本文原创掘金：L_Sivan
前言
上一篇写的那个代理模式，是属于静态代理。假设一种场景，假设我们要为很多类的很多方法添加前置和后置方法（别忘了代理模式是为了控制），按照静态代理的方法，我们就得为所有类的所有方法一个一个地去实现需求，想想这工程量就觉得可怕，所以就有了很优美的实现方式，叫做动态代理。
JDK代理
且看代码
// 抽象接口
public interface MyInterface {
void hello(int i, int j);
void hello(int i, int j, int k);
}
// 接口实现类，也是我们的代理目标类
public class MySubject implements MyInterface{
@Override
public void hello(int i, int j) {
System.out.println("hello(): "+i+"-"+j);
}
@Override
public void hello(int i, int j, int k) {
System.out.println("hello(): "+i+"-"+j+"~"+k);
}
}
// 这个是关键，被代理对象方法的实际执行地方，通过反射实现
public class MyInvocationHandler implements InvocationHandler{
// 被代理的目标对象
private Object target;
MyInvocationHandler(Object target) {
super();
this.target = target;
}
@Override
/\*\*
\* proxy 代理的目标对象
\* method 代理的目标对象的方法
\* args，方法的参数
\*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("方法： " + method.getName() + "执行前");
StringBuilder sb = new StringBuilder("方法的参数：");
for (Object arg : args) {
sb.append(arg.toString()+" ");
}
System.out.println(sb.toString());
Object result = method.invoke(target, args);
System.out.println("方法： " + method.getName() + "执行后");
return result;
}
}
// 场景类
public class Client {
public static void main(String[] args) {
MyInterface mySubject = new MySubject();
MyInvocationHandler handler = new MyInvocationHandler(mySubject);
MyInterface mySubjectProxy = (MyInterface) Proxy.newProxyInstance(mySubject.getClass().getClassLoader(),
mySubject.getClass().getInterfaces(), handler);
proxy.getProxyObject();
mySubjectProxy.hello(5,98);
System.out.println("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");
mySubjectProxy.hello(5, 23, 54);
}
}
结果：
方法： hello执行前
方法的参数：5 98
hello(): 5-98
方法： hello执行后
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
方法： hello执行前
方法的参数：5 23 54
hello(): 5-23~54
方法： hello执行后
比较关键的就三个地方：
- 一、被代理的目标对象必须实现接口，即上文的
MySubject和MyInterface。 - 二、实现InvocationHandler接口的handler类，即上文中的
public class MyInvocationHandler implements InvocationHandler。方法的参数说明在上面也有了，这里就不在阐述了。 - 三、使用Proxy类获取到目标对象的代理对象，即上文中的
Proxy.newProxyInstance(mySubject.getClass().getClassLoader(),mySubject.getClass().getInterfaces(), handler);
之前也想过Proxy是怎么实现这个代理过程的，结果在这里看到了。 回到上面的代码，其实上面的代码还可以封装下，比如变成下面的样子：
// 接口类，接口实现类，handler类都没变化，引入下面的类
// 简单的动态代理类，传入一个目标对象参数，得到其代理对象
public class DynamicProxy{
private MyInvocationHandler handler;
private Object target;
public DynamicProxy(Object _target) {
this.target = _target;
handler = new MyInvocationHandler(_target);
}
public Object getProxyObject(){
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
}
}
// 场景类
public class Client {
public static void main(String[] args) {
MyInterface mySubject = new MySubject();
**DynamicProxy proxy = new DynamicProxy(mySubject);
MyInterface mySubjectProxy = (MyInterface) proxy.getProxyObject();**
mySubjectProxy.hello(5,98);
System.out.println("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");
mySubjectProxy.hello(5, 23, 54);
}
}
结果：
方法： hello执行前
方法的参数：5 98
hello(): 5-98
方法： hello执行后
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
方法： hello执行前
方法的参数：5 23 54
hello(): 5-23~54
方法： hello执行后
上面场景类的代码，用自然语言解释挺流畅的，就是创建代理类对象，通过代理类对象获取被代理对象的代理对象。反正封装方法多种多样，上面其实其中一种，有意者多试试呗。 上面就是JDK代理，但是JDK代理有一个限制，就是上面说到的关键点的第一点，JDK代理无法脱离接口而实现，要为某个目标对象实现JDK代理，该目标对象至少实现一个接口，那如果要为没实现接口的类实现代理，怎么办，就是我们的Cglib代理。
cglib代理
且看代码
// 我们的代理目标类，这次是没有实现接口的
public class MySubject {
public void hello(int i, int j) {
System.out.println("hello(): "+i+"-"+j);
}
public void hello(int i, int j, int k) {
System.out.println("hello(): "+i+"-"+j+"~"+k);
}
}
// cglib代理类
public class CglibProxy implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("方法： " + method.getName() + "执行前");
StringBuilder sb = new StringBuilder("方法的参数：");
for (Object arg : args) {
sb.append(arg.toString() + " ");
}
System.out.println(sb.toString());
Object obj = methodProxy.invokeSuper(o, args);
System.out.println("方法： " + method.getName() + "执行后");
return obj;
}
}
// 场景类
public class Client {
public static void main(String[] args) {
CglibProxy cglibProxy = new CglibProxy();
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(MySubject.class);
enhancer.setCallback(cglibProxy);
// 得到代理对象
MySubject o = (MySubject) enhancer.create();
o.hello(5, 98);
System.out.println("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");
o.hello(5, 23, 54);
}
}
结果：
方法： hello执行前
方法的参数：5 98
hello(): 5-98
方法： hello执行后
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
方法： hello执行前
方法的参数：5 23 54
hello(): 5-23~54
方法： hello执行后
cglib是提供动态代理的第三方库，并不是jdk给我们代理，所以需要自己解决导包的问题。 这里，cglib设计的几个核心类，分别是：
- net.sf.cglib.proxy.Enhancer – 主要的增强类
- net.sf.cglib.proxy.MethodInterceptor – 主要的方法拦截类，它是Callback接口的子接口，需要用户实现
- net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用
核心方法就是public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable ,第一个参数是代理对象，第二和第三个参数分别是拦截的方法和方法的参数，第四个是方法的代理对象。这个就是cglib代理。
以上就是动态代理。
