设计模式精要-优快云博客

来源于架构师训练营第三章，总结。

我们都知道设计模式和基础设计原则是架构师掌握的基础知识，就是学java的人掌握java语法一个道理，那我们在日常开发工作中又怎么对待设计模式呢？我们会刻意的为了一段代码去选择用设计模式吗？今天我们来说一下设计模式。

什么是设计模式

想知道什么是设计模式之前我们需要了解什么是开发原则，可以通过文章《基础框架之设计原则》和文章《设计模式之SOLID原则》了解一些基础概念。

设计模式定义：设计模式是描述一种问题的通用解决方案。这种问题在我们的环境中，不停的出现，为了解决这种问题，抽象出来的一种可以重复使用的解决方案。

设计模式组成部分：一个设计模式总共有四个组成部分；模式名称：由少量字组成的名称，有助于表达我们的设计；待解决问题，什么时候需要用这种设计模式，和运用模式的上下文；解决方案，描述组成的设计元素、关系、职责。一般的解决方案都是抽象的，并不代表具体实现；结论，运用这种方案带来的利和弊，主要是指系统弹性、扩展性、和可移植性等影响。

设计模式划分

设计模式一共23种，我们可以通过类型做作用大致分为三类。

创建型设计模式：主要是对实例化过程的抽象，包括：单例模式、工厂模式、建造者模式、原型模式；
结构型设计模式：将类或者对象结合在一起形成更大的结构，包括：代理模式、桥接模式、装饰器模式、适配器模式、门面模式、组合模式、享元模式；
行为型设计模式：对在不同的对象之间划分责任和算法的抽象画，包括“观察者模式、模板模式、策略模式、职责链模式、迭代器模式、状态模式、访问者模式、备忘录模式、命令模式、解释器模式、中介模式；

我们在不了解设计模式的情况下有用到设计模式吗？但肯定是用的，而且用到的设计模式还不少，只是没有对应到具体的设计模式。

设计模式部分讲解

工厂模式

工厂模式包括简单工厂、工厂方法、抽象工厂这 3 种细分模式。工厂模式用来创建不同但是相关类型的对象（继承同一父类或者接口的一组子类），由给定的参数来决定创建哪种类型的对象。实际上，如果创建对象的逻辑并不复杂，那我们直接通过 new 来创建对象就可以了，不需要使用工厂模式。当创建逻辑比较复杂，是一个“大工程”的时候，我们就考虑使用工厂模式，封装对象的创建过程，将对象的创建和使用相分离。

示例:

public class NodeComponentFactory {

    private final static Map<String,NodeParser> cacheParser = new HashMap<>();

    static {
        cacheParser.put(NodeParserEnum.method.name(),new MethodNodeComponent());
        cacheParser.put(NodeParserEnum.bean.name(),new BeanNodeComponent());
        cacheParser.put(NodeParserEnum.condition.name(),new ConditionNodeComponent());
    }

    public static NodeParser getNodeInstance(String nodeName){
        return cacheParser.get(nodeName);
    }
}

单例模式

单例模式用来创建全局唯一的对象。一个类只允许创建一个对象（或者叫实例），那这个类就是一个单例类，这种设计模式就叫作单例模式。单例有几种经典的实现方式，它们分别是：饿汉式、懒汉式、双重检测、静态内部类、枚举。

public class FlowContext {
    private static FlowContext instance;
    private FlowContext(){}
    public static FlowContext getInstance(){
        if(instance == null){
            synchronized (FlowContext.class){
                if(instance == null){
                    instance = new FlowContext();
                }
            }
        }
        return instance;
    }
}

适配器模式

适配器提供跟原始类不同的接口。适配器模式是用来做适配的，它将不兼容的接口转换为可兼容的接口，让原本由于接口不兼容而不能一起工作的类可以一起工作。适配器模式有两种实现方式：类适配器和对象适配器。其中，类适配器使用继承关系来实现，对象适配器使用组合关系来实现。

public interface Node {
    void setName();
    void setId();
    void setNext();
}
public class MethodNode {
    public void setMethodName(){}
    public void setMethodId(){}
    public void setMethodNext(){}
}
public class BeanNode extends MethodNode implements Node {
    @Override
    public void setName() {
        super.setMethodName();
    }
    @Override
    public void setId() {
        super.setMethodId();
    }
    @Override
    public void setNext() {
        super.setMethodNext();
    }
}

模板模式

模板方法模式在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。这里的“算法”，我们可以理解为广义上的“业务逻辑”，并不特指数据结构和算法中的“算法”。这里的算法骨架就是“模板”，包含算法骨架的方法就是“模板方法”，这也是模板方法模式名字的由来。

public abstract class AbstractNode {
    public void init(String inputUrl, BaseInput baseInput){
        parser();
        setNodeMap();
    }
    public abstract void parser();
    public abstract void setNodeMap();
}
public class TestNode extends AbstractNode{
    @Override
    public void parser() {
        System.out.println("parser");
    }

    @Override
    public void setNodeMap() {
        System.out.println("setNodeMap");
    }
}

策略模式

策略模式定义一组算法类，将每个算法分别封装起来，让它们可以互相替换。策略模式可以使算法的变化独立于使用它们的客户端（这里的客户端代指使用算法的代码）。策略模式用来解耦策略的定义、创建、使用。实际上，一个完整的策略模式就是由这三个部分组成的。

public interface Strategy {
    void test();
}
public class TestAStrategy implements Strategy {
    @Override
    public void test() {
        System.out.println("test");
    }
}
public class TestBStrategy implements Strategy {
    @Override
    public void test() {
        System.out.println("test");
    }
}

组合模式

组合模式主要是用来处理树形结构数据。正因为其应用场景的特殊性，数据必须能表示成树形结构，这也导致了这种模式在实际的项目开发中并不那么常用。但是，一旦数据满足树形结构，应用这种模式就能发挥很大的作用，能让代码变得非常简洁。

装饰器模式

装饰器模式主要解决继承关系过于复杂的问题，通过组合来替代继承，给原始类添加增强功能。这也是判断是否该用装饰器模式的一个重要的依据。除此之外，装饰器模式还有一个特点，那就是可以对原始类嵌套使用多个装饰器。为了满足这样的需求，在设计的时候，装饰器类需要跟原始类继承相同的抽象类或者接口。

public interface IA {
  void f();
}
public class A impelements IA {
    public void f(){ //... }
  }
public class AProxy impements IA {
  private IA a; public AProxy(IA a) { this.a = a; }
  public void f() {
  // 新添加的代理逻辑
  a.f();
  // 新添加的代理逻辑
  }
}