初探Java设计模式4：JDK中的设计模式

时间  2021-02-21
标签 java 程序员 设计模式 微信 网络 多线程 app 异步 分布式 ide 栏目 Java 繁體版
原文   原文链接

行为型模式java

行为型模式关注的是各个类之间的相互做用，将职责划分清楚，使得咱们的代码更加地清晰。程序员

策略模式

策略模式太经常使用了，因此把它放到最前面进行介绍。它比较简单，我就不废话，直接用代码说事吧。设计模式

下面设计的场景是，咱们须要画一个图形，可选的策略就是用红色笔来画，仍是绿色笔来画，或者蓝色笔来画。微信

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

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);
   }
}

使用策略的类：app

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);
}

放到一张图上，让你们看得清晰些：分布式

strategy-1​

这个时候，你们有没有联想到结构型模式中的桥梁模式，它们其实很是类似，我把桥梁模式的图拿过来你们对比下：ide

bridge-1​

要我说的话，它们很是类似，桥梁模式在左侧加了一层抽象而已。桥梁模式的耦合更低，结构更复杂一些。

观察者模式

观察者模式对于咱们来讲，真是再简单不过了。无外乎两个操做，观察者订阅本身关心的主题和主题有数据变化后通知观察者们。

首先，须要定义主题，每一个主题须要持有观察者列表的引用，用于在数据变动的时候通知各个观察者：

public class Subject {

   private List<Observer> observers = new ArrayList<Observer>();
   private int state;

   public int getState() {
      return state;
   }

   public void setState(int state) {
      this.state = state;
      // 数据已变动，通知观察者们
      notifyAllObservers();
   }

   public void attach(Observer observer){
      observers.add(observer);        
   }

   // 通知观察者们
   public void notifyAllObservers(){
      for (Observer observer : observers) {
         observer.update();
      }
   }     
}

定义观察者接口：

public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}

其实若是只有一个观察者类的话，接口都不用定义了，不过，一般场景下，既然用到了观察者模式，咱们就是但愿一个事件出来了，会有多个不一样的类须要处理相应的信息。好比，订单修改为功事件，咱们但愿发短信的类获得通知、发邮件的类获得通知、处理物流信息的类获得通知等。

咱们来定义具体的几个观察者类：

public class BinaryObserver extends Observer {

      // 在构造方法中进行订阅主题
    public BinaryObserver(Subject subject) {
        this.subject = subject;
        // 一般在构造方法中将 this 发布出去的操做必定要当心
        this.subject.attach(this);
    }

      // 该方法由主题类在数据变动的时候进行调用
    @Override
    public void update() {
        String result = Integer.toBinaryString(subject.getState());
        System.out.println("订阅的数据发生变化，新的数据处理为二进制值为：" + result);
    }
}

public class HexaObserver extends Observer {

    public HexaObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
          String result = Integer.toHexString(subject.getState()).toUpperCase();
        System.out.println("订阅的数据发生变化，新的数据处理为十六进制值为：" + result);
    }
}

客户端使用也很是简单：

public static void main(String[] args) {
    // 先定义一个主题
      Subject subject1 = new Subject();
      // 定义观察者
      new BinaryObserver(subject1);
      new HexaObserver(subject1);

      // 模拟数据变动，这个时候，观察者们的 update 方法将会被调用
      subject.setState(11);
}

output:

订阅的数据发生变化，新的数据处理为二进制值为：1011
订阅的数据发生变化，新的数据处理为十六进制值为：B

固然，jdk 也提供了类似的支持，具体的你们能够参考 java.util.Observable 和 java.util.Observer 这两个类。

实际生产过程当中，观察者模式每每用消息中间件来实现，若是要实现单机观察者模式，笔者建议读者使用 Guava 中的 EventBus，它有同步实现也有异步实现，本文主要介绍设计模式，就不展开说了。

责任链模式

责任链一般须要先创建一个单向链表，而后调用方只须要调用头部节点就能够了，后面会自动流转下去。好比流程审批就是一个很好的例子，只要终端用户提交申请，根据申请的内容信息，自动创建一条责任链，而后就能够开始流转了。

有这么一个场景，用户参加一个活动能够领取奖品，可是活动须要进行不少的规则校验而后才能放行，好比首先须要校验用户是不是新用户、今日参与人数是否有限额、全场参与人数是否有限额等等。设定的规则都经过后，才能让用户领走奖品。

若是产品给你这个需求的话，我想大部分人一开始确定想的就是，用一个 List 来存放全部的规则，而后 foreach 执行一下每一个规则就行了。不过，读者也先别急，看看责任链模式和咱们说的这个有什么不同？

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

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);
}

代码其实很简单，就是先定义好一个链表，而后在经过任意一节点后，若是此节点有后继节点，那么传递下去。

至于它和咱们前面说的用一个 List 存放须要执行的规则的作法有什么异同，留给读者本身琢磨吧。

模板方法模式

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

一般会有一个抽象类：

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();
}

代码其实很简单，基本上看到就懂了，关键是要学会用到本身的代码中。

状态模式

update: 2017-10-19

废话我就不说了，咱们说一个简单的例子。商品库存中心有个最基本的需求是减库存和补库存，咱们看看怎么用状态模式来写。

核心在于，咱们的关注点再也不是 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 属性了，那样代码会简单不少。

不过，商品库存这个例子毕竟只是个例，咱们还有不少实例是须要知道当前 context 处于什么状态的。

行为型模式总结

行为型模式部分介绍了策略模式、观察者模式、责任链模式、模板方法模式和状态模式，其实，经典的行为型模式还包括备忘录模式、命令模式等，可是它们的使用场景比较有限，并且本文篇幅也挺大了，我就不进行介绍了。

总结

学习设计模式的目的是为了让咱们的代码更加的优雅、易维护、易扩展。此次整理这篇文章，让我从新审视了一下各个设计模式，对我本身而言收获仍是挺大的。我想，文章的最大收益者通常都是做者本人，为了写一篇文章，须要巩固本身的知识，须要寻找各类资料，并且，本身写过的才最容易记住，也算是我给读者的建议吧。

（全文完）

转自https://javadoop.com/post/des...

更多内容请关注微信公众号【Java技术江湖】

这是一位阿里 Java 工程师的技术小站，做者黄小斜，专一 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！（关注公众号后回复”资料“便可领取 3T 免费技术学习资源以及我我原创的程序员校招指南、Java学习指南等资源）

​

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程