使用JDK和CGLIB实现动态代理
在讲正题之前，先了解一下代理模式，非常形象逼真的买房子实例又要来了。
A去买房子，让B房屋中介公司负责相关事宜，比如看房子结构地段和卖房公司商量价格等等（没买过房子 乱讲的）
那么此时具体去买房子所要做的事情本来该是A做的，因为他要买房啊，但是却交给了B来管，
此时，A是被代理对象，B为代理对象
代理模式可以分为：远程代理，虚拟代理，保护代理，智能引用代理
代理模式的实现方法为；静态代理和动态代理
其中静态代理又分为 继承代理和聚合代理，在这就不敞开叙述了，一般情况下，采用聚合代理居多
使用JDK和CGLIB的区别
JDK只能代理实现了接口的类，如果没有实现接口的类则不能实现jdk动态代理
CGLIB是针对类来实现代理，对指定目标类产生一个子类，通过方法来拦截技术拦截所有父类方法的调用
也就是说，CGLIB不能代理用final修饰的类
下面讲 如何使用JDK代理实现动态代理
实现步骤：
1. 创建一个实现接口InvocationHandler的类，必须实现invoke方法，在invoke方法中放我们的业务逻辑处理
2.创建被代理的类以及接口（类必须实现接口）
3.在mian中调用Proxy静态方法，创建一个代理类
具体的实现过程：通过newProxyInstance返回代理对象
（1）声明一段源码，动态的产生代理
（2）编译源码（JDK Compiler API），产生新的类，也就是代理类
（3）将这个类load到内存当中，产生一个新的对象，也就是代理对象
（4）return 代理对象
4.通过代理调用方法
代码示例：
接口：
public interface Moveable {
void move();
}
实现类：
public class Car implements Moveable {
@Override
public void move() {
//实现开车
try {
Thread.sleep(new Random().nextInt(1000));
System.out.println("汽车行驶中....");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
事务处理类：
public class TimeHandler implements InvocationHandler {
public TimeHandler(Object target) {
super();
this.target = target;
}
private Object target;
/*
* 参数：
* proxy 代理对象
* method 被代理对象的方法
* args 方法的参数
*
* 返回值：
* Object 方法的返回值
* */
@Override
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
long starttime = System.currentTimeMillis();
System.out.println("汽车开始行驶....");
method.invoke(target);
long endtime = System.currentTimeMillis();
System.out.println("汽车结束行驶.... 汽车行驶时间：" + (endtime - starttime) + "毫秒！");
return null;
}
}
测试类：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import com.imooc.proxy.Car;
import com.imooc.proxy.Moveable;
public class Test {
/**
* JDK动态代理测试类
*/
public static void main(String[] args) {
Car car = new Car();
InvocationHandler h = new TimeHandler(car);
Class cls = car.getClass();
/**
* loader 类加载器
* interfaces 实现接口
* h InvocationHandler
*/
Moveable m = (Moveable)Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(), h);
m.move();
}
}
此时如果想在时间处理事务的基础上添加其他处理，比如日志记录，则可再写一个实现了InvocationHandler接口的
LogHandler类，注意在Main方法中，添加loghandler时，可以选择先输出log还是时间
注意是哪个放在后面，就先执行哪个
public class Test {
public static void main(String[] args) {
/**
* 先Log后Time
*/
Car c=new Car();
InvocationHandler h=new TimeHandler(c);
Class cla=c.getClass();
Moveable m=(Moveable) Proxy.newProxyInstance(cla.getClassLoader(), cla.getInterfaces(), h);
InvocationHandler h2=new LogHandler(m);
Moveable m2=(Moveable) Proxy.newProxyInstance(cla.getClassLoader(), cla.getInterfaces(), h2);
m2.move();
/**
* 先Time后Log
*/
Car c=new Car();
InvocationHandler h=new LogHandler(c);
Class cla=c.getClass();
Moveable m=(Moveable) Proxy.newProxyInstance(cla.getClassLoader(), cla.getInterfaces(), h);
InvocationHandler h2=new TimeHandler(m);
Moveable m2=(Moveable) Proxy.newProxyInstance(cla.getClassLoader(), cla.getInterfaces(), h2);
m2.move();
}
}
Log先的输出：
log start!
start
end 10008
log end!
CGLIB实现动态代理
被代理类：
public class Car {
public void move(){
System.out.println("moving...");
}
}
事务处理：
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CglibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
public Object getProxy(Class clazz){
//设置创建子类的类
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
/**
* 拦截所有目标类方法的调用
* obj 目标类的实例
* m 目标方法的反射对象
* args 方法的参数
* proxy代理类的实例
*/
@Override
public Object intercept(Object obj, Method m, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("日志开始...");
//代理类调用父类的方法
proxy.invokeSuper(obj, args);
System.out.println("日志结束...");
return null;
}
}
测试类：
public class Test {
public static void main(String[] args) {
CglibProxy proxy = new CglibProxy();
Car t = (Car)proxy.getProxy(Car.class);
t.move();
}
}
输出：
日志开始...
moving...
日志结束...