代理模式是Java常用的设计模式，代理类通过调用被代理类的相关方法，并对相关方法进行增强。加入一些非业务性代码，比如事务、日志等操作。Spring 的 AOP 就是基于代理模式的思想实现的。
在接触代理模式之前觉得使用代理很麻烦，一个类的方法为什么不直接调用，还要通过增加的代理类，其实，当你只有一个类要实现一些增加的功能时，直接在这个类里增加方法是很简单，当你有几十个，几百个类要增加相同功能时，一个一个的添加就非常繁琐。使用代理，一是增加功能很方便，直接写在代理类里就可以了；二是降低了代码的耦合度，更加便于调整和维护，要调整时，只要调整代理类就可以了，其他类的代码都不用动。
结合代码看一下，Java 常用代理模式，以及之间的区别：
静态代理
- 接口
public interface Animal {
public void eat();
}- 实现类（被代理的类）
public class Dog implements Animal{
@Override
public void eat() {
System.out.println("狗吃肉骨头");
}
}- 静态代理类
public class StaticProxy implements Animal{
//被代理对象
private Animal dog = new Dog();
@Override
public void eat() {
System.out.println("StaticProxy执行前");
dog.eat();//被代理对象的方法
System.out.println("StaticProxy执行后");
}
}- 测试
public class Test {
public static void main(String[] args) {
Animal dog = new StaticProxy();
dog.eat();
}
} - 运行结果
StaticProxy执行前
狗吃肉骨头
StaticProxy执行后JDK 动态代理
接口和实现类同上
// JDK 动态代理，实现 InvocationHandler 接口
public class DynamicProxy implements InvocationHandler{
private Object obj;//被代理对象
//传入被代理对象
public Object getProxy(Object objA){
this.obj = objA;
//创建代理对象，并关联被代理对象
Object objProxy = Proxy.newProxyInstance(objA.getClass().getClassLoader(),
objA.getClass().getInterfaces(), this);
return objProxy;
}
//使用反射技术，协助调用被代理对象的方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("DynamicProxy方法执行前");
Object objResult = method.invoke(obj, args);
System.out.println("DynamicProxy方法执行后");
return objResult;
}
}- 测试
public class Test {
public static void main(String[] args) {
//JDK 动态代理
Animal dog = new Dog();
DynamicProxy dp = new DynamicProxy();
Animal dogProxy = (Animal) dp.getProxy(dog);
dogProxy.eat();
}
}- 运行结果
DynamicProxy方法执行前
狗吃肉骨头
DynamicProxy方法执行后Cglib 动态代理
接口和实现类同上
//cglib 动态代理，实现 MethodInterceptor 接口
public class CglibProxy implements MethodInterceptor{
//被代理的对象
private Object obj;
//传入目标对象
public CglibProxy(Object objA){
this.obj = objA;
}
public Object getProxy(){
//创建目标对象的子对象，通过反射对父对象的内容拦截和处理
Enhancer e = new Enhancer();
e.setSuperclass(obj.getClass());
e.setCallback(this);
//返回代理对象
return e.create();
}
@Override
public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("CglibProxy方法执行前");
Object result = methodProxy.invoke(obj, args);
System.out.println("CglibProxy方法执行后");
return result;
}
}- 测试
public class Test {
public static void main(String[] args) {
//cglib代理
Animal dog = new Dog();
CglibProxy proxy = new CglibProxy(dog);
Animal dogProxy = (Animal) proxy.getProxy();
dogProxy.eat();
}
}- 运行结果
CglibProxy方法执行前
狗吃肉骨头
CglibProxy方法执行后三者的特点和区别
通过代码可以很明显的看出：
1. 静态代理，要把被代理的对象写在类里面，只能处理一个类，执行效率高，代码的耦合度很高，复用性很差。
2. JDK 动态代理，是代理类要实现 InvocationHandler 接口，接口里面有个（method.invoke(对象，参数) 方法，它是利用反射执行被代理对象的方法；Java 动态代理通过 Proxy.newProxyInstance() 方法动态的获得代理对象，这个方法有三个参数：（类加载器、接口，InvocationHandler 接口的子类实例）；其中有个参数是接口，也就是说，Java 动态代理只能代理实现了接口的类，被代理的类如果没有实现任何接口，则不能实现 JDK 动态代理。
3. Cglib 动态代理，和 JDK 动态代理通过接口实现不同， Cglib 动态代理通过继承实现，通过生成子类字节码，重写被代理类的方法，在重写的方法中增强功能；因为 Cglib 动态代理要继承被代理的类，所以，被 final 修饰的类或方法不能实现 Cglib 动态代理。