一．概念
- 为其他对象提供一种代理，以控制对这个对象的访问；
二．分类
- 远程代理：比如用一台远程服务器统计各个分店的销售情况
- 虚拟代理：比如图片预加载
- 保护代理：登录权限，登录后才可以某个对象操作等；
- 智能引用代理：提供对目标对象额外的一些服务（以下是我们要详细学习的）
以下用
静态代理和动态代理实现智能引用代理
三．静态代理
- 代理和被代理对象在代理之前是确定的．他们都实现相同的接口或继承相同的抽象类；
proxy-1.jpg
四．实现静态代理
１．MoveAble接口如下：
package proxy.statics;
/**
* 移动接口
* @author lxf
*
*/
public interface MoveAble {
public void move();
}
２．被代理类Car
package proxy.statics;
import java.util.Random;
/**
* 被代理类，汽车
* @author lxf
* @2017-07-06
*/
public class Car implements MoveAble {
@Override
public void move() {
//System.out.println("被代理对象---我是汽车对象本身："+this.getClass().getName());
//实现开车
try {
System.out.println("汽车行驶中...");
Thread.sleep(new Random().nextInt(1000));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
３．使用继承方式实现静态代理
package proxy.statics;
/**
* 使用继承的方式实现静态代理
* @author lxf
* @date 2017-07-06
*/
public class ProxyCar2 extends Car {
@Override
public void move() {
//开始时间
Long start = System.currentTimeMillis();
System.out.println("汽车开始行驶...");
super.move();
//结束时间
Long end = System.currentTimeMillis();
System.out.println("汽车结束行驶..." + "行驶话费了：" + (end-start) + "ms");
}
}
４．main方法测试：
//使用继承方式实现代理
MoveAble m = new ProxyCar2();
car2.move();
使用继承方式实现静态代理缺点是不够灵活，当对被代理方法执行叠加功能的时候，特别是
灵活的调换叠加功能的顺序时，需要很多代理类
Paste_Image.png
** 以下是使用聚集的方式实现（也就是在代理类中引用被代理类），代理和被代理类都实现相同的接口：**
５．聚集的方式实现代理类
package proxy.statics;
/**
* 聚集的方式实现静态代理（时间代理）
* @author lxf
* @date 2017-07-06
*/
public class ProxyTimerCar implements MoveAble{
//被代理Car对象
private Car car;
public ProxyTimerCar(Car car)
{
this.car = car;
}
@Override
public void move() {
//开始时间
Long start = System.currentTimeMillis();
System.out.println("汽车开始行驶...");
//执行被代理对象的方法
car.move();
//结束时间
Long end = System.currentTimeMillis();
System.out.println("汽车结束行驶..." + "行驶话费了：" + (end-start) + "ms");
}
}
６．main方法测试：
//使用聚集的方式实现代理
Car car = new Car();
MoveAble m = new ProxyTimerCar(car);
m.move();
7．我们在添加一个日志代理类
package proxy.statics;
/**
* 聚集的方式实现静态代理（日志代理类）
* @author lxf
* @date 2017-07-06
*/
public class ProxyLogCar implements MoveAble{
//被代理Car对象
private MoveAble m;
public ProxyLogCar(MoveAble m)
{
this.m = m;
}
@Override
public void move() {
System.out.println("记录日志开始..");
//执行被代理对象的方法
m.move();
System.out.println("记录日志结束...");
}
}
８．叠加时间和日志的代理
//使用聚集的方式实现代理
Car car = new Car();
//先记录日志
ProxyTimerCar tm = new ProxyTimerCar(car);
//在记录时间
ProxyLogCar lm = new ProxyLogCar(tm);
lm.move();
输出结果是：
记录日志开始..
汽车开始行驶...
汽车行驶中...
汽车结束行驶...行驶话费了：982ms
记录日志结束...
当然顺序也可以先日志在时间，这样比继承要灵活很多；
ProxyTimerCar是对汽车做时间上的代理，如果有自行车，火车...，需要新增很多代理类
Paste_Image.png
那么就需要使用动态代理来减少代理类的编写；
五．动态代理（JDK方式）
Paste_Image.png
Paste_Image.png
六，创建动态代理的顺序
１．创建一个实现接口InvocationHandler的类，他必须实现invoke方法，在该方法中实现业务罗辑；
package proxy.dynamic.jdk;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class TimerHandler implements InvocationHandler {
//被代理对象
private Object target;
public TimerHandler(Object target) {
super();
this.target = target;
}
/**
* 参数：
* ＠param: proxy 代理的对象
* @method ：代理对象的方法
* ＠args: 代理对象的方法的参数
*
* 返回值：
* 被代理的对象方法的返回值
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//开始时间
Long start = System.currentTimeMillis();
System.out.println("汽车开始行驶...");
//使用反射调用被代理对象的方法
method.invoke(target);
//结束时间
Long end = System.currentTimeMillis();
System.out.println("汽车结束行驶..." + "行驶话费了：" + (end-start) + "ms");
return null;
}
}
２．创建被代理的类及接口；（就是上面的Car类和MoveAble方法）
３．调用Proxy静态方法，创建一个代理类（同时实例化该代理类）；
４．通过代理调用方法；
public class TestMain {
public static void main(String[] args)
{
Car car = new Car();
InvocationHandler h = new TimerHandler(car);
Class<?> cls = car.getClass();
/**
* 参数：
* loader 被代理类的类加载器
* interfaces 被代理类实现的接口
* invocationHandle 事务处理器（真正的代理业务罗辑）
*/
//Proxy.newProxyInstance(loader, interfaces, arg2);
//动态实例话代理对象
MoveAble m = (MoveAble)Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), h);
m.move();
}
}
执行结果：
汽车开始行驶...
汽车行驶中...
汽车结束行驶...行驶话费了：95ms
七．动态代理（CGLIB）方式实现
１．导入jar包 ( cglib-nodep-2.2.2.jar )
２．创建被代理类Train
package proxy.dynamic.cglib;
/**
* 火车类，不继承任何接口
* @author lxf
*
*/
public class Train {
public void move()
{
System.out.println("火车行驶中!");
}
}
３．创建生成代理类的动态代理类
package proxy.dynamic.cglib;
import java.beans.Encoder;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
* 用cglib方式实现动态代理（原理就是继承的方式）
* @author lxf
*
*/
public class CglibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
/**
* 创建代理类
* @param c
* @return
*/
public Object getProxy(Class c)
{
//设置创建子类的类
enhancer.setSuperclass(c);
enhancer.setCallback(this);
return enhancer.create();
}
/**
* 拦截所有目标类方法的调用
* 参数：
* obj 目标类的实例
* method 目标方法的反射对象
* args 方法的参数列表
* proxy 代理类的实例
*/
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("火车运行开始...");
//代理类调用父类的方法
proxy.invokeSuper(obj, args);
System.out.println("火车运行结束...");
return null;
}
}
４．测试
package proxy.dynamic.cglib;
public class testMain {
public static void main(String[] args)
{
//实例化cglibProxy代理类
CglibProxy proxy = new CglibProxy();
//实例火车类
Train train = new Train();
//获得代理类对象
Train t = (Train)proxy.getProxy(train.getClass());
//通过代理对象执行火车的move方法
t.move();
}
}
输出：
火车运行开始...
火车行驶中!
火车运行结束...
八．JDK动态代理和CGLIB动态代理的区别：
Paste_Image.png
动态代理的实现思路点击查看
