一、静态代理
先看代码:
public interface Movable {
void move();
}
class Tank implements Movable {
@Override
public void move() {
System.out.println("Tank is Moving.....");
try {
//模拟坦克的移动过程
Thread.sleep(new Random().nextInt(1000));
}catch (Exception e){
e.printStackTrace();
}
}
}
Tank类实现了Movable接口,现在我们需要记录Tank运动的开始时间和结束时间
public class TankTimeProxy implements Movable {
Movable t;
//此处传入Tank参数
public TankTimeProxy(Movable t)
{
super();
this.t = t;
}
public void move() {
System.out.println(System.currentTimeMillis());
t.move();
System.out.println(System.currentTimeMillis());
}
}
测试类
public class Client {
public static void main(String[] args) {
Movable t = new Tank();
Movable ttp = new TankTimeProxy(t);
ttp.move();
}
}
这里我们使用组合的方式把Tank的实现作为参数传递给了TankTimeProxy
那么问题就来了,如果我们想要对坦克的运动加上日志是否需要重新实现代理类?
如果我们需要给任任意类的方法加上日志和时间,那么我们需要些许多的代理类
很明显,这样的写法不具有扩展性,我们希望这个代理对象能够实现对任意对象的代理。
二、动态代理的原理
根据要求,动态代理需要实现的功能是,给被代理对象的的每个方法加上代理逻辑。因此,我们需要考虑以下问题:
1、如何得到被代理类的所有接口(也就是方法)
2、如何动态的生成新的代理类
第一个问题可以通过反射获得
对于第二个问题,一个很直观的想法是,在Proxy.newInstance()中,我们首先加上代理的逻辑(日志、事物、时间等),然后利用反射执行被代理对象的方法。生成新的代理类的JAVA文件,然后把上述代码进行编译,这个过程可参考
JavaComplier的使用
这样即可得到代理对象的class文件,具体可以参照马士兵老师设计模式的课程。
三、Java对动态代理的支持
主要有两个类:Proxy和InvocationHandler(接口)
Proxy的主要作用是利用newProxyInstance()产生新的代理类
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
我们来看看这三个参数所代表的含义:
loader: 一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载,一般采用被代理对象的classLoader
interfaces: 一个Interface型的数组,表示的是我将要给代理对象提供一组什么接口,如果我提供了一组接口给它,那么这个代理对象就可以实现该接口,并重写其中的每个方法
h: 一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上
每一个动态代理类都必须要实现InvocationHandler接口,通过newProxyInstance知道,每个代理类的实例都关联到了一个handler,当我们通过代理对象调用一个方法的时候,这个方法的调用就会被转化为由InvocationHandler这个接口的 invoke 方法来进行调用。
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
proxy: 指代我们所代理的那个真实对象,一般作为参数传入InvocationHandler这个接口中的实现类中(组合)
method: 指代的是我们所要调用真实对象的某个方法的Method对象
args: 指代的是调用真实对象某个方法时接受的参数
一个具体的例子:
public class TimeHander implements InvocationHandler{
Object target;
public TimeHander(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
beforeMethod();
method.invoke(target);
afterMethod();
return null;
}
public void beforeMethod(){
System.out.println("Start.....");
}
public void afterMethod(){
System.out.println("end....");
}
}
public class client {
@Test
public void testProxy() {
Movable t = new Tank();
InvocationHandler h = new TimeHander(t);
//和被代理对象使用相同的classLoader
//代理后的Proxy无法看到生产的源码
Movable m = (Movable)Proxy.newProxyInstance(t.getClass().getClassLoader(),t.getClass().getInterfaces(),h);
m.move();
m.stop();
}
}
三、动态代理的应用
在面向对象的设计思想中,使用动态代理可以很方便的增强一个类的行为,相比于继承和静态代理,使用动态代理无疑是更好的选择。
在web开发中,我们经常使用的拦截器以及基于AOP的对日志、权限的管理都是通过动态代理实现的。