静态代理
共同的父类
public interface IMath {
//加intadd(intn1,int n2);
}
被代理类
public class Math implements IMath {
//加publicintadd(intn1,int n2){
intresult=n1+n2;
System.out.println(n1+"+"+n2+"="+result);
return result;
}
}
代理类
public class MathProxy implements IMath {
//被代理的对象
IMath math=new Math();
//加
public int add(int n1, int n2) {
//开始时间
long start=System.currentTimeMillis();
lazy();
int result=math.add(n1, n2);
Long span= System.currentTimeMillis()-start;
System.out.println("共用时："+span);
return result;
}
}
main方法测试
public class Test {
IMath math=new MathProxy();
public void test01()
{
int n1=100,n2=5;
math.add(n1, n2);
}
}
总结：
代理类与被代理类共同实现父类方法，代理类中有被代理类的对象，实现方法中还有代理对象的方法及新加功能。执行：new一个代理对象并执行代理对象中的方法也就意味着执行了被代理类的方法和新方法。
解决了“开闭原则（OCP）”的问题，因为并没有修改Math类，而扩展出了MathProxy类。
如果项目中有多个类，则需要编写多个代理类，工作量大，不好修改，不好维护，不能应对变化。
动态代理
只需要一个代理类，而不是针对每个类编写代理类。
代理类实现
public class DynamicProxy implements InvocationHandler {
//被代理的对象
Object targetObject;
/**
* 获得被代理后的对象
* @param object 被代理的对象
* @return 代理后的对象
*/
public Object getProxyObject(Object object){
this.targetObject=object;
return Proxy.newProxyInstance(
targetObject.getClass().getClassLoader(), //类加载器
targetObject.getClass().getInterfaces(), //获得被代理对象的所有接口
this); //InvocationHandler对象
//loader:一个ClassLoader对象，定义了由哪个ClassLoader对象来生成代理对象进行加载
//interfaces:一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
//h:一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上，间接通过invoke来执行
}
/**
* 当用户调用对象中的每个方法时都通过下面的方法执行，方法必须在接口
* proxy 被代理后的对象
* method 将要被执行的方法信息（反射）
* args 执行方法时需要的参数
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//被织入的内容，开始时间
long start=System.currentTimeMillis();
lazy();
//使用反射在目标对象上调用方法并传入参数
Object result=method.invoke(targetObject, args);
//被织入的内容，结束时间
Long span= System.currentTimeMillis()-start;
System.out.println("共用时："+span);
return result;
}
执行类
public class Test {
//实例化一个MathProxy代理对象
//通过getProxyObject方法获得被代理后的对象
IMath math=(IMath)new DynamicProxy().getProxyObject(new Math());
public void test01()
{
int n1=100,n2=5;
math.add(n1, n2);
}
总结：
代理类中的被代理类变为object,通过getproxy方法传入被代理类获得被代理的类和方法通过反射，拿到类和所有方法的接口然后通过 InvocationHandl中的invoke方法invoke(Object proxy, Method method, Object[] args)拿到要执行的Method在调用invoke方法执行该方法且在该方法中加入要修改的方法。
cglib代理
实战CGLib系列文章 MethodInterceptor和Enhancer - jackyechina的专栏 - CSDN博客
使用cglib完成动态代理，大概的原理是：cglib继承被代理的类，重写方法，织入通知，动态生成字节码并运行，因为是继承所以final类是没有办法动态代理的
public class DynamicProxy implements MethodInterceptor {
// 被代理对象
Object targetObject;
//Generate a new class if necessary and uses the specified callbacks (if any) to create a new object instance.
//Uses the no-arg constructor of the superclass.
//动态生成一个新的类，使用父类的无参构造方法创建一个指定了特定回调的代理实例
public Object getProxyObject(Object object) {
this.targetObject = object;
//增强器，动态代码生成器
Enhancer enhancer=new Enhancer();
//回调方法
enhancer.setCallback(this);
//设置生成类的父类类型
enhancer.setSuperclass(targetObject.getClass());
//动态生成字节码并返回代理对象
return enhancer.create();
}
// 拦截方法
public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
// 被织入的横切内容，开始时间 before
long start = System.currentTimeMillis();
lazy();
// 调用方法
Object result = methodProxy.invoke(targetObject, args);
// 被织入的横切内容，结束时间
Long span = System.currentTimeMillis() - start;
System.out.println("共用时：" + span)
return result;
}
总结：
JDK的动态代理机制只能代理实现了接口的类，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
