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)总结
优点:
- 发送者和接收者都没有对方的信息,只知道请求会被处理,降低系统耦合度;
- 职责链的处理更加灵活,可以动态增加和删除处理者,来改变处理一个请求的职责;
- 增加一个新的请求者无需修改原有代码,只需添加新连接即可,符合开闭原则;
缺点:
- 请求没有明确接收者,可能导致请求走完职责链也并未被处理;
- 请求处理需要多个对象进行处理,系统性能将受一定的影响;
- 创建的连接不当,可能会造成系统死循环;
使用场景:
- 多个对象处理一个请求,请求需要等到运行时才能确定哪一个处理者处理;
- 不明确处理者对象,向多个对象提交一个请求;
- 指定一组对象进行处理,客户端可以动态添加处理对象,并且可以改变顺序;