设计模式（一）

1、适配器模式

（1）概述

• 适配器中有一个适配器包装类Adapter，其包装的对象为适配者Adaptee，适配器作用就是将客户端请求转化为调用适配者中的接口；
• 当调用适配器中的方法时，适配器内部会调用适配者类的方法，这个调用对客户端是透明，实现了不同接口之间由于不兼容的类，可以相互调用；

（2）对象适配器

• Target（目标抽象类）：可以是一个抽象类或接口，该类为客户端所需要的接口；
• Adapter（适配器类）:Adapter可以调用另外一个接口，对Target和Adaptee进行适配，Target通过Adapter可以调用Adaptee中的业务逻辑，对客户端是透明的；
• Adaptee（适配者类）：定义了一个已经存在的接口，适配者类一般是一个具体的类，包含了客户需要调用的业务方法；
• Adapter和Adaptee是关联关系；

//适配器
public class Adapter implements Target{private MySQLConnect mySQLConnect;//适配者对象public Adapter(MySQLConnect mySQLConnect){this.mySQLConnect=mySQLConnect;}@Overridepublic void connect() {mySQLConnect.mysqlConnect();}
}

public interface Target {public void connect();
}

//适配者
public class MySQLConnect {public void mysqlConnect(){System.out.println("数据库链接配置");}
}

//测试
public class Main {public static void main(String[] args) {Target target=new Adapter(new MySQLConnect());target.connect();}
}

（3）类适配器

• 适配器和适配者之间的关系为继承；
• 适配器实现了Target接口，继承了Adapteee类；
• 当Target不是接口，而是抽象类，则无法使用类适配器，当Adaptee类被final修饰，也不能使用类适配器；

//适配器类，其他代码和上一样
public class Adapter extends MySQLConnect implements Target{@Overridepublic void connect() {mysqlConnect();}
}

（3）缺省适配器

• ServiceInterface（适配者接口）：为一个接口，实现大量方法；
• AbstractServiceClass（缺省适配器类）：实现了适配者接口中所有方法，使用空方法形式；
• ConcreteServiceClass（业务类）：为缺省适配器的子类，在没有适配器之前，该类需要实现ServiceInterface中所有方法，引入适配器类后，只需要继承适配器类，实现对应的方法即可；

public interface ServiceInterface {public void print();public void eat();public void smell();
}

public class AbstractService implements ServiceInterface{//缺省适配器@Overridepublic void print() { }@Overridepublic void eat() { }@Overridepublic void smell() { }
}

public class ConcreteService extends AbstractService{@Overridepublic void print() {//重写打印接口System.out.println("打印");}
}

（4）总结

优点：

• 目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，无序修改原有代码结构；
• 增加了类的透明性和复用性，将业务代码封装在适配者类中，对于用户是透明的，同时适配者类可以被多个不同系统调用
• 灵活性和扩展性好，通过配置文件切换适配器类，可以在原有基础上添加新的适配器类，符合开闭原则；

缺点：

• 类适配器中只能适配一个适配者类，java不能多继承；
• 对象适配器，在适配器重置换适配者类比较麻烦，需要先创建一个适配者类的子类，重写需要置换的方法，然后再将适配器适配到这个子类；

使用场景：

• 系统需要使用已有的接口，而这些接口不符合系统需求，甚至没有源代码；
• 想创建一个可以重复使用的类，用于一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作；

2、工厂方法模式

（1）概述

• 工厂方法定义一个创建对象的接口，让实现该接口的子类取实例化对象。
• 工厂方法将对象的实例化延迟到其子类创建；

（2）角色

• Product（抽象产品）：定义产品接口（某个类型产品），是工厂方法模式中，所有创建对象的公共父类；
• ConcreteProduct（具体产品）：实现抽象产品的接口，即某种类型的具体产品，与一个具体工厂一一对应；
• Factory（抽象工厂）：创建对象工厂的接口，声明工厂方法（Factory Method），用于返回一个产品，所有创建对象的工厂类都需要实现该接口；
• ConcreteFactory（具体工厂）：实现抽象工厂的工厂方法，返回一个具体的产品；

（3）实现

public interface Factory {public Product create();
}

public class MySQLFactory implements Factory{@Overridepublic Product create() {return new MySQLProduct();}
}

public abstract class Factory {//抽象工厂public void connect(){//对客户端隐藏调用具体产品的方法Product product = this.create();product.connect();}public abstract Product create();
}

public class MySQLFactory extends Factory{//具体工厂@Overridepublic Product create() {return new MySQLProduct();}
}

public class Main {public static void main(String[] args) {Factory factory=new MySQLFactory();//可以通过配置文件配置，进行工厂方法切换factory.connect();}
}

（4）总结

优点

• 客户端只需要知道创建对象的工厂方法，工厂方法隐藏具体具体对象被实例化的细节，客户端无需关系对象如何创建，甚至无需关心对象的具体类名；
• 当需要加入一个新的对象产品时，无需修改原系统，只需要新增一个具体对象类和对应的工厂类即可；

缺点：

• 每新增一个产品，就需要新增对应的产品类和工厂类，增加系统复杂度，同时由更多类需要被系统加载，会给系统带来一些而外的开销；
• 引入抽象层，增加系统抽象性和可理解性；

使用场景：

• 客户端不知道他所需要的类；
• 抽象工厂类通过子类创建对象；

3、抽象工厂模式

（1）概述

• 产品等级结构：即产品的继承结构，一个抽象产品，多个相同的产品继承该抽象产品，一个抽象产品与其子类构成一个产品等级结构。如：电视机为抽象类，则海尔电视机，华普电视机，创维电视机为其子类，共同构成一个产品等级结构；
• 产品族：产品族是由同一个工厂产生的，位于不同产品等级结构的一组产品；
• 一个工厂负责生产一个产品族（即下图颜色相同的）；
• 抽象工厂会提供一个创建一系列相关或相互依赖的对象的接口，而无需指定他们的具体实现类；

（2）角色

• AbstractFactory（抽象工厂）：声明一些列创建产品族的方法，每一个方法对应一个产品；
• ConcreteFactory（具体工厂）：实现抽象工厂中的方法，用于创建一组具体产品，这些具体产品构成一个产品族，位于一个产品等级结构中；
• AbstractProduct（抽象产品）：为每种产品生成一种接口，在抽象产品中声明了产品所具有的业务方法；
• ConcreteProduct（具体产品）：他定义具体工厂生成的产品对象，实现抽象产品接口中声明的业务方法；

（3）实现

public interface AbstractFactory {//抽象工厂public AbstractProductA createProductA();public AbstractProductB createProductB();
}

public class ConcreteProduct1 implements AbstractFactory{//具体工厂1@Overridepublic AbstractProductA createProductA() {return new ProductA1();}@Overridepublic AbstractProductB createProductB() {return new ProductB1();}
}

public class ConcreteProduct2 implements AbstractFactory{//具体工厂2@Overridepublic AbstractProductA createProductA() {return new ProductA2();}@Overridepublic AbstractProductB createProductB() {return new ProductB2();}
}

public interface AbstractProductA {//抽象产品Apublic void printA();
}

public class ProductA1 implements AbstractProductA{//具体产品A--1@Overridepublic void printA() {System.out.println("产品A类--型号1类型");}
}

public class ProductA2 implements AbstractProductA{//具体产品A---2@Overridepublic void printA() {System.out.println("产品A类--型号2类型");}
}

public interface AbstractProductB {//抽象产品Bpublic void printB();
}

public class ProductB1 implements AbstractProductB{//具体产品B--1@Overridepublic void printB() {System.out.println("产品B类--型号1类型");}
}

public class ProductB2 implements AbstractProductB{//具体产品B--2@Overridepublic void printB() {System.out.println("产品B类--型号2类型");}
}

public class Main {//测试类public static void main(String[] args) {System.out.println("工厂1生成对应1号类型的产品族");AbstractFactory factory1=new ConcreteProduct1();factory1.createProductA().printA();factory1.createProductB().printB();System.out.println("工厂2生成对应的2号类型的产品族");AbstractFactory factory2=new ConcreteProduct2();factory2.createProductA().printA();factory2.createProductB().printB();}
}

（4）总结

优点：

• 客户端不需要知道产品如何创建，如果需要切换产品，更换一个具体工厂即可；
• 增加新的产品族十分方便，无需修改原系统，符合开闭原则；

缺点：

• 添加一个产品等级结构系列时，需要从修改原有系统中的所有工厂方法，不符合开闭原则；

使用场景：

• 一个系统不依赖对象的创建，组合，客户端无需知道对象如何创建；
• 系统中有多个产品族，每次只使用一个产品族；
• 同一个产品族中的产品将在一起使用，同一个产品族的产品可以没有任何关系，但必须是有一总共同约束；

4、装饰器模式

（1）概述

• 装饰模式可以在不改变原有对象的模式下，增加额外行为；
• 可以动态给对象增加一些职责；

（2）角色

• Component（抽象组件）：他是具体组件和装饰组件的父类，声明了具体组件实现的业务方法，为客户端提供以一致方式处理装饰前以及装饰后的组件；
• ConcreteComponent（具体组件）：Component的子类，用于定义具体的组件方法，装饰器类可以给他增加额外职责；
• Decorator（抽象装饰类）：Component子类，用于给具体组件添加新的职责，他维护一个指向抽象组件的应用，通过该应用可以调用装饰之前的组件，并通过起子类扩展职责；
• ConcreteDecorator（具体装饰类）：抽象装饰类的子类，负责向具体组件添加新的职责；

（3）实现

public interface Component {//抽象组件public void operation();
}

public class ConcreteComponent implements Component{//具体组件@Overridepublic void operation() {System.out.println("组件操作");}
}

public class Decorator implements Component{//抽象装饰器private Component component;public Decorator(Component component){this.component=component;}@Overridepublic void operation() {component.operation();}
}

public class ConcreteDecoratorA extends Decorator{//具体装饰类public ConcreteDecoratorA(Component component) {super(component);}@Overridepublic void operation() {super.operation();addState();}public void addState(){System.out.println("添加机器状态");}
}

public class ConcreteDecoratorB extends Decorator {//具体装饰类public ConcreteDecoratorB(Component component) {super(component);}@Overridepublic void operation() {super.operation();addMoney();}public void addMoney(){System.out.println("加钱，买更多机器投入操作");}
}

public class Main {//main方法public static void main(String[] args) {Component component=new ConcreteComponent();System.out.println("装饰器A-----------");Decorator decorator=new ConcreteDecoratorA(component);decorator.operation();System.out.println("装饰器B---------------");decorator=new ConcreteDecoratorB(component);decorator.operation();}
}

（4）总结

优点：

• 装饰器比继承更加灵活，不会导致类个数急剧增加；
• 可以动态的扩展一个对象功能，通过配置类可以在运行时选择不同的配置类，从而实现不同行为；
• 可以对一个对象装饰多次，采用不同1装饰类可以组装出多个不同的行为；
• 具体的组件类和装饰类可以独立添加，可以根据需要添加新的构建类和组件类，符合开闭原则；

缺点：

• 会产生大量的小对象，这些小对象随着不断累积，会消耗大量内存；
• 对于排错，需要多级查找；

使用场景：

• 在不影响其他对象的情况下，动态，透明的给一个对象添加职责；
• 系统中存在大量独立的类，不可以使用装饰器模式，否则会产生大量的子类；

5、建造者模式

（1）概述

• 将一个复杂对象的构建与他的表示分离，使得同样构建过程可以创建不同的表示；
• 不同的具体建造者定义不同的创建过程，且具体的建造者相互独立，增加新的建造者非常方便；

（2）角色

• Builder（抽象建造者）：他为建造复杂对象的各个部件定义接口，在接口中声明方法中，一类是buildProductX方法，用于构建各个组件，另外一类为getProduct（）方法，用于获取构建后的对象；既可以是接口，也可以是抽象类；
• Concretebuilder（具体建造者）：实现Builder接口，实现各个构造组件的方法，并实现返回一个对象的方法；
• Product（产品）：具体的构建对象，包含多个组件，由ConcreteBuilder装配；
• Director（指挥者）：定义一个construct（）方法，复杂组件装配的顺序，返回构造好的对象，一般该类与客户端进行交互；内部维护一个Builder类；
• 复杂对象：包含多个属性的对象；

（3）实现

@Data
public class Product {//产品类private String A;private String B;
}

public abstract class Builder {//建造者抽象类protected Product product=new Product();public abstract void buildPathA(String value);public abstract void buildPathB(String value);public Product getProduct(){return this.product;}
}

public class ConcreteBuilder extends Builder{//具体建造类@Overridepublic void buildPathA(String value) {product.setA(value);}@Overridepublic void buildPathB(String value) {product.setB(value);}
}

public class Director {//指挥者类private Builder builder;public Director(Builder builder){this.builder=builder;}public Product construct(String A,String B){builder.buildPathA(A);builder.buildPathB(B);return builder.getProduct();}
}

public class Main {public static void main(String[] args) {Builder builder=new ConcreteBuilder();Product product=new Director(builder).construct("属性A","属性B");System.out.println(product.getA());System.out.println(product.getB());}
}

（4）总结

优点：

• 在建造者模式中，客户端不必直到内部如何构建，将产品本身与产品构建之间解耦，使得相同的构建过程可以构建不同的产品；
• 每一个构建者相对独立，客户端可以很方便的添加新的构造者，同时增加新的构造者，不用修改原有的代码符合开闭原则；

缺点：

• 产品之间相差过大，各个组成部分由较大差异，不适合使用该模式；
• 产品的组件变化复杂，需要定义过多的构造类来实现这种变化，导致系统过于庞大；

使用场景：

• 需要生成复杂对象，这些对象通常包含多个属性；
• 对象之间的属性相互依赖，且由一定的顺序性；
• 隔离复杂对象的创建和使用，使得相同的创建过程可以构建出不同的对象；

6、组合模式

（1）概述

• 组合多个对象成为树形结构，对于叶子对象和容器对象的操作都具有一致性；
• 当调用容器对象的某一个方法时，将会遍历整个树，寻找包含这个方法的成员变量，使用递归对整个树结构进行调用；
• 叶子对象：没有字节点；
• 容器对象：包含多个叶子对象和多个容器对象；

（2）角色

• Component（抽象构件）：为叶子构件和容器构件声明了接口，定义了其子类共有的行为方法；
• Leaf（叶子构件）：实现了Component接口中的行为方法，没有子节点；
• Composite（容器构件）：该节点有子节点，子节点可以是容器节点，也可以是叶子节点。有一个列表属性，用于存储子节点，实现了Component接口定义的行为方法，该方法可以递归调用子节点的业务方法；同时包含管理子构建的方法；

（3）实现

public abstract class Component {//抽象组件public abstract void add(Component component);//添加构建public abstract void remove(Component component);//删除构建public abstract List<Component> getChild();//获取子类public abstract void print();//输出文件
}

public class OssLeaf extends Component{//叶子组件private String name;public OssLeaf(String name){this.name=name;}@Overridepublic void add(Component component) {System.out.println("异常处理");}@Overridepublic void remove(Component component) {System.out.println("异常处理");}@Overridepublic List<Component> getChild() {return null;}@Overridepublic void print() {System.out.println("输出"+name+"文件");}
}

public class TxtLeaf extends Component{//叶子组件private String name;public TxtLeaf(String name){this.name=name;}@Overridepublic void add(Component component) {System.out.println("异常处理");}@Overridepublic void remove(Component component) {System.out.println("异常处理");}@Overridepublic List<Component> getChild() {return null;}@Overridepublic void print() {System.out.println("输出"+name+"文件类型");}
}

public class Composite extends Component{//容器组件//记录该组件的子组件（叶子组件、容器组件）private List<Component> componentList=new ArrayList<>();private String name;public Composite(String name){this.name=name;}@Overridepublic void add(Component component) {componentList.add(component);}@Overridepublic void remove(Component component) {componentList.remove(component);}@Overridepublic List<Component> getChild() {return componentList;}@Overridepublic void print() {System.out.println("输出"+name+"类型的文件，输出如下：");//调用子类的方法for (Component component : componentList) {component.print();}}
}

public class Main {//测试方法public static void main(String[] args) {OssLeaf ossLeaf1=new OssLeaf("图片");OssLeaf ossLeaf2=new OssLeaf("视频");TxtLeaf txtLeaf=new TxtLeaf("txt");TxtLeaf txtLeaf1=new TxtLeaf("docx");TxtLeaf txtLeaf2=new TxtLeaf("pptx");Composite composite1=new Composite("oss类型文件");composite1.add(ossLeaf1);composite1.add(ossLeaf2);composite1.print();Composite composite2=new Composite("文本类型文件");composite2.add(txtLeaf);composite2.add(txtLeaf1);composite2.add(txtLeaf2);composite2.print();}
}

（4）总结

优点：

• 在新增新的叶子组件或容器组件时，无需修改原有代码，符合开闭原则；
• 忽略客户端层次差异，方便对整个层次进行控制；

缺点：新增新的组件时，难以对组件的类型进行控制；

使用场景：

• 需要处理一个树型结构；
• 系统中可以分离出叶子组件和容器组件，类型不固定，需要增加一些新的类型；
• 整体和部分具有层次结构，需要处理忽略他们的层次差，使用客户端一致调用这些业务方法；

7、观察者模式

（1）概述

• 定义一种一堆多的关系，使得每当一个对象发生改变时，会通知其关联对象并自动更新；
• 发生改变的对象为观察目标，而被通知的对象为观察者，这些观察者之间没有任何联系；

（2）角色

• Subject（目标）：被观察的对象，在目标中定义了一个观察者对象集合，提供删除，添加观察者的方法，同时定义了通知方法notify，可以是接口，抽象类或具体类；
• ConcreteSubject（具体目标）：Subject的子类，他包含发生改变的数据，当该数据发生改变时，会通知集合中的观察者，同时还实现目标类中的抽象业务方法；（无需扩展目标类，该类可以省略）
• Observer（抽象观察者）：观察者对改变做出响应，一般为接口，声明update方法；
• ConcreteObserver（具体观察者）：实现抽象观察者中的update方法，同时维护一个ConcreteSubject对象的应用，存储具体观察者有关状态，该状态需要与目标对象状态一致；

（3）实现

public abstract class Subject {//抽象目标public List<Observer> observerList=new ArrayList<>();//观察者集合public void add(Observer observer){//添加观察者observerList.add(observer);}public void delete(Observer observer){//删除观察者observerList.remove(observer);}public abstract void notifyObserver(String name);}

public class ConcreteSubject extends Subject{//具体目标类@Overridepublic void notifyObserver(String name) {//通知每一个观察者处理errorfor (Observer observer : observerList) {if (!((ConcreteObserver) observer).getName().equals(name)){observer.dealError();}}}
}

public interface Observer {//抽象观察者public void dealError();//在发生error时触发public void error(Subject subject);
}

public class ConcreteObserver implements Observer{//具体观察者private String name;public ConcreteObserver(String name){this.name=name;}public String getName(){return this.name;}//处理错误@Overridepublic void dealError() {System.out.println(name+"来处理error了");}//发生错误@Overridepublic void error(Subject subject) {System.out.println(name+"发生error，都来处理error");subject.notifyObserver(name);}
}

public class Main {public static void main(String[] args) {Subject subject=new ConcreteSubject();Observer observer1=new ConcreteObserver("A");Observer observer2=new ConcreteObserver("B");Observer observer3=new ConcreteObserver("C");subject.add(observer1);subject.add(observer2);subject.add(observer3);observer1.error(subject);}
}

（4）总结

优点：

• 观察者适合广播通信，目标对象发生改变时，会通知所有订阅目标的观察者；
• 添加具体观察者，无需修改原有代码，每一个观察者之间无任何联系，符合开闭原则；

缺点：

• 目标类如果有过多的观察者，通知时会耗费大量时间；
• 观察者和目标之间存在循环依赖，通知时，会导致死循环；
• 观察者无法直到观察对象是如何变化的，只能直到该对象发生了变化；

使用场景：

• 一个对象发生改变会影响多个对象，而这些对象之间相互无任何联系；
• 链式触发，如A影响B，B影响C，。。。；

8、责任链模式

（1）概述

避免请求发送者和接收者耦合在一起，让多个对象都可以接收请求，将这些对象合成一条链，并且沿着这条链传递请求，直到有对象处理该请求为止；

（2）角色

• Handler（抽象处理者）：定义了一个处理请求的接口，不同的处理者对每一个请求的处理方式不同，因此定义抽象处理者。每一个处理者的下一个还是处理者，在抽象类中定义一个处理者对象，用于对下一个处理者的调用；
• ConcreteHandler（具体处理者）：抽象处理者的实现类，实现具体的请求处理方法，处理请求之前需要先判断是否有权限处理，有则处理，否则将请求转发给下一个处理者；

（3）实现

@Data
public abstract class Handler {protected Handler handler;//下一个处理者protected String name;//姓名public Handler(String name){this.name=name;}//处理请求逻辑方法public abstract void processorHandler(int money);
}

public class ConcreteHandlerA extends Handler{public ConcreteHandlerA(String name){super(name);}@Override//可以审批5000元以下public void processorHandler(int money) {if (money<=5000){System.out.println(name+"进行审批，审批通过");}else {System.out.println(name+"无法审批金额，流转下一个审批者");handler.processorHandler(money);}}
}

public class ConcreteHandlerB extends Handler{public ConcreteHandlerB(String name){super(name);}@Override//可以审批5000-20000public void processorHandler(int money) {if (money>5000&&money<=20000){System.out.println(name+"进行审批，审批通过");}else {System.out.println(name+"无法审批金额，流转下一个审批者");handler.processorHandler(money);}}
}

public class ConcreteHandlerC extends Handler{public ConcreteHandlerC(String name){super(name);}@Override//可以审批20000以上public void processorHandler(int money) {if (money>20000){System.out.println(name+"进行审批，审批通过");}else {System.out.println(name+"无法审批金额，流转下一个审批者");handler.processorHandler(money);}}
}

public class Main {public static void main(String[] args) {Handler handlerA=new ConcreteHandlerA("主管");Handler handlerB=new ConcreteHandlerB("经理");Handler handlerC=new ConcreteHandlerC("董事长");//设置下一个处理者handlerA.setHandler(handlerB);handlerB.setHandler(handlerC);handlerA.processorHandler(30000);}
}

（4）总结

优点：

• 发送者和接收者都没有对方的信息，只知道请求会被处理，降低系统耦合度；
• 职责链的处理更加灵活，可以动态增加和删除处理者，来改变处理一个请求的职责；
• 增加一个新的请求者无需修改原有代码，只需添加新连接即可，符合开闭原则；

缺点：

• 请求没有明确接收者，可能导致请求走完职责链也并未被处理；
• 请求处理需要多个对象进行处理，系统性能将受一定的影响；
• 创建的连接不当，可能会造成系统死循环；

使用场景：

• 多个对象处理一个请求，请求需要等到运行时才能确定哪一个处理者处理；
• 不明确处理者对象，向多个对象提交一个请求；
• 指定一组对象进行处理，客户端可以动态添加处理对象，并且可以改变顺序；