Java代理模式

代理模式的定义： 为其他对象提供一种代理以控制对这个对象的访问。代理对象起到中介作用，可以去掉功能服务或者添加额外的服务

静态代理： 代理和被代理对象在代理之前是确定的。他们都实现相同的接口或者继承相同的抽象类

UML图：



以聚合代理的方式实现静态代理为例：
首先抽象接口

package proxy;

public interface Moveable {
void move();
}

被代理对象

package proxy;

import java.util.Random;

public class Car implements Moveable {

public void move() {
try {
Thread.sleep(new Random().nextInt(1000));
System.out.println("汽车行驶.....");
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

代理类1：

package proxy;

public class CarLogProxy implements Moveable {

public CarLogProxy(Moveable m) {
super();
this.m = m;
}

private Moveable m;

public void move() {
System.out.println("Log开始");
m.move();
System.out.println("Log结束");
}

}

代理类2:

package proxy;

public class CarTimeProxy implements Moveable {

public CarTimeProxy(Moveable m) {
super();
this.m = m;
}

private Moveable m;

public void move() {
System.out.println("计时开始");
m.move();
System.out.println("计时结束");
}

}

测试：

package proxy;

public class Client {

public static void main(String[] args) {
Car car = new Car();
CarLogProxy clp = new CarLogProxy(car);
CarTimeProxy ctp = new CarTimeProxy(clp);
ctp.move();
}

}

运行结果：

计时开始
Log开始
汽车行驶.....
Log结束
计时结束

但静态代理只能代理一种类型的被代理类，换个类型的就不行了，这需要动态代理

Java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类：
（1）Interface InvocationHandler : 该接口中定义了一个方法
public object invoke(Object obj , Method method , Object[] args)
在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，args为该方法的参数数组。这个抽象方法在代理类中动态实现。
(2) Proxy : 该类即为动态代理类
static Object newProxyInstance(ClassLoader loader , Class[] interfaces , InvocationHandler h) ： 返回代理类的一个实例， 返回后的代理类可以当作被代理类使用

动态代理实现步骤
（1）创建一个实现接口InvocationHandler的类，它必须实现invoke方法
（2）创建被代理的类以及接口
（3）调用Proxy的静态方法，创建一个代理类
newProxyInstance(ClassLoader loader , Class[] interfaces , InvocationHandler h)
（4） 通过代理调用方法
例：
抽象接口

package proxy;

public interface Moveable {
void move();
}

被代理类：

package proxy;

import java.util.Random;

public class Car implements Moveable {

public void move() {
try {
Thread.sleep(new Random().nextInt(1000));
System.out.println("汽车行驶....");
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

InvocationHandler 实现类

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class TimeHandler implements InvocationHandler {

public TimeHandler(Object target) {
super();
this.target = target;
}

private Object target;

public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {

System.out.println("计时前");
method.invoke(target);
System.out.println("计时后");
return null;
}

}

测试：

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

import proxy.Car;
import proxy.Moveable;

public class Test {

public static void main(String[] args) {
Car car = new Car();
InvocationHandler h = new TimeHandler(car);
Class<?> cls = car.getClass();

Moveable m = (Moveable)Proxy.newProxyInstance(cls.getClassLoader(),
cls.getInterfaces(), h);
m.move();
}

}

运行结果：

计时前
汽车行驶....
计时后

除了使用JDK实现动态代理之外，还可以使用CGLIB实现 ，需要引入cglib的jar包

被代理类：

package cglibproxy;

public class Train {

public void move(){
System.out.println("汽车行驶...");
}
}

代理类：

package cglibproxy;

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();
}

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;
}

}

测试：

package cglibproxy;

public class Client {

/**
* @param args
*/
public static void main(String[] args) {

CglibProxy proxy = new CglibProxy();
Train t = (Train)proxy.getProxy(Train.class);
t.move();
}

}

运行结果：

代理开始..
汽车行驶...
代理结束...

两种动态代理的区别
JDK动态代理：
（1） 只能代理实现了接口的类；
（2）没有实现接口的类不能实现JDK的动态代理。

CGLIB动态代理：
（1） 针对类来实现代理的；
（2）对指定目标类产生一个子类， 通过方法拦截技术拦截所有的父类方法的调用。