【Java 动态代理】Java动态代理的学习

1 参考资料

Java编程思想

2 代理的思想

用官方一点的话说：
设计模式–代理模式是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个真实对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

通过代理层这一中间层，有效的控制对于真实委托类对象的直接访问，同时可以实现自定义的控制策略（Spring的AOP机制），设计上获得更大的灵活性。

用自己的话理解一下：
emm，这里有一个大胆的假设，我有一个女朋友(￣▽￣)。然后今天要和她出去吃饭，本来素颜出去就行的，但是她非得出门前化个妆，吃完饭回来后又得卸妆。在我看来（程序员角度），完全没必要嘛。但是在她看来（产品角度）这是非常必要！

然后，我们用面向对象思想来代码化一下这个场景。假设有一个类A（真正的业务实现类），A中有一个方法，叫做带女朋友出去吃饭。
然后，有一个类B（代理类，实现一些骚操作），A是B的成员，然后有一个方法叫做带化妆的女朋友去吃饭。在这个方法里我们调用了A类的带女朋友出去吃饭方法。

看看伪代码

//业务实现类，我们真正要做的事
class A{
	public void 带女朋友出去吃饭(){
	}
}

class B{
	A a;
	public void 带化妆的女朋友出去吃饭(){
	
		让女朋友化个妆
	
		a.带女朋友出去吃饭();
	
		吃完补个妆
	}
}

然后，来张正式点的图

3 静态代理和动态代理

这个比较好理解，所谓静态代理就是指，我们上面定义的类B，是程序一开始就定义好的。编译期就存在的。
动态代理就是程序运行过程中才动态建立的，一般依靠反射技术创建。这有一篇介绍反射的。

4 Java中的动态代理

写个简单的代码例子吧。

//一个接口
public interface People {
    void eating();
}

//一个接口的实现类
public class GirlFriend implements People {
    @Override
    public void eating() {
        System.out.println("girl friend eating something");
    }
}


//动态代理实现
import java.lang.reflect.Proxy;

public class DynamicProxy {
    public static void main(String[] arg) {
        GirlFriend min = new GirlFriend();

        People gfProxy =(People) Proxy.newProxyInstance(min.getClass().getClassLoader(),
                min.getClass().getInterfaces(),(proxy,method,args)->{
                    if(method.getName().equals("eating")){
                        System.out.println("让她化个装");
                        return method.invoke(min,args);
                    }

                    return null;
                }) ;

        gfProxy.eating();
    }
}

结果

另一个例子，这个写的比较正统，接口是单独写的，引用于 https://www.jianshu.com/p/de68a6dfb621

//懒，就写一起了
public class MainTest {
    //测试方法
    public static void main(String[] args) throws Exception {
        MainTest mainTest = new MainTest();
        mainTest.test();
        //MyInvocationHandler类的invoke方法进入
        //我是汽车
        //MyInvocationHandler类的invoke方法退出
    }

    public void test() {
        //调用Proxy的静态方法，创建一个代理类
        InvocationHandler handler = new MyInvocationHandler(new Car());
        IProduct iProduct = (IProduct) Proxy.newProxyInstance(IProduct.class.getClassLoader(),
                new Class[]{IProduct.class},
                handler);
        //参数1：类加载器(Class Loader)
        //参数2：需要实现的接口数组
        //参数3：InvocationHandler接口。
        
                //(1)根据参数loader和interfaces调用方法 getProxyClass(loader, interfaces)
                //创建代理类$Proxy0，$Proxy0类实现了interfaces的接口,并继承了Proxy类
                //(2)实例化$Proxy0并在构造方法中把handler传过去,接着$Proxy0调用父类
                //Proxy的构造器,为h赋值,如下:
                //class Proxy{
                //   InvocationHandler h=null;
                //   protected Proxy(InvocationHandler h) {
                //    this.h = h;
                //   }
                //   ...
                //}
        
        //通过代理调用方法
        iProduct.show();
    }

    //创建一个实现InvocationHandler接口的类，必须实现invoke()方法
    public class MyInvocationHandler implements InvocationHandler {

        private IProduct iProduct;

        public MyInvocationHandler(IProduct iProduct) {
            this.iProduct = iProduct;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("MyInvocationHandler类的invoke方法进入");
            Object invoke = method.invoke(iProduct, args);
            System.out.println("MyInvocationHandler类的invoke方法退出");
            return invoke;
        }
    }

    //被代理的类
    public class Car implements IProduct {
        @Override
        public void show() {
            System.out.println("我是汽车");
        }
    }

    //被代理的接口
    public interface IProduct {
        void show();
    }

}

5 动态代理的底层实现

先看，生成代理实例的函数，第一个参数是类加载器，第二个是接口的Class对象数组，第三个是一个调用处理器接口。

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
 /
	public interface InvocationHandler {
	    public Object invoke(Object proxy, Method method, Object[] args)
	        throws Throwable;
	        //这个调用处理程序里面就实现代理需要各种操作。proxy是代理对象，menthod是调用的方法，
	        //args是自己可以添加的参数
	}

接下来是生成代理类对象的源码分析，额，简单分析。看下图红色框框，可以总结为4个步骤。

1. 获取接口Class对象的拷贝intfs
2. 用类加载器loader和接口的Class对象生成代理类的Class对象cl
3. 获取代理类的构造函数cons
4. 用cons调用newInstance() 返回一个代理类的实例
   5.

6 动态代理的应用场景

动态代理的好处就是，它比较灵活，可以在运行的时候才切入改变类的方法，而不需要预先定义它。
Srping的AOP（切面编程）中就应用了大量动态代理。