设计模式（一）
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;
}
@Override
public 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{
@Override
public 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{//缺省适配器
@Override
public void print() { }
@Override
public void eat() { }
@Override
public void smell() { }
}public class ConcreteService extends AbstractService{
@Override
public 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{
@Override
public 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{//具体工厂
@Override
public 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
@Override
public AbstractProductA createProductA() {
return new ProductA1();
}
@Override
public AbstractProductB createProductB() {
return new ProductB1();
}
}public class ConcreteProduct2 implements AbstractFactory{//具体工厂2
@Override
public AbstractProductA createProductA() {
return new ProductA2();
}
@Override
public AbstractProductB createProductB() {
return new ProductB2();
}
}public interface AbstractProductA {//抽象产品A
public void printA();
}public class ProductA1 implements AbstractProductA{//具体产品A--1
@Override
public void printA() {
System.out.println("产品A类--型号1类型");
}
}public class ProductA2 implements AbstractProductA{//具体产品A---2
@Override
public void printA() {
System.out.println("产品A类--型号2类型");
}
}public interface AbstractProductB {//抽象产品B
public void printB();
}public class ProductB1 implements AbstractProductB{//具体产品B--1
@Override
public void printB() {
System.out.println("产品B类--型号1类型");
}
}public class ProductB2 implements AbstractProductB{//具体产品B--2
@Override
public 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{//具体组件
@Override
public void operation() {
System.out.println("组件操作");
}
}public class Decorator implements Component{//抽象装饰器
private Component component;
public Decorator(Component component){
this.component=component;
}
@Override
public void operation() {
component.operation();
}
}public class ConcreteDecoratorA extends Decorator{//具体装饰类
public ConcreteDecoratorA(Component component) {
super(component);
}
@Override
public void operation() {
super.operation();
addState();
}
public void addState(){
System.out.println("添加机器状态");
}
}public class ConcreteDecoratorB extends Decorator {//具体装饰类
public ConcreteDecoratorB(Component component) {
super(component);
}
@Override
public 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{//具体建造类
@Override
public void buildPathA(String value) {
product.setA(value);
}
@Override
public 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 getChild();//获取子类
public abstract void print();//输出文件
} public class OssLeaf extends Component{//叶子组件
private String name;
public OssLeaf(String name){
this.name=name;
}
@Override
public void add(Component component) {
System.out.println("异常处理");
}
@Override
public void remove(Component component) {
System.out.println("异常处理");
}
@Override
public List getChild() {
return null;
}
@Override
public void print() {
System.out.println("输出"+name+"文件");
}
} public class TxtLeaf extends Component{//叶子组件
private String name;
public TxtLeaf(String name){
this.name=name;
}
@Override
public void add(Component component) {
System.out.println("异常处理");
}
@Override
public void remove(Component component) {
System.out.println("异常处理");
}
@Override
public List getChild() {
return null;
}
@Override
public void print() {
System.out.println("输出"+name+"文件类型");
}
} public class Composite extends Component{//容器组件
//记录该组件的子组件（叶子组件、容器组件）
private List componentList=new ArrayList<>();
private String name;
public Composite(String name){
this.name=name;
}
@Override
public void add(Component component) {
componentList.add(component);
}
@Override
public void remove(Component component) {
componentList.remove(component);
}
@Override
public List getChild() {
return componentList;
}
@Override
public 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 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{//具体目标类
@Override
public void notifyObserver(String name) {
//通知每一个观察者处理error
for (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;
}
//处理错误
@Override
public void dealError() {
System.out.println(name+"来处理error了");
}
//发生错误
@Override
public 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-20000
public 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）总结
优点：
- 发送者和接收者都没有对方的信息，只知道请求会被处理，降低系统耦合度；
- 职责链的处理更加灵活，可以动态增加和删除处理者，来改变处理一个请求的职责；
- 增加一个新的请求者无需修改原有代码，只需添加新连接即可，符合开闭原则；
缺点：
- 请求没有明确接收者，可能导致请求走完职责链也并未被处理；
- 请求处理需要多个对象进行处理，系统性能将受一定的影响；
- 创建的连接不当，可能会造成系统死循环；
使用场景：
- 多个对象处理一个请求，请求需要等到运行时才能确定哪一个处理者处理；
- 不明确处理者对象，向多个对象提交一个请求；
- 指定一组对象进行处理，客户端可以动态添加处理对象，并且可以改变顺序；