Java三种代理模式

前言

代理(Proxy)模式是一种结构型设计模式，提供了对目标对象另外的访问方式；即通过代理对象访问目标对象。
这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。
这里使用到编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，如果需要修改，可以通过代理的方式来扩展该方法。

代理模式大致有三种角色：

Real Subject：真实类，也就是被代理类、委托类。用来真正完成业务服务功能；
Proxy：代理类，将自身的请求用 Real Subject 对应的功能来实现，代理类对象并不真正的去实现其业务功能；
Subject：定义 RealSubject 和 Proxy 角色都应该实现的接口。
代理模式有三种类型，静态代理，动态代理（JDK代理，接口代理）、Cglib代理（在内存中动态的创建目标对象的子类）

举个例子内说明代理的作用,假设:我们先邀请一位明显,那么并不是直接连接明星,而是联系明星的经纪人,来达到同样的目的,明星就是一个目标对象,他之哟啊啊负责活动中的节目,而其他琐碎的事情就交给他的代理(经纪人)来解决,这就是代理思想在现实中的一个例子.

正文

静态代理(类似装饰模式)

静态代理需要先定义接口，被代理对象与代理对象一起实现相同的接口，然后通过调用相同的方法来调用目标对象的方法。

可以看见，代理类无非是在调用委托类方法的前后增加了一些操作。委托类的不同，也就导致代理类的不同。
代码示例：

接口类

public interface AdminService {
    void update();
    Object find();
}

实现类

public class AdminServiceImpl implements AdminService{
    public void update() {
        System.out.println("修改管理系统数据");
    }

    public Object find() {
        System.out.println("查看管理系统数据");
        return new Object();
    }
}

代理类

public class AdminServiceProxy implements AdminService {

    private AdminService adminService;

    public AdminServiceProxy(AdminService adminService) {
        this.adminService = adminService;
    }

    public void update() {
        System.out.println("判断用户是否有权限进行update操作");
        adminService.update();
        System.out.println("记录用户执行update操作的用户信息、更改内容和时间等");
    }

    public Object find() {
        System.out.println("判断用户是否有权限进行find操作");
        System.out.println("记录用户执行find操作的用户信息、查看内容和时间等");
        return adminService.find();
    }
}

测试类

public class StaticProxyTest {

    public static void main(String[] args) {
        AdminService adminService = new AdminServiceImpl();
        AdminServiceProxy proxy = new AdminServiceProxy(adminService);
        proxy.update();
        System.out.println("=============================");
        proxy.find();
    }
}

输出结果：

判断用户是否有权限进行update操作
修改管理系统数据
记录用户执行update操作的用户信息、更改内容和时间等
=============================
判断用户是否有权限进行find操作
记录用户执行find操作的用户信息、查看内容和时间等
查看管理系统数据

小结

优点：静态代理模式在不改变目标对象的前提下，实现了对目标对象的功能扩展。
缺点：静态代理实现了目标对象的所有方法，一旦目标接口增加方法，代理对象和目标对象都要进行相应的修改，增加维护成本。
如何解决静态代理中的缺点呢？答案是可以使用动态代理方式

动态代理(接口代理)

动态代理具有如下特点：
1. JDK动态代理对象不需要实现接口，只有目标对象需要实现接口。
2. 实现基于接口的动态代理需要利用JDK中的API，在JVM内存中动态的构建Proxy对象。
3. 需要使用到 java.lang.reflect.Proxy，和其newProxyInstance方法，但是该方法需要接收三个参数。

  @CallerSensitive
  public static Object newProxyInstance(
    ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException{}

注意该方法是在Proxy类中是静态方法，且接收的三个参数依次为：

ClassLoader loader：指定当前目标对象使用类加载器，获取加载器的方法是固定的。
Class<?>[] interfaces：目标对象实现的接口的类型，使用泛型方式确认类型。
InvocationHandler h：事件处理，执行目标对象的方法时，会触发事件处理器的方法，会把当前执行目标对象的方法作为参数传入。

代码示例：
代理类接口和代理接口实现类在上面[AdminService AdminServiceImpl]

//1 定义一个代理类工厂对象：实现接口InvocationHandler
class AdminServiceDynamicProxy implements InvocationHandler {
    //2 定义引用记录目标对象:通过构造方法关联
    private Object target;

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

    //3 定义方法 ：通过Proxy的newProxyInstance方法动态的在内存中创建目标对象的代理对象
    public Object getPersonProxy() {
        Object obj = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
        return obj;
    }

    //4 实现InvocationHandler的invoke方法：目标对象的每个方法被调用：此invoke方法发都会被调用一次
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法执行前操作");
        Object obj = method.invoke(target);
        System.out.println("方法执行后操作");
        return obj;
    }
}

测试

public class DynamicProxyTest {
    public static void main(String[] args) {

        // 方法一
        System.out.println("============ 方法一 ==============");
        AdminService adminService = new AdminServiceImpl();
        System.out.println("代理的目标对象：" + adminService.getClass());


        AdminService proxy = (AdminService) new AdminServiceDynamicProxy(adminService).getPersonProxy();

        System.out.println("代理对象：" + proxy.getClass());

        Object obj = proxy.find();
        System.out.println("find 返回对象：" + obj.getClass());
        System.out.println("----------------------------------");
        proxy.update();
    }
}

输出结果：

============ 方法一 ==============
代理的目标对象：class com.zhiyou100.annotation.AdminServiceImpl
代理对象：class com.sun.proxy.$Proxy0
方法执行前操作
查看管理系统数据
方法执行后操作
find 返回对象：class java.lang.Object
----------------------------------
方法执行前操作
修改管理系统数据
方法执行后操作

小结：

代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理。
动态代理的方式中，所有的函数调用最终都会经过 invoke 函数的转发，因此我们就可以在这里做一些自己想做的操作，比如日志系统、事务、拦截器、权限控制等。

JDK 动态代理有一个最致命的问题是它只能代理实现了某个接口的实现类，并且代理类也只能代理接口中实现的方法，要是实现类中有自己私有的方法，而接口中没有的话，该方法不能进行代理调用。
怎么解决这个问题呢？我们可以用 CGLIB 动态代理机制。

Cglib代理(基于继承的方式实现)

静态代理和JDK代理都需要某个对象实现一个接口，有时候代理对象只是一个单独对象，此时可以使用Cglib(导入spring核心jar包)代理。
Cglib代理可以称为子类代理，是在内存中构建一个子类对象，从而实现对目标对象功能的扩展。

Cglib通过Enhancer 来生成代理类，通过实现 MethodInterceptor接口，并实现其中的 intercept方法，在此方法中可以添加增强方法，并可以利用反射 Method或者 MethodProxy继承类来调用原方法。

代码示例：
目标对象

public class AdminCglibService {
    public void update() {
        System.out.println("修改管理系统数据");
    }

    public Object find() {
        System.out.println("查看管理系统数据");
        return new Object();
    }
}

代理类

//1 创建代理工厂类  实现接口 MethodInterceptor
public class AdminServiceCglibProxy implements MethodInterceptor {
    //2 关联目标对象
    private Object target;

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

    //3 创建方法获取代理对象
    public Object getProxyInstance() {
        //3.1 创建工具类
        Enhancer en = new Enhancer();
        //3.2 指定父类
        en.setSuperclass(target.getClass());
        //3.3 设置回调函数
        en.setCallback(this);
        //3.4 创建子类代理对象
        return en.create();
    }

    //4 实现 intercept 方法：目标对象的方法每次被调用 此方法都会被调用
    public Object intercept(Object object, Method method, Object[] arg2, MethodProxy proxy) throws Throwable {

        System.out.println("方法执行前的扩展代码");
        Object result = method.invoke(target);
        System.out.println("方法执行后的扩展代码");
        return result;
    }
}

测试类

public class CglibProxyTest {
    public static void main(String[] args) {
        //创建目标对象
        AdminCglibService target = new AdminCglibService();
        //创建工厂对象
        AdminServiceCglibProxy proxyFactory = new AdminServiceCglibProxy(target);
        //调用工厂对象的方法获取代理对象
        AdminCglibService proxy = (AdminCglibService) proxyFactory.getProxyInstance();
        System.out.println("代理对象：" + proxy.getClass());

        Object obj = proxy.find();
        System.out.println("返回的object对象:" + obj);
        System.out.println("======================");
        proxy.update();
    }
}

输出结果：

代理对象：class com.zhiyou100.annotation.AdminCglibService$$EnhancerByCGLIB$$11296649
方法执行前的扩展代码
查看管理系统数据
方法执行后的扩展代码
返回的object对象:java.lang.Object@3d71d552
======================
方法执行前的扩展代码
修改管理系统数据
方法执行后的扩展代码

Spring中AOP使用代理

Spring中AOP的实现有JDK和Cglib两种，如下图：
如果目标对象需要实现接口，则使用JDK代理。
如果目标对象不需要实现接口，则使用Cglib代理。

总结

静态代理：需要代理类和目标类都实现接口的方法，从而达到代理增强其功能。
JDK 动态代理：需要代理类实现某个接口，使用 Proxy.newProxyInstance方法生成代理类，并实现 InvocationHandler中的invoke方法，实现增强功能。
Cglib 动态代理：无需代理类实现接口，使用Cblib中的 Enhancer来生成代理对象子类，并实现 MethodInterceptor中的intercept方法，在此方法中可以实现增强功能。

相关阅读:
HTTP基础
 DHCP(六)
DOM备忘录
 正则表达式备忘录
 Function与Object的关系
 模块模式浅析
 视频下载
 JSP基础点滴
 迭代输出总结
 中文乱码问题的解决途径
原文地址：https://www.cnblogs.com/zk2020/p/15493883.html