静态代理

• 代理模式大家应该都比较熟悉了，最起码都听过，当初学习SpringAop时，动态代理的源码把我整的是懵懵的
• 说白了就是在不修改原有逻辑给这个方法前后加一些实现，比如常用的加日志，计算方法执行时间，做事务控制。。。

• 缺点就是项目庞大后，代理类过于多，并且接口增加方法后，原方法和代理方法都要跟这改

  public interface Kernel {
    void shopping();
  }
  class Chaotic implements Kernel{
    @Override
    public void shopping() {
        System.out.println("这里是一团很乱的逻辑，不能再修改本方法了");
    }
  }
  class ChaoticProxy implements Kernel{
    public Chaotic chaotic;
    public ChaoticProxy(Chaotic teacherDao){
        this.chaotic = teacherDao;
    }
    @Override
    public void shopping() {
        System.out.println("很乱的逻辑执行前~~~");
        long start = System.currentTimeMillis();
        chaotic.shopping();
        long end = System.currentTimeMillis();
        double sj = (end-start)/1000;
        log.info("耗时："+sj)
        System.out.println("这团乱糟糟的逻辑执行完了。。。耗时："+sj);
    }
  }
  class Test{
    public static void main(String[] args) {
        Kernel iTeacherDao = new ChaoticProxy(new Chaotic());
        iTeacherDao.shopping();
        很乱的逻辑执行前~~~
        这里是一团很乱的逻辑，不能再修改本方法了
        这团乱糟糟的逻辑执行完了。。。耗时：0.1
    }
  }

  动态代理

• 静态代理的优点动态代理都有，Proxy会帮你创建代理对象

• 相同接口业务的不需要创建很多代理类，比静态代理灵活

• newProxyInstance这个方法参数含义：ClassLoader loader指定目标对象使用的类加载器，Class<?>[] interfaces获取传入对象实现的接口，InvocationHandler h 实现代理模式方法，可以实现InvocationHandler重写invoke方法，也可以在入参里重写invoke方法，如果实现InvocationHandler重写invoke，这里入参传this就可以了

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException

• 

public interface Kernel {
    void shopping();
}
class Chaotic implements Kernel{
    @Override
    public void shopping() {
        System.out.println("这里是一团很乱的逻辑，不能再修改本方法了");
    }
}
class ChaoticProxy  {
    private Object object;
    public ChaoticProxy(Object o){
        this.object = o;
    }
    public Object getObject(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader()
                                      , object.getClass().getInterfaces()
                                      , new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("很乱的逻辑执行前~~~");
                long start = System.currentTimeMillis();
                Object invoke = method.invoke(object, args);
                long end = System.currentTimeMillis();
                double sj = (end-start)/1000;
                System.out.println("这团乱糟糟的逻辑执行完了。。。耗时："+sj);
                return invoke;
            }
        });
    }

}
class Test1{
    public static void main(String[] args) {
        ChaoticProxy chaoticProxy = new ChaoticProxy(new Chaotic());
        Kernel object = (Kernel)chaoticProxy.getObject();
        object.shopping();
    }
}