动态代理

代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。

比如现在要对一个UserService进行代理，并增强其test方法。

public class UserService {
    public void test() {
        System.out.println("test...");
    }
}

如果现在想在不修改UserService类的源码前提下，给test()增加额外逻辑，那么就可以使用动态代理机制来创建UserService对象了，比如：

        UserService target = new UserService();
        // 通过cglib技术
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        // 定义额外逻辑，也就是代理逻辑
        enhancer.setCallbacks(new Callback[]{(MethodInterceptor) (o, method, objects, methodProxy) -> {
            System.out.println("before...");
            Object result = methodProxy.invoke(target, objects);
            System.out.println("after...");
            return result;
        }});
        // 动态代理所创建出来的UserService对象
        UserService userService = (UserService) enhancer.create();
        // 执行这个userService的test方法时，就会额外会执行一些其他逻辑
        userService.test();

得到的都是UserService对象，但是执行test()方法时的效果却不一样了，这就是代理所带来的效果

上面是通过cglib来实现的代理对象的创建，是基于父子类的，被代理类（UserService）是父类，代理类是子类，代理对象就是代理类的实例对象，代理类是由cglib创建的，对于程序员来说不用关心。除开cglib技术，jdk本身也提供了一种创建代理对象的动态代理机制，但是它只能代理接口，也就是UserService得先有一个接口才能利用jdk动态代理机制来生成一个代理对象，比如：

    public interface UserInterface {
        public void test();
    }
    public class UserService implements UserInterface {
        public void test() {
            System.out.println("test...");
        }
    }

利用JDK动态代理来生成一个代理对象：

        UserService target = new UserService();
        // UserInterface接口的代理对象
        Object proxy = Proxy.newProxyInstance(UserService.class.getClassLoader(), new Class[]
                {UserInterface.class}, (proxy1, method, args1) -> {
                    System.out.println("before...");
                    Object result = method.invoke(target, args1);
                    System.out.println("after...");
                    return result;
                });
        UserInterface userService = (UserInterface) proxy;
        userService.test();

如果把new Class[]{UserInterface.class}，替换成new Class[]{UserService.class}，允许代码会直接报错：

Exception in thread "main" java.lang.IllegalArgumentException:
com.zxzg.service.UserService is not an interface

表示一定要是个接口。

由于这个限制，所以产生的代理对象的类型是UserInterface，而不是UserService，这是需要注意的。

ProxyFactory

上面介绍了两种动态代理技术，那么在Spring中进行了封装，封装出来的类叫做ProxyFactory，表示是创建代理对象的一个工厂，使用起来会比上面的更加方便，比如：

        UserService target = new UserService();
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAdvice((MethodInterceptor) invocation -> {
            System.out.println("before...");
            Object result = invocation.proceed();
            System.out.println("after...");
            return result;
        });
        UserInterface userService = (UserInterface) proxyFactory.getProxy();
        userService.test();

通过ProxyFactory，可以不再关系到底是用cglib还是jdk动态代理了，ProxyFactory会去判断，如果UserService实现了接口，那么ProxyFactory底层就会用jdk动态代理，如果没有实现接口，就会用cglib技术，上面的代码，就是由于UserService实现了UserInterface接口，所以最后产生的代理对象是UserInterface类型。

Advice的分类

Before Advice：方法之前执行
After returning advice：方法return后执行
After throwing advice：方法抛异常后执行
After (finally) advice：方法执行完finally之后执行，这是最后的，比return更后
Around advice：这是功能最强大的Advice，可以自定义执行顺序

Advisor的理解

跟Advice类似的还有一个Advisor的概念，一个Advisor是有一个Pointcut和一个Advice组成的，通过Pointcut可以指定要需要被代理的逻辑，比如一个UserService类中有两个方法，按上面的例子，这两个方法都会被代理，被增强，那么我们现在可以通过Advisor，来控制到具体代理哪一个方法，比如：

UserService target = new UserService();
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAdvisor(new PointcutAdvisor() {
            @Override
            public Pointcut getPointcut() {
                return new StaticMethodMatcherPointcut() {
                    @Override
                    public boolean matches(Method method, Class<?> targetClass) {
                        return method.getName().equals("testAbc");
                    }
                };
            }
            @Override
            public Advice getAdvice() {
                return (MethodInterceptor) invocation -> {
                    System.out.println("before...");
                    Object result = invocation.proceed();
                    System.out.println("after...");
                    return result;
                };
            }
            @Override
            public boolean isPerInstance() {
                return false;
            }
        });
        UserInterface userService = (UserInterface) proxyFactory.getProxy();
        userService.test();
    }

上面代码表示，产生的代理对象，只有在执行testAbc这个方法时才会被增强，会执行额外的逻辑，而在执行其他方法时是不会增强的。

Spring AOP底层代理实现

动态代理

ProxyFactory

Advice的分类

Advisor的理解