关于java动态代理的作用，小白理解

关于动态代理这个词，嗯......太高深了，这里先咳嗽两声。

我今天买了两本书，一本英语，一本数学，书可以读，看。

public interface Book {
	void readTheBook();
}

英语和数学，虽然是书，但内容不一样。

public class EnglishBook implements Book{

	@Override
	public void readTheBook() {
		System.out.println("leibs:are you OK?");
	}
}

public class MathBook implements Book{

	@Override
	public void readTheBook() {
		System.out.println("1 + 1 = 0?");
	}

}

好咧，我要开始读了，先读英语吧。

public static void main(String[] args) {
		Book book = new EnglishBook();
		book.readTheBook();
		
	}

这跟动态代理有毛关系？是没什么关系。

这时，我想统计下，我读一本书，要多长时间。

那我加呗：

public class EnglishBook implements Book{

	@Override
	public void readTheBook() {
		long start = System.currentTimeMillis();
		System.out.println("leibs:are you OK?");
		long end = System.currentTimeMillis();
		System.out.println(end - start);
	}
}

这下知道读英语的时间了，然后再往MathBook里加同样的代码，要是有语文，地理，化学，也一样加。

代码是这样写的？

估计你的上级已经打电话：喂，老板。这个类的代码又乱写，没骂他，上个类也没骂他。不过这个类还是有问题，他这是思想出了问题。

开个玩笑，明凯的粉丝别锤我。

言归正传，那咋整呢？

答案：动态代理来解决

加个代理类：

public class ProxyHandler implements InvocationHandler{

	private Object tar;
	
    //2020-03-08新增
    public ProxyHandler(Object tar){
        this.tar = tar;
    }
    
    //2020-03-08遗弃，原因：强制转换类型
    /*public Object bind(Object tar) {
        this.tar = tar;
        return Proxy.newProxyInstance(tar.getClass().getClassLoader(),
                                      tar.getClass().getInterfaces(),
                                      this);
    }*/

    //2020-03-08新增
    @SuppressWarnings("unchecked")
    public <T> T bind(){
        return (T)Proxy.newProxyInstance(tar.getClass().getClassLoader(),
                                      tar.getClass().getInterfaces(),
                                      this);
    }
 
    public Object invoke(Object proxy , Method method , Object[] args) throws Throwable {
        Object result = null;
        //在调用具体函数方法前，执行功能处理
        long start = System.currentTimeMillis();
        result = method.invoke(tar,args);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        //在调用具体函数方法后，执行功能处理
        return result;
    }
}

再把调用方式改改：

public static void main(String[] args) {
    //2020-03-08遗弃
    /*
	ProxyHandler proxy = new ProxyHandler();
    Book book = (Book) proxy.bind(new EnglishBook());
    book.readTheBook();*/

    //2020-03-08新增
    ProxyHandler proxy = new ProxyHandler(new EnglishBook());
    Book book = proxy.bind();
    book.readTheBook();
}

把EnglishBook里的代码还原回去，此时，就算是有再多的实现类，也不用花时间去加了，我代理类已经帮我整好了。

是不是发现这东西，跟spring 的AOP 相似？