代理模式
静态代理
1）定义一个接口
package com.imooc.proxy; public interface Moveable { void move(); }
2）被代理类
package com.imooc.proxy; import java.util.Random; public class Car implements Moveable { @Override public void move() { //实现开车 try { Thread.sleep(new Random().nextInt(1000)); System.out.println("汽车行驶中...."); } catch (InterruptedException e) { e.printStackTrace(); } } }
3）代理类
日志代理：
package com.imooc.proxy; public class CarLogProxy implements Moveable { public CarLogProxy(Moveable m) { super(); this.m = m; } private Moveable m; @Override public void move() { System.out.println("日志开始...."); m.move(); System.out.println("日志结束...."); } }
记时代理
package com.imooc.proxy; public class CarTimeProxy implements Moveable { public CarTimeProxy(Moveable m) { super(); this.m = m; } private Moveable m; @Override public void move() { long starttime = System.currentTimeMillis(); System.out.println("汽车开始行驶...."); m.move(); long endtime = System.currentTimeMillis(); System.out.println("汽车结束行驶.... 汽车行驶时间：" + (endtime - starttime) + "毫秒！"); } }
测试类：
package com.imooc.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(); } }
结果：
**聚合方式要优于继承方式
继承：继承父类想要的功能
聚合：传入参数，实现想要的父类
如果为继承方式，如果日志和时间的位置要调换，那么需要新定义一个子类
而继承方式只需要在测试类中，调换位置就行
动态代理：
动态代理不必为特定的对象与方法编写特定的代理对象，使用动态代理，可以使得一个处理折Handler服务于各个对象
接口和被代理类不用改变
时间代理类：！！继承InvocationHandler的接口
package com.imooc.proxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class TimeProxyHandler implements InvocationHandler { private Object target; public TimeProxyHandler(Object target) { super();//调用父类的构造方法 this.target = target; } /* * 参数： * proxy 被代理对象 * method 被代理对象的方法 * args 方法的参数 * * 返回值： * Object 方法的返回值 * */ @Override public Object invoke(Object proxy, Method mothod, Object[] args) throws Throwable { System.out.println("运行开始"); long starttime = System.currentTimeMillis(); mothod.invoke(target); long endtime = System.currentTimeMillis(); System.out.println("运行结束，运行时间为："+(endtime-starttime)+"毫秒"); return null; } //获得代理对象 public static Object getTimeProxy(Object object){ InvocationHandler h = new TimeProxyHandler(object); Class<?> cls = object.getClass(); /** * loader 类加载器 * interfaces 实现接口 * h InvocationHandler **/ return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), h); } }
测试类
package com.imooc.proxy; public class Test { /** * JDK动态代理测试类 */ public static void main(String[] args) { Moveable m = (Moveable) TimeProxyHandler.getTimeProxy(new Car());
//返回代理类,代理类是JVM在内存中动态创建的,该类实现传入的接口数组的全部接口(的全部方法).
m.move();
}
}
InvocationHandler角色：
代理模式：
代理类处理的逻辑很简单：在调用某个方法前及方法后做一些额外的业务。
动态代理工作的基本模式就是将自己的方法功能的实现交给 InvocationHandler角色，外界对Proxy角色中的每一个方法的调用，Proxy角色都会交给InvocationHandler来处理，而InvocationHandler则调用具体对象角色的方法。如下图所示：
在这种模式之中：代理Proxy 和RealSubject 应该实现相同的功能，这一点相当重要。（我这里说的功能，可以理解为某个类的public方法）
在面向对象的编程之中，如果我们想要约定Proxy 和RealSubject可以实现相同的功能，有两种方式：
a.一个比较直观的方式，就是定义一个功能接口，然后让Proxy 和RealSubject来实现这个接口。（JDK机制）
1. 获取 RealSubject上的所有接口列表；
2. 确定要生成的代理类的类名，默认为：com.sun.proxy.$ProxyXXXX ；3. 根据需要实现的接口信息，在代码中动态创建 该Proxy类的字节码；
4 . 将对应的字节码转换为对应的class 对象；
5. 创建InvocationHandler 实例handler，用来处理Proxy所有方法调用；
6. Proxy 的class对象 以创建的handler对象为参数，实例化一个proxy对象
b.还有比较隐晦的方式，就是通过继承。因为如果Proxy 继承自RealSubject，这样Proxy则拥有了RealSubject的功能，Proxy还可以通过重写RealSubject中的方法，来实现多态。（cglib机制）
1. 查找A上的所有非final 的public类型的方法定义；
2. 将这些方法的定义转换成字节码；
3. 将组成的字节码转换成相应的代理的class对象；
4. 实现 MethodInterceptor接口，用来处理 对代理类上所有方法的请求（这个接口和JDK动态代理InvocationHandler的功能和角色是一样的）
CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。
两者区别：
java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
