Java基础汇总（二十二）——行为模式

墨蓝 2024-04-03 11:42 80阅读 0赞

**行为型模式关注的是各个类之间的相互作用，将职责划分清楚，使得我们的代码更加地清晰**

**一、策略模式**

例：我们需要画一个图形，可选的策略就是用红色笔来画，还是绿色笔来画，或者蓝色笔来画

首先，先定义一个策略接口：

public interface Strategy {
       public void draw(int radius, int x, int y);
    }

其次，定义具体的几个策略：

public class RedPen implements Strategy {
       @Override
       public void draw(int radius, int x, int y) {
          System.out.println("用红色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
       }
    }
    public class GreenPen implements Strategy {
       @Override
       public void draw(int radius, int x, int y) {
          System.out.println("用绿色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
       }
    }
    public class BluePen implements Strategy {
       @Override
       public void draw(int radius, int x, int y) {
          System.out.println("用蓝色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
       }
    }

使用策略的类：

public class Context {
       private Strategy strategy;
    
       public Context(Strategy strategy){
          this.strategy = strategy;
       }
    
       public int executeDraw(int radius, int x, int y){
          return strategy.draw(radius, x, y);
       }
    }

客户端演示：

public static void main(String[] args) {
        Context context = new Context(new BluePen()); // 使用绿色笔来画
          context.executeDraw(10, 0, 0);
    }

![640294ef3dbe4389bb1cceaa35bd7990.png][]

**策略者模式和桥梁模式：**

*  **相较于策略者模式，桥梁模式在左侧加了一层抽象，桥梁模式的耦合更低，结构更复杂一些**

![3451f0cb9630495780614019bf999f18.png][]

**二、观察者模式**

**观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。**

观察者模式结构图：

![bdfc257580b44126b9f10b715a60831e.png][]

*  **Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象**
 *  **ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知**
 *  **Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己**
 *  **ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态**

**例：微信公众号。假设微信用户就是观察者，微信公众号是被观察者，有多个的微信用户关注了程序猿这个公众号，当这个公众号更新时就会通知这些订阅的微信用户。**

抽象观察者（Observer）

里面定义了一个更新的方法：

public interface Observer {
        public void update(String message);
    }

具体观察者（ConcrereObserver）

微信用户是观察者，里面实现了更新的方法：

public class WeixinUser implements Observer {
        // 微信用户名
        private String name;
        public WeixinUser(String name) {
            this.name = name;
        }
        @Override
        public void update(String message) {
            System.out.println(name + "-" + message);
        }
    
    
    }

抽象被观察者（Subject）

抽象主题，提供了attach、detach、notify三个方法：

public interface Subject {
        /**
         * 增加订阅者
         * @param observer
         */
        public void attach(Observer observer);
        /**
         * 删除订阅者
         * @param observer
         */
        public void detach(Observer observer);
        /**
         * 通知订阅者更新消息
         */
        public void notify(String message);
    }

具体被观察者（ConcreteSubject）

微信公众号是具体主题（具体被观察者），里面存储了订阅该公众号的微信用户，并实现了抽象主题中的方法：

public class SubscriptionSubject implements Subject {
        //储存订阅公众号的微信用户
        private List<Observer> weixinUserlist = new ArrayList<Observer>();
    
        @Override
        public void attach(Observer observer) {
            weixinUserlist.add(observer);
        }
    
        @Override
        public void detach(Observer observer) {
            weixinUserlist.remove(observer);
        }
    
        @Override
        public void notify(String message) {
            for (Observer observer : weixinUserlist) {
                observer.update(message);
            }
        }
    }

客户端调用：

public class Client {
        public static void main(String[] args) {
            SubscriptionSubject mSubscriptionSubject=new SubscriptionSubject();
            //创建微信用户
            WeixinUser user1=new WeixinUser("杨影枫");
            WeixinUser user2=new WeixinUser("月眉儿");
            WeixinUser user3=new WeixinUser("紫轩");
            //订阅公众号
            mSubscriptionSubject.attach(user1);
            mSubscriptionSubject.attach(user2);
            mSubscriptionSubject.attach(user3);
            //公众号更新发出消息给订阅的微信用户
            mSubscriptionSubject.notify("刘望舒的专栏更新了");
        }
    }

结果：

> 杨影枫-刘望舒的专栏更新了  
> 月眉儿-刘望舒的专栏更新了  
> 紫轩-刘望舒的专栏更新了

**观察者模式的使用场景：**

*  **关联行为场景，需要注意的是，关联行为是可拆分的，而不是“组合”关系。**
 *  **事件多级触发场景。**
 *  **跨系统的消息交换场景，如消息队列、事件总线的处理机制。**

**观察者模式的优点：**

*  **解除耦合，让耦合的双方都依赖于抽象，从而使得各自的变换都不会影响另一边的变换。**

**观察者模式的缺点：**

*  **在应用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行**，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。

**三、责任链模式**

**责任链通常需要先建立一个单向链表，然后调用方只需要调用头部节点就可以了，后面会自动流转下去。比如流程审批就是一个很好的例子，只要终端用户提交申请，根据申请的内容信息，自动建立一条责任链，然后就可以开始流转了。**

有这么一个场景，用户参加一个活动可以领取奖品，但是活动需要进行很多的规则校验然后才能放行，比如首先需要校验用户是否是新用户、今日参与人数是否有限额、全场参与人数是否有限额等等。设定的规则都通过后，才能让用户领走奖品。

首先，我们要定义流程上节点的基类：

public abstract class RuleHandler {
    
          // 后继节点
        protected RuleHandler successor;
    
        public abstract void apply(Context context);
    
        public void setSuccessor(RuleHandler successor) {
            this.successor = successor;
        }
        public RuleHandler getSuccessor() {
            return successor;
        }
    }

其次，需要定义具体的每个节点了。

校验用户是否是新用户：

public class NewUserRuleHandler extends RuleHandler {
    
        public void apply(Context context) {
            if (context.isNewUser()) {
                  // 如果有后继节点的话，传递下去
                if (this.getSuccessor() != null) {
                    this.getSuccessor().apply(context);
                }
            } else {
                throw new RuntimeException("该活动仅限新用户参与");
            }
        }
    
    }

校验用户所在地区是否可以参与：

public class LocationRuleHandler extends RuleHandler {
        public void apply(Context context) {
            boolean allowed = activityService.isSupportedLocation(context.getLocation);
              if (allowed) {
                if (this.getSuccessor() != null) {
                    this.getSuccessor().apply(context);
                }
            } else  {
                throw new RuntimeException("非常抱歉，您所在的地区无法参与本次活动");
            }
        }
    }

校验奖品是否已领完：

public class LimitRuleHandler extends RuleHandler {
        public void apply(Context context) {
              // 查询剩余奖品
              int remainedTimes = activityService.queryRemainedTimes(context); 
            if (remainedTimes > 0) {
                if (this.getSuccessor() != null) {
                    this.getSuccessor().apply(userInfo);
                }
            } else {
                throw new RuntimeException("您来得太晚了，奖品被领完了");
            }
        }
    }

客户端：

public static void main(String[] args) {
        RuleHandler newUserHandler = new NewUserRuleHandler();
          RuleHandler locationHandler = new LocationRuleHandler();
          RuleHandler limitHandler = new LimitRuleHandler();
    
          // 假设本次活动仅校验地区和奖品数量，不校验新老用户
          locationHandler.setSuccessor(limitHandler);
          locationHandler.apply(context);
    }

**责任链模式就是先定义好一个链表，然后在通过任意一节点后，如果此节点有后继节点，那么传递下去。**

**四、模板方法模式**

**在含有继承结构的代码中，模板方法模式是非常常用的，这也是在开源代码中大量被使用的。**

通常会有一个抽象类：

public abstract class AbstractTemplate {
        // 这就是模板方法
          public void templateMethod(){
            init();
            apply(); // 这个是重点
            end(); // 可以作为钩子方法
        }
        protected void init() {
            System.out.println("init 抽象层已经实现，子类也可以选择覆写");
        }
          // 留给子类实现
        protected abstract void apply();
        protected void end() {
        }
    }

模板方法中调用了 3 个方法，其中 apply() 是抽象方法，子类必须实现它，其实模板方法中有几个抽象方法完全是自由的，我们也可以将三个方法都设置为抽象方法，让子类来实现。也就是说，模板方法只负责定义第一步应该要做什么，第二步应该做什么，第三步应该做什么，至于怎么做，由子类来实现。

我们写一个实现类：

public class ConcreteTemplate extends AbstractTemplate {
        public void apply() {
            System.out.println("子类实现抽象方法 apply");
        }
          public void end() {
            System.out.println("我们可以把 method3 当做钩子方法来使用，需要的时候覆写就可以了");
        }
    }

客户端调用演示：

public static void main(String[] args) {
        AbstractTemplate t = new ConcreteTemplate();
          // 调用模板方法
          t.templateMethod();
    }

**五、状态模式**

商品库存中心有个最基本的需求是减库存和补库存，我们看看怎么用状态模式来写。

**核心在于，我们的关注点不再是 Context 是该进行哪种操作，而是关注在这个 Context 会有哪些操作**

定义状态接口：

public interface State {
       public void doAction(Context context);
    }

定义减库存的状态：

public class DeductState implements State {
    
       public void doAction(Context context) {
          System.out.println("商品卖出，准备减库存");
          context.setState(this);
    
          //... 执行减库存的具体操作
       }
    
       public String toString(){
          return "Deduct State";
       }
    }

定义补库存状态：

public class RevertState implements State {
        public void doAction(Context context) {
            System.out.println("给此商品补库存");
              context.setState(this);
    
              //... 执行加库存的具体操作
        }
          public String toString() {
            return "Revert State";
        }
    }

前面用到了 context.setState(this)，我们来看看怎么定义 Context 类：

public class Context {
        private State state;
          private String name;
          public Context(String name) {
            this.name = name;
        }
    
          public void setState(State state) {
            this.state = state;
        }
          public void getState() {
            return this.state;
        }
    }

我们来看下客户端调用，大家就一清二楚了：

public static void main(String[] args) {
        // 我们需要操作的是 iPhone X
        Context context = new Context("iPhone X");
    
        // 看看怎么进行补库存操作
          State revertState = new RevertState();
          revertState.doAction(context);
    
        // 同样的，减库存操作也非常简单
          State deductState = new DeductState();
          deductState.doAction(context);
    
          // 如果需要我们可以获取当前的状态
        // context.getState().toString();
    }

**在上面这个例子中，如果我们不关心当前 context 处于什么状态，那么 Context 就可以不用维护 state 属性了，那样代码会简单很多。**

**参考文章：**

[Java-Tutorial/初探Java设计模式3：行为型模式（策略，观察者等）.md at master · h2pl/Java-Tutorial · GitHub][Java-Tutorial_Java_3_.md at master _ h2pl_Java-Tutorial _ GitHub]

[设计模式（五）观察者模式\_刘望舒的博客-CSDN博客\_观察者模式][-CSDN]

[640294ef3dbe4389bb1cceaa35bd7990.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/03ab9986bf904a8e8c5e0be496c859bf.png
[3451f0cb9630495780614019bf999f18.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/11c6fc26c1e2456bbd90f643c30e95e1.png
[bdfc257580b44126b9f10b715a60831e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/aa8000e78b0549a7ba6dd7d3dcafb664.png
[Java-Tutorial_Java_3_.md at master _ h2pl_Java-Tutorial _ GitHub]: https://github.com/h2pl/Java-Tutorial/blob/master/docs/java/design-parttern/%E5%88%9D%E6%8E%A2Java%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F3%EF%BC%9A%E8%A1%8C%E4%B8%BA%E5%9E%8B%E6%A8%A1%E5%BC%8F%EF%BC%88%E7%AD%96%E7%95%A5%EF%BC%8C%E8%A7%82%E5%AF%9F%E8%80%85%E7%AD%89%EF%BC%89.md#%E8%A7%82%E5%AF%9F%E8%80%85%E6%A8%A1%E5%BC%8F
[-CSDN]: https://blog.csdn.net/itachi85/article/details/50773358