• 设计模式之代理模式

    代理模式

    1、简介

    1. 概念：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象。这样的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。
    2. 被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象。
    3. 代理模式有不同的形式，主要有三种：静态代理、动态代理（JDK代理、接口代理）和Cglib代理（可以在内存动态的创建对象，而不需要实现接口，他是属于动态代理的范畴）。

    1.2、静态代理

    1.2.1、简介

    1. 静态代理一般需要定义接口或父类，代理对象和被代理的对象都要实现同一个接口或相同的父类。

    1.2.2、实现

    1. 定义一个接口
    /**
 * 
    
 * Title:目标对象和代理对象都需要实现实现同一接口
 * 
    
 *
 * @author: yangyongbing
 * @Date: 2022-07-22 11:20
 * @version: v1.0
 */    
public interface CommonDao {
    void say();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    1. 目标对象实现接口
    /**
 * 
    
 * Title:被代理的对象（目标对象）
 * 
    
 *
 * @author: yangyongbing
 * @Date: 2022-07-22 11:20
 * @version: v1.0
 */    
public class TargetObject implements CommonDao{
    @Override
    public void say() {
        System.out.println("我是被代理的对象！");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    1. 代理对象实现接口
    /**
 * 
    
 * Title:代理对象
 * 
    
 *
 * @author: yangyongbing
 * @Date: 2022-07-22 11:21
 * @version: v1.0
 */    
public class ProxyObject implements CommonDao{

    private final TargetObject targetObject;

    public ProxyObject(TargetObject targetObject) {
        this.targetObject = targetObject;
    }

    @Override
    public void say() {
        System.out.println("代理之前做一些处理！");
        targetObject.say();
        System.out.println("代理结束后也可以做一些处理！");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    1. 客户端调用
    /**
 * 
    
 * Title:模拟客户端
 * 
    
 *
 * @author: yangyongbing
 * @Date: 2022-07-22 11:18
 * @version: v1.0
 */    
public class Client {
    public static void main(String[] args) {
        //1.创建目标对象（被代理对象）
        TargetObject targetObject=new TargetObject();
        //2.创建代理对象，并将目标对象传递给代理对象
        ProxyObject proxyObject = new ProxyObject(targetObject);
        //3.通过代理对象，调用到目标对象的方法
        proxyObject.say();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    在这里插入图片描述

    1.2.3、依赖关系

    在这里插入图片描述

    1.2.4、优缺点

    1. 优点：在不修改目标对象功能前提下，能通过代理对象对目标功能扩展。
    2. 缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类，一旦接口增加方法，目标对象与代理对象都需要维护。

    1.3、动态代理

    1.3.1、简介

    1. 代理对象，不需要实现接口，但是目标对象要实现接口，否则不能用动态代理。
    2. 代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象。
    3. 动态代理也叫做：JDK代理、接口代理。

    1.3.2、JDK中生成代理对象的API

    1. 代理类所在包：java.lang.reflect.Proxy
    2. JDK实现代理只需要使用newProxyInstance方法，但是该方法需要接受三个参数，完整的写法是：
      static Objcet newProxyInstance(ClassLoader loader,Class)

    1.3.3、实现

    1. 定义一个接口
    /**
 * 
    
 * Title:目标对象需要实现的接口
 * 
    
 *
 * @author: yangyongbing
 * @Date: 2022-07-22 11:23
 * @version: v1.0
 */    
public interface TargetDao {
    void say();
    void play(String name);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    1. 目标对象实现接口
    /**
 * 
    
 * Title:目标对象
 * 
    
 *
 * @author: yangyongbing
 * @Date: 2022-07-22 11:24
 * @version: v1.0
 */    
public class TargetObject implements TargetDao{

    @Override
    public void say() {
        System.out.println("我是目标对象");
    }

    @Override
    public void play(String name) {
        System.out.println("我是目标对象喜欢打"+name);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    1. 代理对象
    /**
 * 
    
 * Title:代理对象
 * 
    
 *
 * @author: yangyongbing
 * @Date: 2022-07-22 11:27
 * @version: v1.0
 */    
public class ProxyFactory {

    //维护一个目标对象,object
    private Object target;

    //构造器，对目标对象进行初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象生成一个代理对象
    public Object getProxyInstance(){

        //ClassLoader loader:指定当前对象使用的类加载器，获取加载器的固定方法
        //Class[] interfaces:目标对象实现的接口类型，使用泛型方法确认类型
        //InvocationHandler:事件处理，执行目标对象的方法时，会触发事件处理器方法，会把当前执行的目标对象方法作为参数传入
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("JDK代理开始！");
                        Object invoke = method.invoke(target, args);
                        System.out.println("JDK代理结束！");
                        //反射机制调用目标方法
                        return invoke;
                    }
                });
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    1. 客户端调用
    /**
 * 
    
 * Title:客户端
 * 
    
 *
 * @author: yangyongbing
 * @Date: 2022-07-22 11:28
 * @version: v1.0
 */    
public class Client {
    public static void main(String[] args) {

        //创建目标对象
        TargetDao targetObject = new TargetObject();

        //创建代理对象，并将目标对象（被代理的对象）传给代理对象
        TargetDao proxyInstance = (TargetDao) new ProxyFactory(targetObject).getProxyInstance();
        //System.out.println(proxyInstance);
        //内存中动态生成了代理对象
        System.out.println(proxyInstance.getClass());

        //通过代理对象，调用目标对象的方法
        proxyInstance.say();
       //通过代理对象，调用目标对象的方法
        proxyInstance.play("篮球");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    在这里插入图片描述

    1.3.4、依赖关系

    在这里插入图片描述

    1.4、Cglib代理

    1.4.1、简介

    1. 静态代理和JDK代理模式都要求目标对象实现一个接口，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候可以使用目标子对象来实现代理，即Cglib代理。
    2. Cglib代理也叫做子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能扩展，有些书也将Cglib归属到动态代理。
    3. Cglib是一个功能强大的高性能的代码生成包，它可以运行期扩展java类接口，它广泛的被许多AOP的框架使用，例如Spring AOP,实现方法拦截。
    4. 在AOP编程中如何选择代理模式：若目标对象需要实现接口，就用JDK代理；若目标对象不需要实现接口，就用Cglib代理。
    5. Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的类。
      ASM:ASM 是一个 Java 字节码操控框架。它能够以二进制形式修改已有类或者动态生成类。ASM 可以直接产生二进制 class 文件，也可以在类被加载入 Java 虚拟机之前动态改变类行为。ASM 从类文件中读入信息后，能够改变类行为，分析类信息，甚至能够根据用户要求生成新类。

    1.4.2、实现步骤

    1. 需要引入cglib的jar文件：implementation group: 'cglib', name: 'cglib', version: '3.3.0'
    2. 在内存中动态构建子类，注意代理的类不能为final,否则报错java.lang.illegalArgumentException非法的参数异常，无法实现在内存中动态构建子类的操作。
    3. 目标对象的方法如果为final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法。

    1.4.3、实现

    1. 创建被代理对象（目标对象）
    /**
 * 
    
 * Title:被代理对象（目标对象）
 * 
    
 *
 * @author: yangyongbing
 * @Date: 2022-07-22 12:29
 * @version: v1.0
 */    
public class TargetObject {
    String say(){
        System.out.println("我是被代理对象,cglib代理，不需要实现接口!");
        return "Hello World！";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    1. 创建代理对象
    /**
 * 
    
 * Title:代理对象
 * 
    
 *
 * @author: yangyongbing
 * @Date: 2022-07-22 12:32
 * @version: v1.0
 */    
public class ProxyFactory implements MethodInterceptor {

    //维护一个目标对象
    private Object target;

    //构造器，对目标对象进行初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //返回一个代理对象，即target的代理对象
    public Object getProxyInstance(){
        //1、创建一个工具类， Enhancer是字节码增强器，可以用来为无接口的类创建代理，它会根据某个给定的类创建子类，并且所有非final的方法都带有回调钩子
        Enhancer enhancer = new Enhancer();
        //2、设置父类
        enhancer.setSuperclass(target.getClass());
        //3、设置回调函数
        enhancer.setCallback(this);
        //设置子类对象，即代理对象
        return enhancer.create();
    }

    //重写intercept方法，该方法会自动调用被代理对象（目标对象）的方法
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("cglib动态代理开始");
        Object invoke = method.invoke(target, args);
        System.out.println("cglib动态代理提交");
        return invoke;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    1. 创建客户端
    /**
 * 
    
 * Title:客户端
 * 
    
 *
 * @author: yangyongbing
 * @Date: 2022-07-22 13:32
 * @version: v1.0
 */    
public class Client {
    public static void main(String[] args) {

        //创建目标对象
        TargetObject targetObject = new TargetObject();

        //创建代理对象，并将目标对象传递给代理对象
        TargetObject proxyInstance = (TargetObject) new ProxyFactory(targetObject).getProxyInstance();

        //执行代理对象的方法，触发intercept方法，从而调用目标对象的方法
        String say = proxyInstance.say();
        System.out.println(say);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    在这里插入图片描述

    1.5、常见代理模式应用

    1. 防火墙代理：内网通过代理穿透防火墙，实现对外网的访问。
    2. 缓存代理：如请求图片、文件等资源时，先到缓存中去读取，若读取到OK，若没读取到，就再从外网或者数据库中去读取。
    3. 远程代理：远程对象的本地代表，通过该代表可以把远程对象当本地对象来调用。远程代理通过网络和真正的远程对象交互。
    4. 同步代理：主要运用在多线程编程中，完成多线程间同步工作。
  • 相关阅读:
    获取两个字符串的最大公共子序列(LCS)
    swagger使用教程——快速使用swagger
    蓝牙BLE官方Spec文档中表格部分涉及的缩写词
    VUE 常用炫酷动画库（拿来即用系列）
    暑假如何有效控制、预防近视？保护视力的护眼灯分享
    记一次 .NET 某仪器测量系统 CPU爆高分析
    深入解析Java HashMap的Resize源码
    OD华为机试 17
    OFDM 十六讲 5 -Discrete Convolution, ISI and ICI on DMT/OFDM Systems
    简易云在线人事管理系统
  • 原文地址：https://blog.csdn.net/YYBDESHIJIE/article/details/126084995