jdk动态代理

1：jdk动态代理的简单实现https://www.cnblogs.com/xiaoluo501395377/p/3383130.html

package com.li.chapter09;

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

public class DynamicProxyTest {
    interface IHello{
        void sayHello();
    }

    static class Hello implements IHello{

        @Override
        public void sayHello() {
            System.out.println("Hello world");
        }
    }

    static class DynamicProxy implements InvocationHandler{

        Object originalObj;  //对象
        Object bind(Object originalObj){ //绑定目标对象
            this.originalObj=originalObj;
            //返回代理实例,originalObj.getClass().getInterfaces()是真实对象的实现的接口数组

 /*
         * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
         * 第一个参数 handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
         * 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
         * 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
         */

 return Proxy.newProxyInstance(originalObj.getClass().getClassLoader(), originalObj.getClass().getInterfaces(), this); } @Override public Object invoke(Object o, Method method, Object[] objects) throws Throwable { System.out.println("welcome"); return method.invoke(originalObj, objects); //调用目标对象方法  } } 

public static void main(String[] args){ 
//原因就是在newProxyInstance这个方法的第二个参数上，我们给这个代理对象提供了一组什么接口，那么我这个代理对象就会实现了这组接口，这个时候我们当然可以将这个代理对象强制类型转化为这组接口中的任意一个，因为这里的接口是Subject类型，所以就可以将其转化为Subject类型了。
IHello hello = (IHello) new DynamicProxy().bind(new Hello()); 

// IHello决定使用哪一个接口  
hello.sayHello(); } }

结果：

welcome
Hello world

2：一个类实现两个接口

package com.li.chapter09;

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

public class DynamicProxyTest {
    interface IHello{
        void sayHello();
    }
    interface IHello2{
        void sayHello2();
    }

    static class Hello implements IHello,IHello2{
        @Override
        public void sayHello() {
            System.out.println("Hello world");
        }

        @Override
        public void sayHello2() {
            System.out.println("Hello world 2");
        }
    }

    static class DynamicProxy implements InvocationHandler{

        Object originalObj;  //对象
        Object bind(Object originalObj){ //绑定目标对象
            this.originalObj=originalObj;
            //返回代理实例
            return Proxy.newProxyInstance(originalObj.getClass().getClassLoader(), originalObj.getClass().getInterfaces(), this);
        }
        @Override
        public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
            System.out.println("welcome");
            return method.invoke(originalObj, objects);  //调用目标对象方法
        }
    }

    public static void main(String[] args){
        IHello hello = (IHello) new DynamicProxy().bind(new Hello());   //
        hello.sayHello();

        IHello2 hello2 = (IHello2) new DynamicProxy().bind(new Hello());   //
        hello2.sayHello2();
    }

}

结果：

welcome
Hello world
welcome
Hello world 2

jdk动态代理：当为一个对象创建代理类时，会将对象的方法，equals,toString,hashCode方法都传给代理类,这几个类都被代理了，当使用它们时，会调用invoke方法。代理类也包含InvocationHander。当代理类执行对象的方法时，会执行com.sun.proxy.Proxy中的(h)InvocationHander.invoke方法

public $Proxy0(InvocationHandler invocationhandler) {
super(invocationhandler); //调用父类的InvocationHandler就是调用DynamicProxy。创建出来的代理类是DyanmicProxy的子类。 DynamicProxy是一个InvocationHandler
}

发现：使用 Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), invocationhandle) 生成代理类时，是创建一个$Proxy0.java文本，一点一点写入，该类实现了目标对象的接口，代理的方法有目标对象的方法，equals,hashcode,toString()。这几个方法都调用了 invocationhandle 中的invoke方法。最后将该对象强转成接口对象作为代理对象返回，

https://github.com/1367356/GradleTestUseSubModule/tree/master/SpringAOPTheory