09. 23种经典设计模式-23-代理模式

蔚落 2024-04-17 14:52 41阅读 0赞

# 1. 代理模式 #

> Provide a surrogate or placehoilder for another object to control access to it.(为其它对象提供一种代理，以控制该对象的访问)

代理模式(Proxy Pattern ),也称为委托模式, 是一种使用非常广泛的设计模式, 指的是为一个对象提供一个代理对象, 通过访问代理对象以访问目标对象.

### 1.1 代理模式核心思想 ###

*  代理的目标是对象
 *  代理类需要实现要代理对象实现的接口, 无论是静态还是动态
 *  对于实现接口的业务逻辑方法而言，代理类相当于一个空壳儿, 实际调用的时被代理类的实现方法.

### 1.2 代理模式类图 ###

代理类Proxy 和 被代理类RealSubject 同为接口Subject 的子类, 但是Proxy 又聚合了被代理类RealSubject.

*  Subject： 抽象主题角色, 通常为接口类， 定义需要代理的抽象方法
 *  RealSubject: 被代理角色, 也称委托角色. 是业务逻辑的具体执行者
 *  Proxy： 代理角色. 负责在真实角色执行完业务逻辑前后做预处理或善后工作.

![format_png][]

### 1.3 代理模式优缺点 ###

*  优点:
    
     *  职责清晰: 真实角色就是实现实际的业务, 不用关心非本职事务
     *  高扩展性和智能化: 使用动态代理时, 无论真实角色如何变动, 代理类完全不用进行任何修改
 *  缺点： 动态代理时, 被代理对象的每一个方法都会被同一个代理方法所处理，会增加编程复杂度和影响性能

### 1.4 代理模式适用场景 ###

*  代理模式是一种使用非常广泛的设计模式, 适用于切面编程, 如Spring 的AOP 就是采用动态代理实现的.
 *  典型应用场景: spring 的声明式事务

### 1.5 代理模式分类 ###

*  静态代理: 显式创建代理类，实现代理对象实现的接口
 *  动态代理: java 动态代理的实现有两种方式
    
     *  jdk 动态代理: 代理对象必须实现接口, 通过实现相同接口方式创建代理对象
     *  cglib 动态代理: 代理对象无须实现接口, 通过继承方式动态创建代理对象

## 2. 静态代理模式 ##

静态代理在实际开发中并不是太常用， 通常都是采用动态代理.

### 2.1 定义抽象角色 ###

笔者定义两个业务方法.

public interface ISubject { 
    
        // 业务操作1
        void doBizJob1();
    
        // 业务操作2
        void doBizJob2();
    
    }

### 2.2 定义被代理角色 ###

定义实际的业务类, 实现抽象接口并实现其抽象方法.

public class RealSubject implements ISubject { 
    
        public void doBizJob1() { 
            System.out.println("do method --> " + getClass().getName() + ".doBizJob1");
        }
    
        public void doBizJob2() { 
            System.out.println("do method --> " + getClass().getName() + ".doBizJob2");
        }
    }

### 2.3 定义静态代理类 ###

*  静态代理类需要实现要代理的接口, 并实现接口的抽象方法
 *  静态代理类的接口方法,会调用真正代理对象的接口方法
 *  静态代理类调用真正代理对象的接口方法前后, 可做一些统一的操作, 以实现AOP 的前置后置通知.

public class ProxyForSubject implements ISubject { 
    
        private ISubject subject;
    
        public ProxyForSubject(ISubject subject) { 
            // 指定代理对象
            this.subject = subject;
        }
    
        public void doBizJob1() { 
            // 前置操作
            this.before();
    
            // 执行目标方法
            this.subject.doBizJob1();
    
            // 后置操作
            this.after();
        }
    
        public void doBizJob2() { 
            // 前置操作
            this.before();
    
            // 执行目标方法
            this.subject.doBizJob2();
    
            // 后置操作
            this.after();
        }
    
        // 目标方法前置方法
        private void before(){ 
            System.out.println("目标方法执行前, 执行before操作...");
        }
    
        // 目标方法后置方法
        private void after(){ 
            System.out.println("目标方法执行后, 执行after操作...");
        }
    }

### 2.4 测试 ###

@Test
    public void test_static(){ 
    
        // 1. 创建被代理对象
        RealSubject realSubject = new RealSubject();
    
        // 2. 创建代理对象
        ISubject proxy = new ProxyForSubject(realSubject);
    
        // 3. 执行被代理方法
        proxy.doBizJob1();
    
        System.out.println("\n************************************************\n");
        proxy.doBizJob2();
    
    }

### 2.5 测试输出 ###

目标方法执行前, 执行before操作...
    do method --> org.zongf.learn.design.pattern.proxy.RealSubject.doBizJob1
    目标方法执行后, 执行after操作...
    
    ************************************************
    
    目标方法执行前, 执行before操作...
    do method --> org.zongf.learn.design.pattern.proxy.RealSubject.doBizJob2
    目标方法执行后, 执行after操作...

## 3. JDK 动态代理 ##

### 3.1 动态代理处理器 ###

*  动态代理必须提供一个调用处理器, 自定义调用目标方法的逻辑. 这样才能实现类似Spring AOP 的前置与后置通知
 *  动态代理类无须关注要代理对象的类型, 当代码执行时, 才知道代理对象的类型.

public class SubJectInvoHandler implements InvocationHandler { 
    
        Object target;
    
        public SubJectInvoHandler(Object target) { 
            this.target = target;
        }
    
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            this.before();
            try{ 
                Object object = method.invoke(this.target, args);
                return object;
            }finally { 
                this.after();
            }
        }
    
        private void before() { 
            System.out.println("前置通知....");
        }
    
        private void after(){ 
            System.out.println("后置通知...");
        }
    }

### 3.2 动态代理测试 ###

@Test
    public void test_jdk(){ 
        // 创建被代理对象
        RealSubject subject = new RealSubject();
    
        // 获取类加载器
        ClassLoader classLoader = subject.getClass().getClassLoader();
    
        // 创建动态代理执行器
        SubJectInvoHandler invoker = new SubJectInvoHandler(subject);
    
        // 创建动态代理
        ISubject proxy = (ISubject) Proxy.newProxyInstance(classLoader, new Class[]{ ISubject.class}, invoker);
    
        // 执行请求
        proxy.doBizJob1();
    
        System.out.println("\n************************************************\n");
    
        proxy.doBizJob2();
    }

### 3.3 测试输出 ###

测试输出和静态代理输出完全一致

前置通知....
    do method --> org.zongf.learn.design.pattern.proxy.RealSubject.doBizJob1
    后置通知...
    
    ************************************************
    
    前置通知....
    do method --> org.zongf.learn.design.pattern.proxy.RealSubject.doBizJob2
    后置通知...

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3pvbmdmMDUwNC9ibG9nLWltYWdlcy9tYXN0ZXIvaW1hZ2VzL2Rlc2lnbi1wYXJ0dGVybi9sZHAtcHJveHktMDEucG5n?x-oss-process=image/format,png