代理模式是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方法执行后
三者的特点和区别
通过代码可以很明显的看出：
- 静态代理，要把被代理的对象写在类里面，只能处理一个类，执行效率高，代码的耦合度很高，复用性很差。
- JDK 动态代理，是代理类要实现 InvocationHandler 接口，接口里面有个（method.invoke(对象，参数) 方法，它是利用反射执行被代理对象的方法；Java 动态代理通过 Proxy.newProxyInstance() 方法动态的获得代理对象，这个方法有三个参数：（类加载器、接口，InvocationHandler 接口的子类实例）；其中有个参数是接口，也就是说，Java 动态代理只能代理实现了接口的类，被代理的类如果没有实现任何接口，则不能实现 JDK 动态代理。
- Cglib 动态代理，和 JDK 动态代理通过接口实现不同， Cglib 动态代理通过继承实现，通过生成子类字节码，重写被代理类的方法，在重写的方法中增强功能；因为 Cglib 动态代理要继承被代理的类，所以，被 final 修饰的类或方法不能实现 Cglib 动态代理。
