Java设计模式代理模式（Proxy）_编写一段代理模式 java-CSDN博客

本文链接：https://blog.csdn.net/weixin_65637841/article/details/126174296

1. 代理模式的基本介绍

        1.代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象。这样做的好处是：可以在目标对象实现的基础上，添加额外的功能操作，即拓展目标对象的功能。

        2. 被代理的对象可以是远程对象、创建开销大的对下给你或需要安全控制的对象

        3. 代理模式有不同的形式，主要有三种静态代理、动态代理（JDK代理、接口代理）和Cglib代理（可以在内存动态里创建对象，而不需要实现接口，他是属于动态代理的范畴）

        4.代理模式示意图

2. 静态代理

2.1 静态代理模式的基本介绍

静态代理在使用时，需要定义接口或者父类，被代理对象（即目标对象）与代理对象一起实现接口或者时继承相同的父类

2.2 应用实例

2.2.1 实例具体要求

1. 定义一个接口 TeacherDao

2. 目标对象 TeacherDaoImpl 实现接口 TeacherDao 接口

3. 使用静态代理方式，就需要在代理对象 TeacherDaoProxy 中也实现 TeacherDao 接口

4. 调用的时候通过调用代理对象的方法来调用目标对象

5. 代理对象与目标对象要实现相同的接口，然后通过调用相同的方法来调用目标对象的方法

2.2.2 思路流程

1. 编写 TeacherDao 接口，并定义方法

2. 编写 TeacherDaoImpl 类实现 TeacherDao 接口

3. 编写 TeacherDaoProxy 代理对象实现TeacherDao 接口

4. 在 TeacherDaoProxy 代理对象实现接口方法，并创建 TeacherDao 属性（用于聚合目标方法），在实现方法中再次调用方法。

5. 编写Client类，创建代理对象及目标对象（即TeacherDaoImpl 实现类），调用方法

2.2.3 代码编写

1. 编写 TeacherDao 接口，并定义方法

public interface TeacherDao {
    public void teach();
}

2. 编写 TeacherDaoImpl 类实现 TeacherDao 接口

public class TeacherDaoImpl implements TeacherDao{
    @Override
    public void teach() {
        System.out.println(" 老师正在授课中。。。。 ");
    }
}

3. 编写 TeacherDaoProxy 代理对象实现TeacherDao 接口

4. 在 TeacherDaoProxy 代理对象实现接口方法，并创建 TeacherDao 属性（用于聚合目标方法），在实现方法中再次调用方法。

// 代理对象 静态代理
public class TeacherDaoProxy implements TeacherDao{
    private TeacherDao teacherDao; // 目标对象，通过接口来聚合

    // 构造器
    public TeacherDaoProxy(TeacherDao teacherDao) {
        this.teacherDao = teacherDao;
    }

    // 增强方法
    @Override
    public void teach() {
        System.out.println("开始代理 。。。 完成某些方法");

        teacherDao.teach();

        System.out.println("再完成某些方法。。。 代理结束");

    }
}

5. 编写Client类，创建代理对象及目标对象（即TeacherDaoImpl 实现类），调用方法

public class Client {
    public static void main(String[] args) {
        //创建目标对象（被代理对象）
        TeacherDaoImpl teacherDao = new TeacherDaoImpl();

        // 创建代理对象，同时将被代理对象传递给代理对象
        TeacherDaoProxy dao = new TeacherDaoProxy(teacherDao);

        // 通过代理对象，调用被代理对象的方法
        dao.teach();
    }
}

结果：

2.3 静态代理优缺点

1. 优点：在不修改对象的功能的前提下，能通过代理对象对目标功能扩展

2. 缺点：因为代理对象需要与目标对象实现一样的接口，所以回有很多代理类，一旦接口则增加方法，目标对象与代理对象都要进行维护。

3. 动态代理

3.1 动态代理模式的基本介绍

1. 代理对象，不需要实现接口，但是目标对象要实现接口，否则不能动态代理

2. 代理对象的生成，是利用 JDK 的 API ，动态的内存中构建代理对象

3. 动态代理也叫作：JDK代理、接口代理。

3.2 JDK中生成代理对象的 API

1. 代理类所在包：java.lang.reflect.Proxy

2. JDK 事项代理只需要使用 newPRoxyInstance 方法，但是该方法需要接收三个参数，完成的写法是：

static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h);

参数1：ClassLoader loader:指定当前目标对象使用的类加载器，

获取加载器的方法固定: 1.类的实例对象.getClass().getClassLoader

2. 类名.class.getClassLoader

参数2：Class<?>[] interfaces:目标对象的接口类型，使用泛型方法确认类型

参数3：InvocationHandler h:事件处理，执行目标对象的方法时，会触发事件处理器方法，

会把当前执行的目标对象方法作为参数传入

3.3 思路流程

1. 编写 IteacherDao 接口，并定义方法

2. 编写 TeacherDao 实现类，实现IteacherDao 接口

3. 编写 ProxyFactory 代理类，在类中创建一个目标对象属性，并生成构造器与获取动态目标对象的

方法:getInstanceProxy();

4. 在 getInstanceProxy(); 使用生成代理对象的 API ，动态的内存中构建代理对象

5. 编写Client类，使用代理对象获取动态的目标对象，调用方法

3.4 代码实现

1. 编写 IteacherDao 接口，并定义方法

public interface ITeacherDao {
    public void teach();
    public void sayHello(String name);
}

2. 编写 TeacherDao 实现类，实现IteacherDao 接口

public class TeacherDao implements ITeacherDao {

    @Override
    public void teach() {
        System.out.println(" 老师正在授课中。。。。 ");
    }

    @Override
    public void sayHello(String name) {
        System.out.println(" hello " + name);
    }
}

3. 编写 ProxyFactory 代理类，在类中创建一个目标对象属性，并生成构造器与获取动态目标对象的

方法:getInstanceProxy();

4. 在 getInstanceProxy(); 使用生成代理对象的 API ，动态的内存中构建代理对象

public class ProxyFactory {

    // 创建一个目标对象
    private Object target;

    // 构造器

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

    public Object getInstanceProxy() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // proxy 表示要代理的对象， method 表示代理对象的方法 args表示要代理方法的参数列表
                System.out.println(" JDK代理开始。。。 ");

                // 通过反射机制调用方法
                Object invoke = method.invoke(target, args);
                System.out.println(method.getName()+"方法执行了");

                System.out.println("JDK代理提交");
                return invoke;
            }
        });
    }
}

5. 编写Client类，使用代理对象获取动态的目标对象，调用方法

public class Client {
    public static void main(String[] args) {
        // 创建目标对象
        TeacherDao teacherDao = new TeacherDao();

        // 给目标对象，创建代理对象，可以转成 ITeacherDao
        ITeacherDao dao = (ITeacherDao) new ProxyFactory(teacherDao).getInstanceProxy();

        System.out.println(dao.getClass());
        //class com.sun.proxy.$Proxy0 内存中动态生成了代理对象

        // 通过动态代理，调用目标对象的方法
        dao.teach();
        System.out.println();

        dao.sayHello("张三");
    }
}

结果：

4. Cglib 代理

4.1 Cglib 代理模式的基本介绍

1. 静态代理和 JDK 代理模式都要求目标对象时实现一个接口，但是有时候目标对象只是一个单独的对象，并没有实现任何接口，

这个时候可以使用目标对象子类来实现代理 -- 这就是 Cglib 代理。

2. Cglib 代理也叫做子类代理，它是内容中构建一个子类对象从而实现对目标对象功能扩展，有些书也将 Cglib 代理归属到动态代理。

3. Cglib 是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多 AOP 的框架使用，例如Spring AOP ，实现方法拦截

4. 在AOP编程中如何选择代理模式

（1）目标对象需要实现接口，用 JDK 代理

（2）目标对象不需要实现接口，用 Cglib 代理

5. Cglib 包的底层是通过使用字节码处理框架 ASM 来转换字节码并生成新的类

4.2 Cglib 代理模式实现步骤

1. 需要引入 cglib 的 jar 文件

2. 在内存中动态构建子类，注意代理的类不能是 final,否则报错:

java.lang.IllegalArgumentException;

3. 目标对象的方法如果为 final / static ，那么就不会被拦截，即不会被执行目标对象额外的业务方法

4.3 Cglib 代理模式应用实例

1. 应用实例要求

将前面的案例用Cglib代理模式实现

2. 思路图解（类图）

3. 思路流程

1. 编写 TeacherDao 类，并定义方法

2. 编写 ProxyFactory 类，创建目标对象 int,并实现 MethodInterceptor 接口

3. 重写 intercept() ,调用目标对象方法，并增强其功能

4. 编写 getProxyInstance 方法，放回一个代理对象，创建Enhancer工具类对象，用setSuperclass方法设置其父类，用

setCallbace()方法设置回调函数（回调它自己）

5.编写 Client 类，创建目标类，用 ProxyFactory 获取代理对象，调用目标方法

4.4 代码实现

1. 编写 TeacherDao 类，并定义方法

public class TeacherDao {
    public void teach() {
        System.out.println(" 老师授课中。。。。这是Cglib代理，不用实现接口");
    }

    public void sayHello(String name) {
        System.out.println("hello " + name);
    }
}

2. 编写 ProxyFactory 类，创建目标对象 int,并实现 MethodInterceptor 接口

3. 重写 intercept() ,调用目标对象方法，并增强其功能

4. 编写 getProxyInstance 方法，放回一个代理对象，创建Enhancer工具类对象，用setSuperclass方法设置其父类，用

setCallbace()方法设置回调函数（回调它自己）

public class ProxyFactory implements MethodInterceptor {

    // 创建目标对象
    private Object target;

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

    // 返回一个代理对象：是 target 对象的代理对象
    public Object getProxyInstance() {
        // 1. 创建一个工具类
        Enhancer enhancer = new Enhancer();
        // 2. 设置父类
        enhancer.setSuperclass(target.getClass());
        // 3. 设置回调函数
        enhancer.setCallback(this);
        // 4. 创建子类对象，即代理对象，并返回
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("Cglib 代理模式 开始 ~~~");
        Object invoke = method.invoke(target, objects);
        System.out.println("Cglib 代理模式 提交 ~~~");
        return invoke;
    }
}

5.编写 Client 类，创建目标类，用 ProxyFactory 获取代理对象，调用目标方法

public class Client {
    public static void main(String[] args) {
        // 创建目标对象
        TeacherDao teacherDao = new TeacherDao();

        // 获取到代理对象，并且将目标对象传递给代理对象
        TeacherDao dao = (TeacherDao) new ProxyFactory(teacherDao).getProxyInstance();

        // 执行代理对象的方法，触发 intercept 方法，从而实现 对象目标对象的调用
        dao.teach();
        System.out.println();
        dao.sayHello("李四");
    }
}

运行结果：

5. 集中常见的代理模式介绍 -- 几种变体

1. 防火墙代理

内网通过代理穿透防火墙，实现对公网的访问。

2. 缓存代理

比如：当请求图片文件等资源时，先到缓存代理取，如果渠道资源就ok，如果取不到资源，再到公网或者数据库取，然后缓存。

3. 远程代理

远程对象的本地代表，通过它可以Ⅷ远程对象当本地对象来调用。远程代理通过网络和真正的远程对象沟通信息

4. 同步代理

主要使用在多线程中，完成多线程间同步工作