java常用设计模式

最新推荐文章于 2022-06-03 19:39:42 发布

一位大腿

最新推荐文章于 2022-06-03 19:39:42 发布

阅读量246

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/anyudong1016/article/details/115557325

版权

笔记专栏收录该内容

14 篇文章 0 订阅

订阅专栏

本文介绍了设计模式的作用，如重用设计、提高扩展性和灵活性，以及提升开发效率。文章详细阐述了创建型、结构型和行为型设计模式的分类，并分别对工厂方法模式、抽象工厂模式、建造者模式、单例模式、原型模式、外观模式、装饰模式、代理模式和责任链模式等进行了讲解，提供了相应的图示和代码示例。

摘要由CSDN通过智能技术生成

一、设计模式作用

重用设计和代码（设计重用更有意义，因为设计的重用会带来代码的重用）
提高了扩展性（因大量使用面向对象接口编程，预留了扩展能力）
提高了灵活性（因大量使用组合而不是继承，使得一处的修改不会涉及很多模块）
提高开发效率（节省时间）

二、设计模式分类

按解决的问题可分为：创建型设计模式、结构型设计模式、行为型设计模式。

创建型设计模式：对象实例化的模式 (可以理解为构造方法new)，用于解耦对象实例化过程。
包括：工厂方法模式、抽象工厂模式、建造者模式、单例模式、原型模式等。
结构型设计模式：将类和对象结合在一起形成一个大结构（可以理解为变量）。
包括：外观模式、装饰模式、代理模式等。
行为型设计模式：类和对象如何交互，划分责任和算法。（方法）
包括：责任链模式、模板模式、策略模式等。

按处理对象间还是父子类关系可分为：类设计模式（静态的）和对象设计模式（动态的，在运行期间可变化）。

（1）创建型设计模式

解耦对象实例化过程，创建对象时隐藏创建逻辑，不再是 new 运算符直接实例化对象，使得创建对象更加灵活，创建和使用分离，只需知道接口不用知道细节。

简单工厂模式（不属于23种经典设计模式，不符合开闭原则，但有助于后续理解）

原理：由工厂类根据传入的参数来判断应该创建产品的那个子类，且以产品类(父类)形式返回。
包含角色：(未抽象化)工厂(提供可被外界调用的静态方法，创建相应产品对象)，抽象产品(产品父类/接口，有通用接口)，具体产品(子类，是创建目标)
优点：产品的创建和使用分开，降低了客户端代码难度
缺点：若增减子类需要改工厂类，不符合开闭原则。如果子类太多不方便
图示：
代码示例：所有产品有一个共同的接口或者父类

/**
 * 这是一个产品接口，里面有要输出的操作
 * 所有产品有一个共同的接口或者父类，它们是一个系列，例如:都是手机
 */
public interface Product {

    public void output1();

    public void output2();
}

/**
 * 有三个产品子类来实现了产品接口
 */
 
//产品1
public class Product1 implements Product{
    @Override
    public void output1() {
        System.out.println("Product1: output1");
    }

    @Override
    public void output2() {
        System.out.println("Product1: output2");
    }
}

//产品2
public class Product2 implements Product{
    @Override
    public void output1() {
        System.out.println("Product2: output1");
    }

    @Override
    public void output2() {
        System.out.println("Product2: output2");
    }
}

//产品3
public class Procuct3 implements Product{
    @Override
    public void output1() {
        System.out.println("Product3: output1");
    }

    @Override
    public void output2() {
        System.out.println("Product3: output2");
    }
}

/**
 * 这是一个工厂类
 * static：可以通过工厂名直接访问方法
 * type：根据传人的type类型来判断要new哪个子类
 */
public class Factory {
    public Product getProduct(String type){
        Product product = null;
        if("1".equals(type)){
            product = new Product1();
        }else if("2".equals(type)){
            product = new Product2();
        }else{
            product = new Procuct3();
        }
        return product;
    }
}

/**
 * 这是一个测试类
 */
public class Test {
    public static void main(String[] args) {
        //创建一个工厂
        //Factory factory = new Factory();
        //不需要创建某个产品，直接从工厂获取
        //Product product = factory.getProduct("1");

        //可以不创建工厂，但是要在工厂中的方法上加static
        Product product = Factory.getProduct("1");
        product.output1();//输出Product1: output1
        product.output2();//输出Product1: output2
    }
}

工厂方法模式

与简单工厂模式不同的是，工厂方法模式将工厂类也进行了抽象化。
工厂不再负责产品生产，而是指定规则，将创建任务交给子类完成。
符合了开闭原则，虽不用修改工厂类，但增加产品子类的时候也要增加工厂子类，增加了工作量。
图示：
代码示例：

/**
 * 这是一个运算的抽象类
 */
public abstract class Operation {

    protected int num1;

    protected int num2;

    public Operation() {
    }

    public Operation(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
    }

    public int getNum1() {
        return num1;
    }

    public void setNum1(int num1) {
        this.num1 = num1;
    }

    public int getNum2() {
        return num2;
    }

    public void setNum2(int num2) {
        this.num2 = num2;
    }

    //定义一个运算方法
    public abstract int operationMethod();
}

/**
 * 实现Operation中的运算接口
 */
public class Addition extends Operation {

    @Override
    public int operationMethod() {
        return num1 + num2;
    }
}

class Subtraction extends Operation {

    @Override
    public int operationMethod() {
        return num1 - num2;
    }
}

/**
 * 这是一个抽象工厂
 */
public abstract class Factory {
    /**创建一个运算对象
     * @return
     */
    public abstract Operation getMethod();
}

/**
 * 实现Factory中的get接口，来new不同的运算子类
 */
public class AddFactory extends Factory {
    @Override
    public Operation getMethod() {
        return new Addition();
    }
}

class SubtractFactory extends Factory {
    @Override
    public Operation getMethod() {
        return new Subtraction();
    }
}

public class Test {
    public static void main(String[] args) {
        //创建一个工厂,这是一个加法的
        Factory factory = new AddFactory();
        //从工厂中获取产品
        Operation operation = factory.getMethod();
        operation.setNum1(1);//或 operation.num1 = 1;
        operation.setNum2(2);

        //调用运算方法
        int res = operation.operationMethod();
        System.out.println(res);//输出3
    }
}

抽象工厂模式

一个工厂负责(创建)多个产品族，更换产品组时更新一个工厂类即可。例如:产品族是一套手机产品，包含了手机和充电线等。
但组装的过程需要在客户端进行，可能会造成客户端代码复杂。但如果在工厂中进行，则不符合单一职责。
图示
代码示例：

/**
 * 这是一个手机接口，可以获取手机的类型
 */
public interface Phone {
    public void getPhoneType();
}

/**
 * 这是一个充电线接口，可以获取充电线的类型
 */
public interface ChargingLine {
    public void getLineType();
}

//小米手机实例
public class XiaomiPhone implements Phone{
    @Override
    public void getPhoneType() {
        System.out.println("小米手机");
    }
}

//华为手机实例
class HuaweiPhone implements Phone{
    @Override
    public void getPhoneType() {
        System.out.println("华为手机");
    }
}

//小米充电线实例
public class XiaomiLine implements ChargingLine{
    @Override
    public void getLineType() {
        System.out.println("小米充电线");
    }
}

//华为充电线实例
class HuaweiLine implements ChargingLine{
    @Override
    public void getLineType() {
        System.out.println("华为充电线");
    }
}

/**
 * 这是一个手机工厂，里面有手机和充电线接口
 */
public interface PhoneFactory {
    Phone getPhone();

    ChargingLine getLine();
}

//华为的手机工厂
public class HuaweiFactory implements PhoneFactory{

    @Override
    public Phone getPhone() {
        return new HuaweiPhone();
    }

    @Override
    public ChargingLine getLine() {
        return new HuaweiLine();
    }
}

//小米的手机工厂
class XiaomiFactory implements PhoneFactory{

    @Override
    public Phone getPhone() {
        return new XiaomiPhone();
    }

    @Override
    public ChargingLine getLine() {
        return new XiaomiLine();
    }
}

public class Test {
    public static void main(String[] args) {
        //创建一个华为的工厂，     如果手机比较复杂，则组装就比较复杂，所以就有了建造者模式。
        PhoneFactory factory = new HuaweiFactory();
        //获取手机
        Phone phone = factory.getPhone();
        //获取充电线
        ChargingLine line = factory.getLine();
        phone.getPhoneType();//华为手机
        line.getLineType();//华为充电线
    }
}

建造者模式

该模式就是在抽象工厂模式的基础上，单独提供了一个组装类
主要产品要有共同点。

单例模式

一个类只有一个实例，可自行实例化并向系统提供该实例。
饿汉单例模式

/**
 * 饿汉单例模式：
 * 1.构造方法是private
 * 2.提供自身类型的成员变量，且是 private static
 * 3.提供返回方法返回实例，且是 public static
 * 
 * 好处：绝对一个实例
 * 坏处：未获取实例时，实例已建好，如果不使用则浪费空间
 */
public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}

public class Test {
    public static void main(String[] args) {
        //用方法获取实例
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);//输出true
    }
}

懒汉单例模式

/**
 * 懒汉单例模式：类加载的时候不创建实例，等第一次请求时才创建
 * 好处：资源利用率高
 * 坏处：多线程的情况，下可能会创建多个实例
 */
public class Singleton {
    private static Singleton instance;//和饿汉区别是没有new

    private Singleton(){}

    public static Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

public class Test {
    public static void main(String[] args) {
        //单线程时输出结果相同
        //Singleton singleton1 = Singleton.getInstance();
        //Singleton singleton2 = Singleton.getInstance();
        //System.out.println(singleton1 == singleton2);//输出true

        //多线程时会因为执行快慢，可能创建多个实例
        //两次输出结果可能不同
        new Thread(() ->{
            System.out.println(Singleton.getInstance());
        });
        new Thread(() ->{
            System.out.println(Singleton.getInstance());
        });
    }
}

双重检测懒汉单例模式

/**
 * 双重检测懒汉单例模式：注意 volatile 和 synchronized
 * volatile 确保本条指令不会因编译器的优化而省略，且要求每次直接读值。
 * synchronized 方法加锁,相当于不管哪一个线程运行到此，都检查有没有其他线程运行
 */
public class Singleton {
    //volatile 多线程情况下保证instance多个线程之前的可见性和禁止指令重排
    private volatile static Singleton instance;

    private Singleton(){}

    public static Singleton getInstance(){
        if(instance == null){//节约时间，如果创建好了就跳过
            synchronized (Singleton.class){//上锁和下方的if 保证是单例的
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
    
    public static void main(String[] args) {
        new Thread(() ->{
            System.out.println(getInstance());
        });
        new Thread(() ->{
            System.out.println(getInstance());
        });
    }
}

静态内部类方式

/**
 * 静态内部类单例模式：只有第一次调用getInstance的时候内部类才会new
 * 资源利用率高，线程安全
 */
public class Singleton {
    
    private Singleton(){}

    //静态内部类，提供成员变量同时赋值
    private static class InnerClass{
        static Singleton instance = new Singleton();
    }
    
    public static Singleton getInstance(){
        return InnerClass.instance;
    }

    public static void main(String[] args) {
        new Thread(() ->{
            System.out.println(getInstance());
        });
        new Thread(() ->{
            System.out.println(getInstance());
        });
    }
}

原型模式

/**
 * 原型模式：多个实例内容差别不大。性能高，简化创建对象，底层直接复制不用构造方法。但要给每个类配置clone方法，不符合开闭原则，深复制实现麻烦。
 * 如果引用类太多，可以用序列化的方式，先用ObjectOutputStream 的writeObject 实现序列号到字节数组，然后用readObect反序列化成一个相同对象。
 * 1.实现 Cloneable接口
 * 2.重新Object类的clone方法，把权限改为 public，将输出的 Object 强转为当前类
 * 3.浅复制：只重新第一层类的 clone方法。
 * 4.深复制：还要重新引用类的 clone方法。实现麻烦。
 */

//人员信息，  注意生成构造函数和get、set方法
public class Personnel implements Cloneable {
    private String name;//姓名
    private int age;//年龄
    private NativePlace nativePlace;//籍贯
    
    //重新Object的clone方法
    @Override
    protected Personnel clone(){
        try{//这块加报错处理后别的地方就不用加了
            return (Personnel)super.clone();//这块尽量加强转，免得在别的地方再写
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}
//籍贯实体类：如果也深复制，也要给这个类重新 clone方法
public class NativePlace {
    private String province;//省
    private String city;//市
    private String county;//县
}

//测试类
public class Test {
    public static void main(String[] args) {
        NativePlace nativePlace = new NativePlace("陕西省","西安市","长安区");
        Personnel personnel1 = new Personnel("张三",25,nativePlace);
        //如果不用原型模式要写多次上面的代码
        Personnel personnel2 = personnel1.clone();
        Personnel personnel3 = personnel1.clone();
        System.out.println(personnel1);
        System.out.println(personnel2);
        System.out.println(personnel3);
    }
}

//下方是深复制
public class Personnel implements Cloneable {
    private String name;//姓名
    private int age;//年龄
    private NativePlace nativePlace;//籍贯
    
    @Override
    public Personnel clone(){
        Personnel obj = null;
        try{
            obj =  (Personnel)super.clone();//浅复制
            obj.nativePlace = this.nativePlace.clone();//深复制
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return obj;
    }
}
//籍贯实体类：如果也深复制，也要给这个类重新 clone方法
public class NativePlace {
    private String province;//省
    private String city;//市
    private String county;//县

    @Override
    public NativePlace clone(){
        try{
            return (NativePlace)super.clone();
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        NativePlace nativePlace = new NativePlace("陕西省","西安市","长安区");
        Personnel personnel1 = new Personnel("张三",25,nativePlace);
        
        Personnel personnel2 = personnel1.clone();
        personnel2.setName("李四");//第二个改名字
        Personnel personnel3 = personnel1.clone();
        nativePlace.setCounty("莲湖区");//第三个改籍贯中的县
        
        System.out.println(personnel1);
        System.out.println(personnel2);
        System.out.println(personnel3);
    }
}

(2) 结构型设计模式：通过类和对象的组合，将类和对象结合成一个更大的结构。

外观模式

为子系统的一组接口提供一个一致的高级接口(界面)。
优点：松散耦合，简单好用
缺点：降低了灵活性，因为对外提供的接口有限。
例： MVC模式
图示：如果没有外观层，客户端会直接调用对象和其方法，对象多的情况下比较复杂。

装饰模式

替代继承的一种方法（组合），减少子类数量，更加灵活，符合开闭原则和聚合复用原则。
将装饰部分搬出了类，简化了原有类。将核心代码和装饰功能区分开。
角色/原理：(完整的包括下面的四部分，也可以省去某部分)
(1): 抽象构建角色：提供抽象接口，规范要附加的责任。
(2): 具体构建角色：实现要附加的责任。
(3): 抽象装饰角色：对 (1)抽象构建角色进行引用，并定义和它一致的接口。
(4): 具体装饰角色：给 (2)具体构建角色加上装饰。
实际应用:（顺序和上面角色顺序一致）
(1) IO流(完整的) :
InputStream、FileInputStream - ByteArrayInputStream、FilterInputStream、BufferedInputStream - DataInputStream
(2)myBatis 的 Cache 体系（没有抽象装饰角色）:
Cache、PerpetualCache、无抽象装饰、LruCache
图示：
代码示例：

/**
 * 抽象构件类：
 */
public abstract class ComponentCake {

    /**
     * 做蛋糕
     */
    public abstract void makeCake();
}

//实现抽象构建类
public class ChocolatesCake extends ComponentCake {
    @Override
    public void makeCake() {
        System.out.println("制作巧克力蛋糕");
    }
}

class CreamCake extends ComponentCake{

    @Override
    public void makeCake() {
        System.out.println("制作奶油蛋糕");
    }
}

class StrawberryCake extends ComponentCake{

    @Override
    public void makeCake() {
        System.out.println("制作草莓蛋糕");
    }
}

/**
 * 抽象装饰类：  蛋糕上的装饰--卡片、鲜花
 *
 * 继承蛋糕类、重写makeCake方法
 * 关联抽象蛋糕类
 */
public abstract class DecorateCake extends ComponentCake{
    //关联
    private ComponentCake cake;

    //可以转入蛋糕的子类，例如奶油和卡片，因为卡片也相当于继承了蛋糕类
    public DecorateCake(ComponentCake cake) {
        this.cake = cake;
    }

    public DecorateCake() {
    }

    //重写
    @Override
    public void makeCake() {
        cake.makeCake();
    }
}

//具体装饰角色
public class CardDecorate extends DecorateCake{
    public CardDecorate(ComponentCake cake) {
        super(cake);
    }

    @Override
    public void makeCake() {
        //先调用父类DecorateCake的制作方法，例如:当前传入是蛋糕就先做蛋糕，是鲜花就先放鲜花，保证先后顺序
        super.makeCake();
        //自己要做的
        System.out.println("加一个卡片");
    }
}

class FlowerDecorate extends DecorateCake{
    public FlowerDecorate(ComponentCake cake) {
        super(cake);
    }

    @Override
    public void makeCake() {
        super.makeCake();
        System.out.println("放一朵鲜花");
    }
}

public class Test {
    public static void main(String[] args) {
        //1.制作奶油蛋糕
        //先做个蛋糕
        ComponentCake cake = new CreamCake();
        //放个卡片
        ComponentCake cake1 = new CardDecorate(cake);
        //再放个鲜花上去
        ComponentCake cake2 = new FlowerDecorate(cake1);
        cake2.makeCake();//用哪个cake调用方法就到哪一步

        //2.制作草莓蛋糕
        ComponentCake cake3 = new CardDecorate(new FlowerDecorate(new StrawberryCake()));
        cake3.makeCake();
    }
}

代理模式 （静态代理，JDK动态代理，CGLIB动态代理）

给一个对象提供一个代理，由代理控制对象的引用，对象不直接和目标接触。(例如：打官司的原告和律师)

（1）静态代理 ：

优点：在符合开闭原则的情况下对对象功能进行扩展。
缺点：一个代理类只能代理一个接口；代理类是运行前编辑好的；先有接口再有代理；接口改变代理类也要变。
图示：在代理中关联共同接口
代码示例

//需要中介和买家实现的接口
public interface Subject {
    public void request();
}
/**
 * 买家
 */
public class Buyers implements Subject{
    @Override
    public void request() {
        System.out.println("我是买家，掏钱买房子");
    }
}
/**
 * 中介
 * 1.和买家实现共同接口，有同样的输出方法
 * 2.关联共同接口
 */
public class Proxy implements Subject{

    //关联共同接口,被代理对象
    private Subject subject;

    public Proxy(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void request() {
        //预处理操作，例如看房
        befor();
        subject.request();//买家的操作，付钱
        //后处理操作
        after();
    }

    private void after() {
        System.out.println("办理手续");
    }

    private void befor() {
        System.out.println("查看房源，看房");
    }
}

public class Test {
    public static void main(String[] args) {
        Subject subject = new Buyers();//买家
        Proxy proxy = new Proxy(subject);//中介
        proxy.request();
    }
}

（2）JDK动态代理 ：

不需要再手动创建代理类，只需要写一个动态处理器，让处理器创建代理类。Proxy是jdk提供的动态代理类。
动态实现 InvocationHandler 中的invoke方法。
Proxy.newProxyInstance 返回的是代理类的一个实例。
例：Mybatis 的 getMapper就是用的JDK动态代理。
优点：一个代理类可以代理多个接口；代理类是运行时动态生成的；可以先写代理类，再写接口；接口改变，代理类不用修改。
缺点：只能作接口的代理，不能作类的代理。(因为Proxy已经是所有代理类的父类，java是单继承的，不能再继承其他类)
代码示例：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 自动处理器，不是代理类
 * 定义代理类执行时要进行的操作
 */
public class AuthHandler implements InvocationHandler {

    Object target;//目标对象，买家

    public AuthHandler(Object target) {
        this.target = target;
    }

    /**
     *
     * @param proxy 代理对象，中介
     * @param method 要调用的对象，买家
     * @param args 要调用的方法
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //预处理
        befor();
        //让买家对象调用方法(用反射)
        Object buyers = method.invoke(target,args);
        //后处理
        after();
        //返回结果(在第二步得到)
        return buyers;
    }

    private void after() {
        System.out.println("后处理操作：手续");
    }

    private void befor() {
        System.out.println("预处理操作：看房");
    }

    /**
     * 创建一个代理对象
     * @return
     */
    public Object  getProxy(){
        //这个类里面的参数 ClassLoader loader, Class<?>[] interfaces, InvocationHandler h
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
}

//需要中介和买家实现的接口
public interface Subject {
    public void request();
}
/**
 * 买家
 */
public class Buyers implements Subject {
    @Override
    public void request() {
        System.out.println("我是买家，掏钱买房子");
    }
}
//测试
public class Test {
    public static void main(String[] args) {
        Subject subject = new Buyers();//买家
        AuthHandler authHandler = new AuthHandler(subject);//自动处理器
        Subject proxy = (Subject) authHandler.getProxy();//创建买家的代理，创建中介
        proxy.request();
    }
}

（3）CGLIB动态代理 ：

加入CGLIB和ASM架包。
因为代理是被代理类的子类，所以这里不能加final(不能重写和继承)
Enhancer 和 JDK中的Proxy差不多，但它可以代理类，也可以代理接口。
与JDK动态代理区别：
CGLIB可以代理类和接口，JDk只能代理接口（因为java中不能多继承，Proxy已经是所有代理类的父类）；
JDK使用的是java原生反射API进行操作，生成效率高， CGLIB使用ASM框架对字节码进行操作，类的执行过程比较高效。
代码示例：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class AuthInterceptor implements MethodInterceptor {
    Object target;//被代理对象，买家

    public AuthInterceptor(Object obj) {
        this.target = obj;
    }

    /**
     *
     * @param proxy 代理对象
     * @param method 目标对象要调用的方法
     * @param args 目标对象要调用方法的参数
     * @param methodProxy 方法的代理
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //预处理
        befor();
        //让买家对象调用方法(用反射)
        Object result = method.invoke(target,args);
        //后处理
        after();
        //返回结果(在第二步得到)
        return result;
    }

    private void befor() {
        System.out.println("预处理操作：看房");
    }

    private void after() {
        System.out.println("后处理操作：手续");
    }

    /**
     * 创建一个代理对象
     * @return
     */
    public Object  getProxy(){
        //这个类里面的参数 ClassLoader loader, Class<?>[] interfaces, InvocationHandler h
        Enhancer enhancer = new Enhancer();//相当于jdk的Proxy
        enhancer.setSuperclass(this.target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
}

//要实现的抽象类
public abstract class Subject {
    public abstract void request();
}
//买家类/被代理类，因为代理是该类的子类，所以这里不能加final(不能重写和继承)
public class Buyers extends Subject {
    @Override
    public void request() {
        System.out.println("我是买家，掏钱买房子");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Subject subject = new Buyers();
        AuthInterceptor authInterceptor = new AuthInterceptor(subject);
        Subject sub = (Subject) authInterceptor.getProxy();
        sub.request();
    }
}

（3）行为型设计模式

(1) 责任链模式 ：

责任链模式将多个处理器串成链，让请求在链上传递。
多个处理器都有机会处理请求，直到其中某个处理器处理完请求为止。
提高系统灵活性，新增一个处理器代价小。
降低了系统性能，如果链比较长就比较麻烦，不利于调试。
图示：
代码示例：上图的组长、经理、总经理有一个共同的抽象处理器，如果组长权限不够，抽象处理器让经理执行，以此类推。

//抽象处理器
public abstract class Handler {
    protected Handler handler;

    public void setHandler(Handler handler){
        this.handler = handler;
    }

    public abstract void process(Integer info);
}
//组长
public class Leader extends Handler {

    @Override
    public void process(Integer info) {
        if(info > 0 && info < 4){
            //组长处理三天内的请假
            System.out.println("组长：请假通过");
        }else{
            handler.process(info);
        }
    }
}
//经理
public class Manager extends Handler{
    @Override
    public void process(Integer info) {
        System.out.println("经理：请假通过");
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        Handler handler1 = new Manager();//创建经理
        Handler handler = new Leader();//创建组长
        //将经理权限set到组长权限内
        handler.setHandler(handler1);

        handler.process(2);
        handler.process(5);
    }
}