【spring的AOP】

动态代理

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

如果我们现在想在不修改UserService类的源码前提下，给test()增加额外逻辑，那么就可以使用动态
代理机制来创建UserService对象了，比如：
UserService target = new UserService();
// 通过cglib技术
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserService.class);
// 定义额外逻辑，也就是代理逻辑
enhancer.setCallbacks(new Callback[]{new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy
methodProxy) throws Throwable {
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}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(“before…”);
Object result = method.invoke(target, args);
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.zhouyu.service.UserService is not an interface
表示一定要是个接口。
由于这个限制，所以产生的代理对象的类型是UserInterface，而不是UserService，这是需要注意
的。

ProxyFactory

上面我们介绍了两种动态代理技术，那么在Spring中进行了封装，封装出来的类叫做ProxyFactory，
表示是创建代理对象的一个工厂，使用起来会比上面的更加方便，比如：
UserService target = new UserService();
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.addAdvice(new MethodInterceptor() {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
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的分类

1. Before Advice：方法之前执行
2. After returning advice：方法return后执行
3. After throwing advice：方法抛异常后执行
4. After (finally) advice：方法执行完finally之后执行，这是最后的，比return更后
5. Around advice：这是功能最强大的Advice，可以自定义执行顺序
   看课上给的代码例子将一目了然

Advisor的理解

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

创建代理对象的方式

上面介绍了Spring中所提供了ProxyFactory、Advisor、Advice、PointCut等技术来实现代理对象的
创建，但是我们在使用Spring时，我们并不会直接这么去使用ProxyFactory，比如说，我们希望
ProxyFactory所产生的代理对象能直接就是Bean，能直接从Spring容器中得到UserSerivce的代理对
象，而这些，Spring都是支持的，只不过，作为开发者的我们肯定得告诉Spring，那些类需要被代
理，代理逻辑是什么。

ProxyFactoryBean

通过这种方法来定义一个UserService的Bean，并且是经过了AOP的。但是这种方式只能针对某一个
Bean。它是一个FactoryBean，所以利用的就是FactoryBean技术，间接的将UserService的代理对
象作为了Bean。
ProxyFactoryBean还有额外的功能，比如可以把某个Advise或Advisor定义成为Bean，然后在
ProxyFactoryBean中进行设置

BeanNameAutoProxyCreator

ProxyFactoryBean得自己指定被代理的对象，那么我们可以通过BeanNameAutoProxyCreator来通
过指定某个bean的名字，来对该bean进行代理
@Bean
public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
beanNameAutoProxyCreator.setBeanNames(“userSe*”);
beanNameAutoProxyCreator.setInterceptorNames(“zhouyuAroundAdvise”);
beanNameAutoProxyCreator.setProxyTargetClass(true);
return beanNameAutoProxyCreator;
}
通过BeanNameAutoProxyCreator可以对批量的Bean进行AOP，并且指定了代理逻辑，指定了一个
InterceptorName，也就是一个Advise，前提条件是这个Advise也得是一个Bean，这样Spring才能
找到的，但是BeanNameAutoProxyCreator的缺点很明显，它只能根据beanName来指定想要代理
的Bean。

DefaultAdvisorAutoProxyCreator

通过DefaultAdvisorAutoProxyCreator会直接去找所有Advisor类型的Bean，根据Advisor中的
PointCut和Advice信息，确定要代理的Bean以及代理逻辑。
但是，我们发现，通过这种方式，我们得依靠某一个类来实现定义我们的Advisor，或者Advise，或
者Pointcut，那么这个步骤能不能更加简化一点呢？
对的，通过注解！

对Spring AOP的理解

OOP表示面向对象编程，是一种编程思想，AOP表示面向切面编程，也是一种编程思想，而我们上
面所描述的就是Spring为了让程序员更加方便的做到面向切面编程所提供的技术支持，换句话说，就
是Spring提供了一套机制，可以让我们更加容易的来进行AOP，所以这套机制我们也可以称之为
Spring AOP。
但是值得注意的是，上面所提供的注解的方式来定义Pointcut和Advice，Spring并不是首创，首创是
AspectJ，而且也不仅仅只有Spring提供了一套机制来支持AOP，还有比如 JBoss 4.0、aspectwerkz
等技术都提供了对于AOP的支持。而刚刚说的注解的方式，Spring是依赖了AspectJ的，或者说，
Spring是直接把AspectJ中所定义的那些注解直接拿过来用，自己没有再重复定义了，不过也仅仅只
是把注解的定义赋值过来了，每个注解具体底层是怎么解析的，还是Spring自己做的，所以我们在用
Spring时，如果你想用@Before、@Around等注解，是需要单独引入aspecj相关jar包的，比如：
compile group: ‘org.aspectj’, name: ‘aspectjrt’, version: ‘1.9.5’
compile group: ‘org.aspectj’, name: ‘aspectjweaver’, version: ‘1.9.5’
值得注意的是：AspectJ是在编译时对字节码进行了修改，是直接在UserService类对应的字节码中进
行增强的，也就是可以理解为是在编译时就会去解析@Before这些注解，然后得到代理逻辑，加入到
被代理的类中的字节码中去的，所以如果想用AspectJ技术来生成代理对象 ，是需要用单独的
AspectJ编译器的。我们在项目中很少这么用，我们仅仅只是用了@Before这些注解，而我们在启动
Spring的过程中，Spring会去解析这些注解，然后利用动态代理机制生成代理对象的。

AOP中的概念

AOP中的这些概念不是Spring特有的，不幸的是，AOP中的概念不是特别直观的，但是，
如果Spring重新定义自己的那可能会导致更加混乱

1. Aspect：表示切面，比如被@Aspect注解的类就是切面，可以在切面中去定义Pointcut、
   Advice等等
2. Join point：表示连接点，表示一个程序在执行过程中的一个点，比如一个方法的执行，比如一
   个异常的处理，在Spring AOP中，一个连接点通常表示一个方法的执行。
3. Advice：表示通知，表示在一个特定连接点上所采取的动作。Advice分为不同的类型，后面详
   细讨论，在很多AOP框架中，包括Spring，会用Interceptor拦截器来实现Advice，并且在连接
   点周围维护一个Interceptor链
4. Pointcut：表示切点，用来匹配一个或多个连接点，Advice与切点表达式是关联在一起的，
   Advice将会执行在和切点表达式所匹配的连接点上
5. Introduction：可以使用@DeclareParents来给所匹配的类添加一个接口，并指定一个默认实现
6. Target object：目标对象，被代理对象
7. AOP proxy：表示代理工厂，用来创建代理对象的，在Spring Framework中，要么是JDK动态
   代理，要么是CGLIB代理
8. Weaving：表示织入，表示创建代理对象的动作，这个动作可以发生在编译时期（比如
   Aspejctj），或者运行时，比如Spring AOP

Advice在Spring AOP中对应API
上面说到的Aspject中的注解，其中有五个是用来定义Advice的，表示代理逻辑，以及执行时机：
1@Before
9. @AfterReturning
10. @AfterThrowing
11. @After
12. @Around
我们前面也提到过，Spring自己也提供了类似的执行实际的实现类：
13. 接口MethodBeforeAdvice，继承了接口BeforeAdvice
14. 接口AfterReturningAdvice

3. 接口ThrowsAdvice
4. 接口AfterAdvice
5. 接口MethodInterceptor
   Spring会把五个注解解析为对应的Advice类：
6. @Before：AspectJMethodBeforeAdvice，实际上就是一个MethodBeforeAdvice
7. @AfterReturning：AspectJAfterReturningAdvice，实际上就是一个AfterReturningAdvice
8. @AfterThrowing：AspectJAfterThrowingAdvice，实际上就是一个MethodInterceptor
9. @After：AspectJAfterAdvice，实际上就是一个MethodInterceptor
10. @Around：AspectJAroundAdvice，实际上就是一个MethodInterceptor

ProxyFactory选择cglib或jdk动态代理原理

ProxyFactory在生成代理对象之前需要决定到底是使用JDK动态代理还是CGLIB技术：
// config就是ProxyFactory对象
// optimize为true,或proxyTargetClass为true,或用户没有给ProxyFactory对象添加interface
if (config.isOptimize() || config.isProxyTargetClass() ||
hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
“Either an interface or a target is required for proxy creation.”);
}
// targetClass是接口，直接使用Jdk动态代理
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
// 使用Cglib
return new ObjenesisCglibAopProxy(config);
}
else {
// 使用Jdk动态代理
return new JdkDynamicAopProxy(config);
}
代理对象创建过程
JdkDynamicAopProxy

1. 在构造JdkDynamicAopProxy对象时，会先拿到被代理对象自己所实现的接口，并且额外的增
   加SpringProxy、Advised、DecoratingProxy三个接口，组合成一个Class[]，并赋值给
   proxiedInterfaces属性
2. 并且检查这些接口中是否定义了equals()、hashcode()方法
3. 执行 Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this) ，得到代理对象，
   JdkDynamicAopProxy作为InvocationHandler，代理对象在执行某个方法时，会进入到
   JdkDynamicAopProxy的**invoke()**方法中

ObjenesisCglibAopProxy

1. 创建Enhancer对象
2. 设置Enhancer的superClass为通过ProxyFactory.setTarget()所设置的对象的类
3. 设置Enhancer的interfaces为通过ProxyFactory.addInterface()所添加的接口，以及
   SpringProxy、Advised、DecoratingProxy接口
4. 设置Enhancer的Callbacks为DynamicAdvisedInterceptor
5. 最后创建一个代理对象，代理对象在执行某个方法时，会进入到DynamicAdvisedInterceptor的
   intercept()方法中