一、开篇
什么是Java代理呢？Java的代理就是客户类不再直接和委托类打交道，而是通过一个中间层来访问，而这个中间层就是代理。比如当我们想给某个类中的方法加一些额外的操作处理，就可以给这个类创建一个代理类，这个类不仅包含了原来类的方法功能，而且还在原来的基础上增加了额外的处理功能。
为什么要这样做呢？是因为增加代理还是有好处的：
- 可以隐藏委托类的实现。
- 可以实现客户端和委托类之间的解耦，在不修改委托类代码的情况下能够添加一些额外操作（
解耦、灵活、扩展性强）。
二、静态代理
静态代理就是代理类在编译期间就创建好了，是手动创建的类。即代理类和委托类的关系在程序运行前就已经存在了。她适合用于代理类比较少且确定的情况，如果委托类有方法很多就会很难受，要在代理类中写一堆的代理方法。
实现步骤
- 定义接口和接口的实现类。
- 定义接口的代理对象，并将接口的实例注入到代理对象中。
- 然后通过代理对象调用真实的实现类。
代码案例
//委托类接口
public interface IHelloService {
String sayHello(String message);
}
//委托类实现类
public class HelloService implements IHelloService{
public String sayHello(String message) {
System.out.println("I am static proxy,"+word);
return "I am static proxy,"+word;
}
}
//代理类
public class StaticProxyHello implements IHelloService{
private IHelloService helloService = new HelloService();
public String sayHello(String message) {
beforeProcess();
String result = helloService.sayHello(message);
afterProcess();
return result;
}
private void beforeProcess(){
System.out.println("我是委托类方法处理之前要执行的方法。。。。");
}
private void afterProcess(){
System.out.println("我是委托类处理之后执行的方法。。。。");
}
}
//测试静态代理
public class MainStatic {
public static void main(String[] args) {
StaticProxyHello proxy = new StaticProxyHello();
proxy.sayHello("我是静态代理。。。");
}
}
执行结果打印如下：
我是委托类方法处理之前要执行的方法。。。。
I am static proxy,我是静态代理。。。
我是委托类处理之后执行的方法。。。。
静态代理说白了就是一个代理模式。代理模式主要就是一个接口，一个委托类，一个代理类。代理类持有委托类的实例，代理类执行具体类的实例方法。代理类存在的意义就是增强委托类，可以增加一些额外的处理逻辑。
Java动态代理
代理类是在程序运行时创建的代理方式称为动态代理，相比于静态代理而言，动态代理的优势可以对代理类中的方法进行统一的处理，而不用修改每个代理类中的方法。在java动态代理中主要涉及两个类，java.lang.reflect.InvocationHandler和java.lang.reflect.Proxy，需要创建一个代理类来实现InvocationHandler接口，这个接口中只有一个方法invoke，我们在对委托类中所有的方法调用都会变成是调用invoke方法。这样我们就可以在invoke方法中添加一些特定的逻辑进行处理。
实现步骤
//委托类接口
public interface IHelloService {
String sayHello(String message);
}
//委托类具体实现
public class HelloService implements IHelloService {
@Override
public String sayHello(String message) {
System.out.println("执行了sayHello方法....");
return "消息内容：" + message;
}
}
//代理类
public class HelloProxyInvocationHandler implements InvocationHandler {
private Object obj;
public HelloProxyInvocationHandler(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
beforeProcess();
Object result = method.invoke(obj, args);
afterProcess();
return result;
}
private void beforeProcess() {
System.out.println("增加方法調用之前执行的额外操作...");
}
private void afterProcess() {
System.out.println("增加方法調用之后执行的额外操作...");
}
}
//测试动态代理类
public class MainProxy {
public static void main(String[] args) {
HelloProxyInvocationHandler proxyInvocationHandler = new HelloProxyInvocationHandler(new HelloService());
IHelloService helloProxy = (IHelloService) Proxy.newProxyInstance(HelloService.class.getClassLoader(),
new Class<?>[]{IHelloService.class}, proxyInvocationHandler);
helloProxy.sayHello("我是jdk动态代理");
}
}
执行之后的结果打印：
增加方法調用之前执行的额外操作...
执行了sayHello方法....
增加方法調用之后执行的额外操作...
上面的测试动态代理类中, 我们调用Proxy类的newProxyInstance方法来获取一个代理类实例。这个代理类实现了我们指定的接口并且会把方法调用分发到指定的调用处理器。
首先通过newProxyInstance方法获取代理类的实例, 之后就可以通过这个实例调用代理类的方法，对代理类的方法调用都会调用invoke方法，在invoke方法中我们调用委托类的对应方法，然后加上自己的处理逻辑。
java动态代理最大的特点就是动态生成的代理类和委托类实现同一个接口。java 动态代理其实内部是通过反射机制实现的，也就是已知的一个对象，在运行的时候动态调用它的方法，并且调用的时候还可以加一些自己的逻辑在里面。
CGlib动态代理
JDK的动态代理依赖于接口，当我们只有类而没有接口的时候，我们需要借助一个三方框架CGlib来实现动态代理。CGLIB代理是针对类来实现代理的，原理是对指定的委托类生成一个子类并重写其中业务方法来实现代理。但因为采用的是继承，所以不能对final修饰的类进行代理。final修饰的类不可继承。
实现步骤
maven依赖:
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2</version>
</dependency>
代码实现如下：
//委托类
public class HelloService {
public String sayHello(String message) {
System.out.println("目标对象sayHello执行了....");
return "消息内容：" + message;
}
}
//对方法调用拦截以及回调
public class HelloInterceptor implements MethodInterceptor {
/**
* 用于生成 Cglib 动态代理类工具方法
* @param target 委托类
* @return
*/
public Object initCglib(Class target) {
Enhancer enhancer = new Enhancer();// 为代理类指定需要代理的类，也即是父类
enhancer.setSuperclass(target);// 设置方法拦截器回调引用，对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept() 方法进行拦截
enhancer.setCallback(this);// 获取动态代理类对象并返回
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
beforeProcess();
Object result = methodProxy.invokeSuper(o, args);
afterProcess();
return result;
}
private void beforeProcess() {
System.out.println("增加方法調用之前执行的额外操作...");
}
private void afterProcess() {
System.out.println("增加方法調用之后执行的额外操作...");
}
}
//测试
public class MainCglib {
public static void main(String[] args) {
HelloInterceptor interceptor = new HelloInterceptor();
HelloService helloService = (HelloService) interceptor.initCglib(HelloService.class);
helloService.sayHello("我是cglib实现的动态代理");
}
}
执行之后的结果打印：
增加方法調用之前执行的额外操作...
目标对象sayHello执行了....
增加方法調用之后执行的额外操作...
对于需要被代理的类，它只是动态生成一个子类以覆盖非final的方法，同时绑定钩子回调自定义的拦截器。
总结
静态代理相对而言比较容易理解, 需要委托类和代理类实现同一个接口, 然后在代理类中调用真正实现类, 并且静态代理的关系在编译期间就已经确定了。而动态代理的关系是在运行期间确定的。静态代理实现简单，适合于代理类较少且确定的情况，而动态代理则给我们提供了更大的灵活性。
JDK动态代理所用到的代理类在程序调用到代理类对象时才由JVM真正创建，JVM根据传进来的业务实现类对象以及方法名，动态地创建了一个代理类的class文件并被字节码引擎执行，然后通过该代理类对象进行方法调用。
静态代理和动态代理都是基于接口实现的, 而对于那些没有提供接口只是提供了实现类的而言, 就只能选择CGLIB动态代理了。
Cglib和jdk动态代理的区别？
- JDK动态代理基于Java反射机制实现, 必须要实现了接口的业务类才能用这种方法生成代理对象。
- CGLIB动态代理基于ASM框架通过生成业务类的子类来实现。
静态代理、JDK动态代理、CGlib动态代理优缺点？
静态代理：代理对象和实际对象都实现同一个接口，在代理对象中指向的是实际对象的实例，这样对外暴露的是代理对象而真正调用的是真实对象。
- 优点：可以很好的保护实际对象的业务逻辑对外暴露，从而提高安全性。
- 缺点：不同的接口要有不同的代理类实现，会很冗余
JDK动态代理：为了解决静态代理中，生成大量的代理类造成的冗余；JDK动态代理只需要实现InvocationHandler接口，重写invoke方法便可以完成代理的实现，jdk的代理是利用反射生成代理类Proxyxx.class代理类字节码，并生成对象。jdk动态代理之所以只能代理接口是因为代理类本身已经继承了Proxy，而java是不允许多重继承。
- 优点：解决了静态代理中冗余的代理实现类问题。
- 缺点：JDK 动态代理是基于接口设计实现的，如果没有接口，会抛异常。
CGLIB动态代理：
由于JDK动态代理限制了只能基于接口设计，而对于没有接口的情况，JDK方式解决不了；CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑，来完成动态代理的实现。实现方式实现MethodInterceptor接口，重写intercept方法，通过Enhancer类的回调方法来实现。
但是CGLib在创建代理对象时所花费的时间却比JDK多得多，所以对于单例的对象，因为无需频繁创建对象，用CGLib合适，反之，使用JDK方式要更为合适一些。同时，由于 CGLib 由于是采用动态创建子类的方法，对于final方法，无法进行代理。
- 优点：没有接口也能实现动态代理，而且采用字节码增强技术，性能也不错。
- 缺点：技术实现相对难理解些。
写在最后
动态代理在Java开发中是非常常见的，在日志、监控、事务中都有着广泛的应用，同时在大多主流框架中的核心组件中也是少不了使用的，掌握其要点，不管是开发还是阅读其他框架源码时，都是必须的。希望这篇文章能给大家带来帮助。喜欢加关注，后续持续更新！！！
