Java代理

静态代理

本质： 不改变源代码的情况下对功能进行增强

需求：

在不改变原有代码的基础上，在项目现有所有类的方法前后打印日志。
通过静态代理实现：

• 为项目的每一个类都编写一个对应的代理类，且代理类和被代理类都实现相同的接口，代理类中存在被代理类的引用；
• .在创建代理对象时，通过构造器塞入一个目标对象，然后在代理对象的方法内部调用目标对象同名方法，并在调用前后打印日志。
  也就是说，代理对象 = 增强代码 + 目标对象（原对象）。有了代理对象后，就不用原对象了
  
  

静态代理实现

• 公共的接口

public interface HelloInterface {
    void sayHello();
}

• 被代理对象实现公共接口

public class Hello implements HelloInterface{
    @Override
    public void sayHello() {
        System.out.println("Hello zhanghao!");
    }
}

• 代理对象实现该接口，同时代理对象中存在被代理对象引用

public class ProxyHandler implements HelloInterface {
    private Hello hello;//被代理对象

    public ProxyHandler(Hello hello) {
        this.hello = hello;
    }

    @Override
    public void sayHello() {
        System.out.println("执行前");//增强
        hello.sayHello();
        System.out.println("执行后");//增强
    }
}

• 测试

public class Demo {
    public static void main(String[] args) {
     Hello hello=new Hello();
     ProxyHandler proxy=new ProxyHandler(hello);
     proxy.sayHello();
     //执行前
     //Hello!
     //执行后
    }
}

缺陷

• 每一个代理只能服务于一个类，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。

动态代理（JDK）

继承静态代理的优点，弥补静态代理的不足

• 用到的类：java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy类

Proxy

Proxy类通过getProxyClass(ClassLoader, interfaces)可以返回代理Class对象。通俗的讲，只要你给它传入类加载器和一组接口，它就给你返回代理Class对象
Proxy.getProxyClass()这个方法的本质就是：以Class造Class。

InvocationHandler

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

invoke(Object proxy, Method method, Object【】 args) ｛
这个方法第一个参数，是生成的代理类，目前没发现用处，不管它。
第二个参数，是执行的方法(利用反射的原理，可以去看反射，也很简单。)
第三个参数，是执行某方法需要的参数。
第二个第三个参数解释执行的方法意思是：代理类不是要代理某个对象么，然后增强里面的方法么，指得就是这个方法，代理类会为几乎所有方法都增强，除非你在这里做判断。
返回值，是执行这个方法所返回的值。
然后你要去执行方法，就是用第二参数的invoke(obj,args);第一个参数是你要增强的对象。第二个是参数。object是你返回的类型
Object object= method.invoke(obj,args);
｝

Proxy

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
生成代理类Proxy.newProxyInvocation(参数1.参数2，参数3)
参数1：表名你要用那个类加载器去加载生成的代理类。（这个是JVM类加载的知识，可以去了解一下，挺简单）。
参数2：说明你要生成的代理类的接口。
参数3：实现了InvocationHandle的类，这个类只有一个方法需要你要实现它。

实现

• 公共的接口

public interface HelloInterface {
    void sayHello();
}

• 被代理对象实现公共接口

public class Hello implements HelloInterface{
    @Override
    public void sayHello() {
        System.out.println("Hello zhanghao!");
    }
}

• 动态生成代理对象

public class ProxyHandler implements InvocationHandler {
    private Object object;
    public  ProxyHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("执行前");
        method.invoke(object,args);
        System.out.println("执行后");
        return null;
    }
    public Object getProxy(){
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
    }
}

• 测试

public class Demo {
    public static void main(String[] args)  {

        HelloInterface hello=new Hello();
        InvocationHandler handler=new ProxyHandler(hello);
        HelloInterface proxyHello  =(HelloInterface) ((ProxyHandler) handler).getProxy();
        proxyHello.sayHello();
    }
}