代理类图

    在代理类图中可以看到代理类的作用，他就是相当于一个中介，用户过来的请求，Proxy类拦截一下，然后再去调用RealSubject类，具体拦截一下能做什么就在于代理类想去做什么。静态代理就是我们想要一个代理就去写一个代理类，提前编写好类，当我们需要很多代理的时候就得去编写很多代理类，这样代码就会显得特别臃肿。所以，这个时候动态代理就出来了，他可以在运行时生成代理类，然后加载到JVM中生成实例。
    与静态代理不同的是，动态代理在Proxy和RealSubject之间引入了InvocationHandler，如图所示：

动态代理类图

    从静态代理和动态代理类图可以看出，代理Proxy和RealSubject必须要实现相同的功能，也即含有相同的非final的public方法，这点是代理实现的关键。相同的功能在面向对象的编程中有两种方式：

• 通过实现相同的接口来实现，也即是Proxy和RealSubject实现一个相同的接口
• 通过继承来实现，这用Proxy就自动拥有RealSubject类的public方法了

    所以基于上面的两种方式，也就有了2种动态代理的实现方式，基于接口和基于类两种实现方式。这也是为什么动态代理不是被称为动态实现，就是因为除了通过接口实现还可以通过直接继承类来实现。

    动态代理JDK实现：JDK就是基于接口来实现的动态代理，JDK实现动态代理的关键就是Proxy和InvocationHandler，直接通过Proxy.newInstance就可以获得一个动态代理类。

public class DynamicProxy {

    public static void main(String[] args) {
        RealUser realUser = new RealUser();
        realUser.say();

        ClassLoader classLoader = realUser.getClass().getClassLoader();
        Class[] interfaces = realUser.getClass().getInterfaces();
        UserInvocationHandler userInvocationHandler = new UserInvocationHandler();
        userInvocationHandler.setUser(realUser);
        User proxyUser = (User)Proxy.newProxyInstance(classLoader, interfaces, userInvocationHandler);
        proxyUser.say();
    }
}

• 获取类加载器
• 获取RealUser的接口
• 实现触发管理器InvocationHandler，这里还要设置具体的需要代理的RealSubject类
• 生成动态代理类

public interface User {

    void say();
}

    RealUser和Proxy需要实现共同的功能，也就是User接口

public class UserInvocationHandler implements InvocationHandler {

    private User user;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("UserInvocationHandler invoke method " + method.getName() + " before");
        method.invoke(user,null);
        System.out.println("UserInvocationHandler invoke method " + method.getName() + " after");
        return null;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

    实现统一的触发管理器，他是Proxy和RealSubject之间的角色，Proxy将请求统一交给InvocationHandler。

public class RealUser implements User {

    @Override
    public void say() {
        System.out.println("This is realUser say hello");
    }
}

    RealUser实现类

This is realUser say hello
UserInvocationHandler invoke method say before
This is realUser say hello
UserInvocationHandler invoke method say after

Process finished with exit code 0

    运行结果

    cglib实现动态代理：cglib就是基于继承的方式进行实现的动态代理，他不需要某个类去实现接口，直接基于具体类去生成动态代理类。

public class Animal {

    public void say() {
        System.out.println("This is animal");
    }
}

public class UserMethodInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("UserMethodInterceptor invoke method " + method.getName() + " before");
        methodProxy.invokeSuper(o, objects);
        System.out.println("UserMethodInterceptor invoke method " + method.getName() + " after");
        return null;
    }
}


public class DynamicProxy {

    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.say();

        UserMethodInterceptor userMethodInterceptor = new UserMethodInterceptor();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Animal.class);
        enhancer.setCallback(userMethodInterceptor);
        Animal proxyAnimal = (Animal) enhancer.create();
        proxyAnimal.say();
    }
}

    Proxy和Enhancer的实现不同，决定了一个需要通过实现相同接口来生成动态代理类，一个直接继承一个类来生成动态代理类。动态代理其实就是在运行时期生成符合java虚拟机规范的字节码，通过JVM加载生成的class字节码文件，生成对应实例来起作用。

    思考：为什么要引入InvocationHandler和MethodInterceptor？
动态代理类相较于静态代理类，它的优势并不是在于省去了编写代理类那一点工作量，而是实现了可以在原始类和接口还未知的时候，就确定了代理类的行为，当代理类与原始类脱离直接联系后，就可以很灵活地重用于不同的应用场景之中。这也是由于InvocationHandler和MethodInterceptor的出现才带来的好处，所以它的角色是不可取消的。