在设计模式中责任链模式的举例（一）

小咪咪 2024-03-22 10:59 62阅读 0赞

在设计模式中责任链模式的举例

一个在线商店需要对用户的购物车进行处理。每个购物车可以包含多个商品，当用户提交购物车时，需要依次对购物车中的商品进行处理，如验证库存、计算价格等。而处理方式可以有不同的实现，并且需要按照一定的顺序执行。

下面是一个基于JAVA的责任链模式的示例代码：

//抽象处理者：处理购物车
    interface ShoppingCartHandler {
        
        void handle(Cart cart);
    }
    
    //具体处理者1：验证库存
    class StockValidationHandler implements ShoppingCartHandler {
        
    
        @Override
        public void handle(Cart cart) {
        
            // 模拟验证库存
            System.out.println("验证库存...");
            for (Item item : cart.getItems()) {
        
                if (item.getQuantity() > 10) {
        
                    System.out.println(item.getName() + " 库存不足！");
                }
            }
    
            // 调用下一个处理者
            if (cart.getNextHandler() != null) {
        
                cart.getNextHandler().handle(cart);
            }
        }
    }
    
    //具体处理者2：计算价格
    class PriceCalculationHandler implements ShoppingCartHandler {
        
    
        @Override
        public void handle(Cart cart) {
        
            // 模拟计算价格
            System.out.println("计算价格...");
            double totalPrice = 0.0;
            for (Item item : cart.getItems()) {
        
                totalPrice += item.getPrice() * item.getQuantity();
            }
            cart.setTotalPrice(totalPrice);
    
            // 调用下一个处理者
            if (cart.getNextHandler() != null) {
        
                cart.getNextHandler().handle(cart);
            }
        }
    }
    
    //具体处理者3：生成订单
    class OrderGenerationHandler implements ShoppingCartHandler {
        
    
        @Override
        public void handle(Cart cart) {
        
            // 模拟生成订单
            System.out.println("生成订单...");
            Order order = new Order(cart.getItems(), cart.getTotalPrice(), new Date());
            System.out.println(order);
    
            // 调用下一个处理者
            if (cart.getNextHandler() != null) {
        
                cart.getNextHandler().handle(cart);
            }
        }
    }
    
    //具体处理者4：发送邮件
    class EmailSendingHandler implements ShoppingCartHandler {
        
    
        @Override
        public void handle(Cart cart) {
        
            // 模拟发送邮件
            System.out.println("发送邮件...");
            System.out.println("尊敬的 " + cart.getUser().getName() + "，您的订单已经处理完毕！");
    
            // 调用下一个处理者
            if (cart.getNextHandler() != null) {
        
                cart.getNextHandler().handle(cart);
            }
        }
    }
    
    //购物车类
    class Cart {
        
        private List<Item> items;
        private double totalPrice;
        private User user;
        private ShoppingCartHandler nextHandler;
    
        public Cart(List<Item> items, User user) {
        
            this.items = items;
            this.user = user;
        }
    
        public List<Item> getItems() {
        
            return items;
        }
    
        public User getUser() {
        
            return user;
        }
    
        public void setTotalPrice(double totalPrice) {
        
            this.totalPrice = totalPrice;
        }
    
        public double getTotalPrice() {
        
            return totalPrice;
        }
    
        public ShoppingCartHandler getNextHandler() {
        
            return nextHandler;
        }
    
        public void setNextHandler(ShoppingCartHandler nextHandler) {
        
            this.nextHandler = nextHandler;
        }
    }
    
    //用户类
    class User {
        
        private String name;
    
        public User(String name) {
        
            this.name = name;
        }
    
        public String getName() {
        
            return name;
        }
    }
    
    //商品类
    class Item {
        
        private String name;
        private double price;
        private int quantity;
    
        public Item(String name, double price, int quantity) {
        
            this.name = name;
            this.price = price;
            this.quantity = quantity;
        }
    
        public String getName() {
        
            return name;
        }
    
        public double getPrice() {
        
            return price;
        }
    
        public int getQuantity() {
        
            return quantity;
        }
    }
    
    //客户端代码
    public class Client {
        
        public static void main(String[] args) {
        
            //创建购物车
            User user = new User("小明");
            List<Item> items = new ArrayList<>();
            items.add(new Item("手机", 3000.0, 2));
            items.add(new Item("电脑", 8000.0, 1));
            Cart   cart = new Cart(items, user);
    
            //设置处理链
            cart.setNextHandler(new StockValidationHandler());
            cart.getNextHandler().setNextHandler(new PriceCalculationHandler());
            cart.getNextHandler().getNextHandler().setNextHandler(new OrderGenerationHandler());
            cart.getNextHandler().getNextHandler().getNextHandler().setNextHandler(new EmailSendingHandler());
    
            //处理购物车
            cart.getNextHandler().handle(cart);
        }
    }

输出结果为：

验证库存...
    计算价格...
    生成订单...
    Order{items=[Item{name='手机', price=3000.0, quantity=2}, Item{name='电脑', price=8000.0, quantity=1}], totalPrice=14000.0, date=Mon Feb 21 15:28:32 CST 2022}
    发送邮件...
    尊敬的 小明，您的订单已经处理完毕！

从中可以看到，当购物车提交时，它会依次被不同的处理者进行处理，处理方式不同但处理顺序是固定的，每个处理者只需要处理自己能处理的部分并传递请求给下一个处理者。这就是责任链模式的应用。