前言
Java语言本身是具有动态性的，在我们平时使用中，存在两种动态代理，分别是出自官方之手的JDK动态代理，一种是出自民间的CGLib(Code Generation Library)。
JDK动态代理
JDK动态代理依赖接口，所以我们首先创建一个接口类 Hello
public interface Hello {
public void sayHello();
}
接下来就是一个接口实现类 HelloImpl
public class HelloImpl implements Hello {
public void sayHello() {
System.out.println("HelloImpl is invoking sayHello() method...");
}
}
至此，我们准备工作已经做好了，接下来看看我们还需要做哪些工作
我们需要创建一个类，这个类的作用是给我们动态创建出来的代理类调用的，暂且命名为 DynamicProxy 吧。该类需要继承自 InvocationHandler 接口，并实现 invoke() 方法。
public class DynamicProxy implements InvocationHandler {
//委托对象实例
private Object target;
public DynamicProxy(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if(method.getName().equals("sayHello")) {
before();
Object result = method.invoke(target,args);
after();
return result;
}
return null;
}
public void before() {
System.out.println("before invoke sayHello() method");
}
public void after() {
System.out.println("after invoke sayHello() method");
}
}
可以看到在 invoke() 方法中我们在方法执行前后添加了自定义的行为，我们称之为方法拦截。接下来就是书写 main() 方法了。
public class ProxyTest {
public static void main(String[] args) {
//创建实现接口的对象
Hello helloImpl = new HelloImpl();
//该类的作用就是对方法进行拦截
DynamicProxy dynamicProxy = new DynamicProxy(helloImpl);
//在运行过程中动态创建代理类
Hello helloProxy = (Hello) Proxy.newProxyInstance(helloImpl.getClass().getClassLoader(),
helloImpl.getClass().getInterfaces(),
dynamicProxy);
//通过代理类调用方法
helloProxy.sayHello();
}
}
具体的各类之间关系我们还是来看UML图吧。
JDK动态代理
如上图，我们可以看到，通过JDK生成的动态代理类$HelloProxy100与委托类(实现Hello接口的HelloImpl类)是兄弟关系，当要执行动态代理类$HelloProxy100中的任一方法时，都会去调用DynamicProxy类中的invoke()方法，这样我们就对方法实现了拦截。
JDK动态代理优化
我们在 DynamicProxy 类中添加一个获取代理类的方法，以后每次通过这个 DynamicProxy 中间类来获取代理类。
@SuppressWarnings("unchecked")
public <T> T getProxy() {
return (T) Proxy.newProxyInstance(this.target.getClass().getClassLoader(),
this.target.getClass().getInterfaces(),
this);
}
这样我们的 main() 方法中的代码量就大大减少了。
public class ProxyTest {
public static void main(String[] args) {
DynamicProxy dynamicProxy = new DynamicProxy(new HelloImpl());
Hello helloProxy = dynamicProxy.getProxy();
helloProxy.sayHello();
}
}
CGLib动态代理
与JDK动态代理相比，CGLib动态代理是不需要接口的，这里就创建一个普通类 Hi
public class Hi {
public void sayHi() {
System.out.println("Hi,my friend");
}
}
接着，创建出一个与 DynamicProxy 作用(给动态创建出的代理类调用)相似的类，创建一个叫做 CGLibProxy 的类，该类必须实现 MethodInterceptor 接口，并实现 interceptor() 方法。
public class CGLibProxy implements MethodInterceptor {
public <T> T getProxy(Class<?> cls) {
return (T) Enhancer.create(cls,this);
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before();
//执行委托类中的原方法
Object result = methodProxy.invokeSuper(o,objects);
after();
return result;
}
public void before() {
System.out.println("before method");
}
public void after() {
System.out.println("after method");
}
}
最后书写 main() 方法。
public class ProxyTest {
public static void main(String[] args) {
CGLibProxy cgLibProxy = new CGLibProxy();
Hi hiProxy = cgLibProxy.getProxy(Hi.class);
hiProxy.sayHi();
}
}
各类关系我们还是使用UML来表示
CGLib动态代理
可以看出，生成的动态代理类 $HiProxy100 是委托类的子类，通过反编译工具查看 $HiProxy100 源代码可得知，该类重写了委托类的 sayHi() 方法，如果发现存在实现了 MethodInterceptor 接口的对象，那么就会通过这个对象调用 intercept() 方法对委托类中的每一个方法进行拦截(除了final方法，因为final方法不能被继承，所以动态代理类自然就没有这个方法)。
网友评论