代理模式

Proxy Pattern.：指为对象提供一种代理,用以控制对这个对象的访问. 是一种结构型模式。
简单的说就是我们本来是想访问对象A，但是想在访问A之前做一些其他的事情，这时候我们可以使用代理模式生成一个新的对象B，B可以做一些我们想做的事情。也就是代理模式，通过访问B来代替对A的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

• 代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。

代理模式有静态代理和动态代理两种实现方式。

静态代理

静态代理中，对目标对象的代理都是手动完成的（下面有代码实例），不是很灵活,比如接口一旦新增加方法，目标对象和代理对象都要进行修改，需要对每个目标类都单独写一个代理类。实际应用场景很少。

• 优点:可以做到在不修改目标对象的功能前提下,对目标功能进行扩展
  
  
• 缺点:因为代理对象需要与真实对象实现同样的接口,所以会有很多代理类，如果接口增加方法,真实对象与代理对象都要进行维护

接下来我们来个代码实现：

实现步骤：

• 定义一个接口及其实现类；（这个就是被代理的具体对象，不过静态代理有要求，代理的对象必须实现了某一接口，所以需要一个接口和实现类）
  
  
• 创建一个代理类（代理类也要实现上面的接口）
  
  
• 将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

代码展示：

第一步：定义接口以及实现接口

• 接口

public interface PService {
    String getName(String name);
}

• 实现类

public class PServiceImpl implements PService{
    @Override
    public String getName(String name) {
        return name;
    }
}

第二步创建个代理类（代理类也要实现上面的接口）

public class PServiceProxy implements PService{
    private final PService pService;

    public PServiceProxy(PService pService) {
        this.pService = pService;
    }

    @Override
    public String getName(String name) {
        //调用方法之前，我们可以添加自己的操作逻辑
        System.out.println("before method getName()");
        String nameT = pService.getName("zhang san");
        //调用方法之后，我们同样可以添加自己的操作逻辑
        System.out.println("after method getName()");
        return nameT;
    }
}

调用代理

public static void main(String[] args) {
    PService pService = new PServiceImpl();
    PServiceProxy pServiceProxy = new PServiceProxy(pService);
    pServiceProxy.getName("zhang san");
}

运行结果

静态代理成功。

动态代理

动态代理代理对象不需要实现接口，动态代理是利用JDK的API, 动态地在内存中构建代理对象.需要指定创建的代理对象或者目标对象实现的接口类型。分为俩种模式：JDK动态代理和
CGLIB 动态代理

JDK动态代理

实现步骤：

• 定义一个接口及其实现类；

• 实现 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑（也就是我们需要在代理方法前或者后需要的操作）；

• 通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象；

JDK动态代理InvocationHandler接口和 Proxy类是核心。

• Proxy
  需要调用newProxyInstance() ，这个方法主要用来生成一个代理对象。

这个方法一共有 3 个参数：

• loader :类加载器，用于加载代理对象。
• interfaces : 被代理类实现的一些接口；
• h : 实现了 InvocationHandler 接口的对象（里面会实现一些自定义处理逻辑）

• InvocationHandler
  用来自定义处理逻辑。 当我们的动态代理对象调用一个方法时候，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用。
  
  

• invoke() 方法有下面三个参数：
  proxy :动态生成的代理类
  method : 与代理类对象调用的方法相对应
  args : 当前 method 方法的参数

也就是说：你通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。 你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

接下来上实例：

第一步：定义接口以及实现接口

• 接口

public interface PService {
    String getName(String name);
}

• 实现类

public class PServiceImpl implements PService{
    @Override
    public String getName(String name) {
        return name;
    }
}

第二步定义一个 JDK 动态代理类（实现InvocationHandler接口）

public class InvocationHandlerTest implements InvocationHandler {

    /**
     * 代理类中的真实对象
     */
    private final Object object;

    public InvocationHandlerTest(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object result = method.invoke(object, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return result;
    }
}

invoke() 方法: 其实调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法昨晚我们需要的前置逻辑后，又去调用了被代理对象的原生方法，接着再继续后面的后置逻辑处理，最终代理结束。

第三步获取代理对象的工厂类

public class JdkProxyFactory {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
                // 用于目标类的类加载
                target.getClass().getClassLoader(),
                // 代理需要实现的接口，可指定多个
                target.getClass().getInterfaces(),
                // 代理对象对应的自定义 InvocationHandler，用于自定义逻辑处理
                new InvocationHandlerTest(target)
        );
    }
}

代理工厂getProxy() ：主要通过Proxy.newProxyInstance（）方法获取某个类的代理对象，其中代理类必须实现了InvocationHandler接口。

第四步代码使用

public static void main(String[] args) {
    PService pService = (PService) JdkProxyFactory.getProxy(new PServiceImpl());
    pService.getName("li si");
}

运行结果ok，jdk代理演示ok

• 注意：JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。

CGLIB动态代理

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB， 例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

MethodInterceptor 接口和 Enhancer 类是CGLIB代理核心。

记住CGLIB是需要单独引用jar包的：

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.3.0</version>
</dependency>

• MethodInterceptor

实现MethodInterceptor，重写 intercept 方法，intercept 用于拦截增强被代理类的方法。和JDK代理invoke方法类似。

• obj :被代理的对象（需要增强的对象）
• method :被拦截的方法（需要增强的方法）
• args :方法入参
• methodProxy :用于调用原始方法

Enhancer：
用来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法。

接下来直接看代码实例：

• 1.自定义个类，包含一个方法，也就是需要被代理的方法。
  
  

public class MethodA {
    String getName(String name) {
        System.out.println("this is MethodA is begin.");
        return name;
    }
}

• 2.自定义 MethodInterceptor（方法拦截器，也就是被代理方法的额外处理逻辑）

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CGLIBMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object object = methodProxy.invokeSuper(o, objects);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
      
        System.out.println(object);
        return object;
    }
}

• 3.获取代理类

import org.springframework.cglib.proxy.Enhancer;

public class CGLIBproxyfactory {
    public static Object getProxy(Class<?> clazz) {
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new CGLIBMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}

• 4.代理类的配合使用

public static void main(String[] args) {
    MethodA methodA = (MethodA) CGLIBproxyfactory.getProxy(MethodA.class);
    methodA.getName("wu fa");
}

运行结果：

• JDK动态代理和CGLIB动态代理的区别

1.JDK 动态代理只能只能代理实现了接口的类，而 CGLIB 可以代理未实现任何接口的类。 另外， CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。（cglib选择通过继承扩展原始对象，但java无法继承用final限定的类。 因此，cglib不能代理用final限定的类。jdk代理继承了Proxy类，只能在Java不能继承很多的前提下实现接口。 从这一点来看，cglib就业更广，还是往往勉强实现一个接口有点麻烦。）

2.就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

• 静态代理和动态代理的区别

灵活性 ：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！

JVM 层面 ：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。

动态代理是运行时动态生成代理类。动态代理的应用有 spring aop、hibernate 数据查询、测试框架的后端 mock、rpc，Java注解对象获取等。