AOP的常用注解
AOP的源码分析
事务的注解与源码分析

`AOP`的常用注解

Aspect-Oriented Programming 面向切面编程，主要包含切面Aspect，切入点Pointcut以及通知(切入时机)Advice,通知包含方法执行之前Before、方法执行之后After、方法环绕Around，通知方法参数有JoinPoint,Around方法参数有ProceedingJoinPoint

JoinPoint只能放在方法的第一个参数，主要方法如下

getArgs() 返回方法的参数

getThis() 返回代理对象

getTarget() 返回目标对象

getSignature() 返回通知方法的签名

toString() 返回通知方法有用描述

ProceedingJoinPoint只能放在方法的第一个参数，主要方法如下

proceed(Object[] args) 执行目标方法

`@EnableAspectJAutoProxy`

启用切面，相当于xml中aop:aspectj-autoproxy

<aop:aspectj-autoproxy />

proxyTargetClass 对应xml中属性proxy-target-class，是否启用CGLIB
exposeProxy 对应xml中属性expose-proxy ，是否暴露代理，设置为true的时候，可以通过AopContext.currentProxy() 获取代理实例（通过ThreadLocal进行实现的）

`@Aspect`

切面，横切多个类的关系的模块化

@Aspect
@Component
public class LogAspect {
}

相当于xml中

<aop:config>
    <aop:aspect id="logAspect" ref="logAspectBean">
</aop:config>
    
<bean id="logAspectBean" class="top.felixfly.aop.apesct.LogAspect"></bean>

`@Pointcut`

切点，执行方法的切点

@Pointcut("execution(* top.felixfly.aop.service.*Service.*(..))")
public void servicePoint() {
}

相当于xml中

<aop:config>
     <aop:pointcut id="servicePoint"
            expression="execution(* top.felixfly.aop.service.*Service.*(..))"/>
</aop:config>

切入点表达式

execution 切入表达式，这个Spring中最常用的

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
- execution(public * *(..)) 所有包下的public方法
- execution(* set*(..)) 所有已set开头的方法`*
- execution(* com.xyz.service.AccountService.*(..))AccountService下的所有方法
- execution(* com.xyz.service.*.*(..)) service包下的所有类的方法
- execution(* com.xyz.service..*.*(..)) service包以及子包的所有类的方法
within
- within(com.xyz.service.*) service包下的所有类的方法
- within(com.xyz.service.*) service包以及子包所有类的方法
this 指定代理实现的接口
this(com.xyz.service.AccountService) 指定AccountService接口下的所有方法
target 执行目标对象实现的接口
target(com.xyz.service.AccountService) 指定AccountService接口下的所有方法
args 执行目标方法的参数
args(java.io.Serializable) 有Serializable参数的所有方法
@target
@target(org.springframework.transaction.annotation.Transactional) 目标对象有@Transactional注解的类所有方法
@within
@within(org.springframework.transaction.annotation.Transactional) 目标对象有@Transactional注解申明的类所有方法
@annotation
@annotation(org.springframework.transaction.annotation.Transactional) 有@Transactional注解的所有方法
@args
@args(com.xyz.security.Classified) 有@Classified注解的单参数方法
bean
- bean(*ServiceImpl) 所有以ServiceImpl结尾Bean的所有方法

`@Before`

在切点的方法之前执行方法

@Before("servicePoint()")
public void before(JoinPoint joinPoint) {
    System.out.println("before。。。。。");
}

相当于xml中

<aop:config>
    <aop:aspect id="logAspect" ref="logAspect">
      <aop:pointcut id="servicePoint"
            expression="execution(* top.felixfly.aop.service.*Service.*(..))"/>
        <aop:before pointcut-ref="servicePoint" method="before"/>
    </aop:aspect>
</aop:config>

`@AfterReturning`

在切点的方法执行返回执行

@AfterReturning(value="servicePoint()",returing="object")
public void afterReturning(JoinPoint joinPoint,Object object) {
    System.out.println("afterReturning。。。。。");
}

相当于xml中

<aop:config>
    <aop:aspect id="logAspect" ref="logAspect">
      <aop:pointcut id="servicePoint"
            expression="execution(* top.felixfly.aop.service.*Service.*(..))"/>
        <aop:after-returning pointcut-ref="servicePoint" method="afterReturning" returning="object" />
    </aop:aspect>
</aop:config>

`@AfterThrowing`

在切点的方法执行抛出异常执行

@AfterThrowing(value = "servicePoint()", throwing = "ex")
public void afterThrowing(JoinPoint joinPoint, Exception ex) {
    System.out.println("afterThrowing。。。。。" + ex);
}

相对于xml中

<aop:config>
    <aop:aspect id="logAspect" ref="logAspect">
      <aop:pointcut id="servicePoint"
            expression="execution(* top.felixfly.aop.service.*Service.*(..))"/>
        <aop:after-throwing pointcut-ref="servicePoint" method="afterThrowing" throwing="ex" />
    </aop:aspect>
</aop:config>

`@After`

在切点方法执行之后执行，也就是在@AfterReturning或者@AfterThrowing之前执行

@After("servicePoint()")
public void after(JoinPoint joinPoint) {
    System.out.println("after。。。。。");
}

相当于xml中

<aop:config>
    <aop:aspect id="logAspect" ref="logAspect">
      <aop:pointcut id="servicePoint"
            expression="execution(* top.felixfly.aop.service.*Service.*(..))"/>
        <aop:after pointcut-ref="servicePoint" method="after" />
    </aop:aspect>
</aop:config>

`@Around`

在切点方法执行前后执行

@Around(value = "servicePoint()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    // 执行目标方法之前,在@Before方法之前执行
    System.out.println("around before。。。。。" );
    // 执行目标方法
    Object retVal = joinPoint.proceed(joinPoint.getArgs());
    // 执行目标方法之后,@After之前执行
    System.out.println("around after。。。。。" );
    return retVal;
}

相当于xml中

<aop:config>
    <aop:aspect id="logAspect" ref="logAspect">
      <aop:pointcut id="servicePoint"
            expression="execution(* top.felixfly.aop.service.*Service.*(..))"/>
        <aop:around pointcut-ref="servicePoint" method="around" />
    </aop:aspect>
</aop:config>

`AOP`的执行顺序

正常执行流程：@Around -> @Before -> @After -> @AfterReturning

异常执行流程：@Around -> @Before -> @After -> @AfterThrowing

切面的主要接口

`PointCut` 切入点

ClassFilter 类的过滤器

MethodMatcher 方法的匹配器

`Advice` 通知

BeforeAdvice 前置通知
AfterAdvice 后置通知
AfterReturningAdvice 执行返回通知
ThrowsAdvice 异常通知

`MethodInterceptor` 方法的拦截器（继承Advice）

MethodBeforeAdviceInterceptor 方法前置拦截器
AspectJAroundAdvice ApectJ环绕拦截器
AspectJAfterAdvice ApectJ后置拦截器
AfterReturningAdviceInterceptor 后置返回拦截器
AspectJAfterThrowingAdvice 后置异常拦截器

`Advisor` 通知器

Advice 通知

`PointcutAdvisor` 切入点通知器（继承Advisor）

Pointcut 切入点

动态代理的主要接口

`AopProxy` `Aop`动态代理

JdkDynamicAopProxy Jdk动态代理
CglibAopProxy Cglib动态代理
- ObjenesisCglibAopProxy 扩展的 Cglib动态代理

这个是通过org.springframework.aop.framework.DefaultAopProxyFactory进行动态匹配生成，构建执行链org.springframework.aop.framework.DefaultAdvisorChainFactory#getInterceptorsAndDynamicInterceptionAdvice关联了Advisor

`AOP`的源码分析

`@EnableAspectJAutoProxy`

注解通过@Import(AspectJAutoProxyRegistrar.class)注册

实现ImportBeanDefinitionRegistrar
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry)
- 注册org.springframework.aop.config.internalAutoProxyCreator ——AnnotationAwareAspectJAutoProxyCreator,最高优先级

`AnnotationAwareAspectJAutoProxyCreator`

实现主要接口

BeanFactoryAware BeanFactory回调接口
InstantiationAwareBeanPostProcessor 实例化执行的接口
BeanPostProcessor Bean后置处理器

`BeanFactoryAware` `BeanFactory`回调接口

AbstractAdvisorAutoProxyCreator#setBeanFactory
AnnotationAwareAspectJAutoProxyCreator#initBeanFactory
- ReflectiveAspectJAdvisorFactory
  
  处理Advice通知注解@Around、@Before、@After、@AfterReturning、@AfterThrowing
  
  构建了一个PointcutAdvisor(InstantiationModelAwarePointcutAdvisorImpl)
  - AspectJExpressionPointcut PointCut切点表达式
  - Advice 通知
- BeanFactoryAspectJAdvisorsBuilderAdapter

`InstantiationAwareBeanPostProcessor` 实例化执行的接口

`InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation` 实例化执行的方法

AbstractAutoProxyCreator#postProcessBeforeInstantiation

判断是否是通知Bean
- Advice、Pointcut、Advisor、AopInfrastructureBean 这几个类的子类
- @Aspect注解的类
- bean的名词是否以bean的Class名称开头并且以.ORIGINAL结束
是否需要跳过
- 获取Advisor通知器列表(获取到了InstantiationModelAwarePointcutAdvisorImpl)
是否自定义TargetSourceCreator，若是有直接执行createProxy

`BeanPostProcessor` Bean后置处理器

`BeanPostProcessor#postProcessAfterInitialization` 初始化执行的方法

AbstractAutoProxyCreator#postProcessAfterInitialization

wrapIfNecessary
- 判断是否是通知Bean
- 是否需要跳过
- 判断是否有Advice通知的Bean创建代理
  - createProxy
    - DefaultAopProxyFactory#createAopProxy
      - config.isProxyTargetClass()
        
        接口或者是Proxy的子类，使用JdkDynamicAopProxy
        
        其他使用ObjenesisCglibAopProxy
      - 创建JdkDynamicAopProxy

通过代码实现切面

实现一个`PointAdvisor`

/**
 * 日志通知器
 *
 * @author FelixFly <chenglinxu@yeah.net>
 * @date 2020/5/18
 */
public class TraceBeanFactoryPointcutAdvisor extends AbstractBeanFactoryPointcutAdvisor {


    @Override
    public Pointcut getPointcut() {
        // 所有的方法
        return Pointcut.TRUE;
    }
}

实现一个`MethodInterceptor`

/**
 * 日志拦截器
 *
 * @author FelixFly <chenglinxu@yeah.net>
 * @date 2020/5/18
 */
public class TraceInterceptor extends SimpleTraceInterceptor {


    private final AtomicInteger count = new AtomicInteger();

    @Override
    protected boolean isLogEnabled(Log logger) {
        // 调整日志级别
        return logger.isInfoEnabled();
    }


    @Override
    protected void writeToLog(Log logger, String message, Throwable ex) {
        // 打印日志方式
        if (Objects.nonNull(ex)) {
            logger.error(message, ex);
            return;
        }
        logger.info(message);
    }


    @Override
    protected Object invokeUnderTrace(MethodInvocation invocation, Log logger) throws Throwable {
        // 这地方有个并发的问题
        // 可以构建个上下文用ThreadLocal处理，ThreadLocal什么时候进行移除？
        int num = count.incrementAndGet();
        long start = System.currentTimeMillis();
        try {
            Object proceed = invocation.proceed();
            // 执行序号|执行方法名|执行时间|入参|出参|错误信息
            writeToLog(logger, getDescription(invocation, num, proceed, System.currentTimeMillis() - start));
            return proceed;

        } catch (Throwable ex) {
            writeToLog(logger, getDescription(invocation, num, null, System.currentTimeMillis() - start), ex);
            throw ex;
        }
    }

    private String getDescription(MethodInvocation invocation, int num, Object returnObject, long time) {
        Method method = invocation.getMethod();
        Object[] arguments = invocation.getArguments();
        return String.format("%d|%s#%s|%d|%s|%s", num,
                method.getDeclaringClass().getSimpleName(), method.getName(), time, JSON.toJSONString(arguments),
                Objects.isNull(returnObject) ? "" : JSON.toJSONString(returnObject));
    }
}

配置Bean信息

/**
 * Aop切面配置
 *
 * @author FelixFly <chenglinxu@yeah.net>
 * @date 2019/11/28
 */
@Configuration
@EnableAspectJAutoProxy // 一定要开启，不开启无效，自定义的实现是通过EnableAspectJAutoProxy来实现的
public class AopConfiguration {

    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TraceBeanFactoryPointcutAdvisor traceBeanFactoryPointcutAdvisor(){
        TraceBeanFactoryPointcutAdvisor pointcutAdvisor = new TraceBeanFactoryPointcutAdvisor();
        pointcutAdvisor.setAdvice(traceInterceptor());
        return pointcutAdvisor;
    }

    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TraceInterceptor traceInterceptor(){
        return new TraceInterceptor();
    }
}

若是不希望拦截所有的方法，自行实现`Pointcut`

/**
 * 日志切面
 *
 * @author FelixFly <chenglinxu@yeah.net>
 * @date 2020/5/18
 */
public class TracePointcut implements Pointcut, Serializable {

    public static final TracePointcut INSTANCE = new TracePointcut();

    /**
     * Enforce Singleton pattern.
     */
    private TracePointcut() {
    }

    @Override
    public ClassFilter getClassFilter() {
        // service 注解打点,true表示派生的注解
        return new AnnotationClassFilter(Service.class, true);
    }

    @Override
    public MethodMatcher getMethodMatcher() {
        return MethodMatcher.TRUE;
    }

    /**
     * Required to support serialization. Replaces with canonical
     * instance on deserialization, protecting Singleton pattern.
     * Alternative to overriding {@code equals()}.
     */
    private Object readResolve() {
        return INSTANCE;
    }

    @Override
    public String toString() {
        return "Pointcut.TRUE";
    }
}

事务的注解与源码分析

事务的解决问题

脏读

一个线程在处理数据，事务还未提交；另一个线程可以读到此数据

重复读

一个线程读数据，另一个线程改数据，导致同一个线程获取的数据不一致。

幻读

一个线程读数据，另一个线程添加数据，导入同一个线程获取的数据条目不一致，多出来的条目称为幻行。

事务的隔离级别Connection

READ_UNCOMMITTED 读未提交的

READ_COMMITTED 读已提交

REPEATABLE_READ 重复读

SERIALIZABLE 串行

事务的传播机制TransactionDefinition

REQUIRED 必须以事务执行，若有事务，以当前事务执行，没有事务重新启动新事务执行

SUPPORTS 支持事务执行，若有事务，用当前事务执行，没有事务不进行事务操作

MANDATORY 支持事务执行，若有事务，用当前事务执行，没有事务抛错

REQUIRES_NEW 以新事务执行

NOT_SUPPORTED 支持无事务执行

NEVER 无事务执行，有事务抛错

NESTED 若是有事务存在，嵌套事务执行

常用注解

`@EnableTransactionManagement`

开启事务的注解

`@Transactional`

启用事务的注解

源码分析

`@EnableTransactionManagement`

通过@Import(TransactionManagementConfigurationSelector.class)注册

PROXY JDK代理通知
- AutoProxyRegistrar
  - AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry)
    
    注册org.springframework.aop.config.internalAutoProxyCreator ——InfrastructureAdvisorAutoProxyCreator
    
    优先级判断
  - AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry)
    
    org.springframework.aop.config.internalAutoProxyCreator设置属性proxyTargetClass
- ProxyTransactionManagementConfiguration
  
  注册如下的Bean
  - transactionAdvisor——BeanFactoryTransactionAttributeSourceAdvisor 事务通知者
    - TransactionAttributeSource
    - Advice——TransactionInterceptor
  - transactionAttributeSource——AnnotationTransactionAttributeSource
  - transactionInterceptor——TransactionInterceptor 事务方法拦截器
    - TransactionAttributeSource
    - TransactionManager
ASPECTJ AspectJ代理通知
- AspectJJtaTransactionManagementConfiguration
- AspectJTransactionManagementConfiguration

@EnableAspectJAutoProxy​

@Aspect​

@Pointcut​

切入点表达式​

@Before​

@AfterReturning​

@AfterThrowing​

@After​

@Around​

AOP的执行顺序

切面的主要接口

PointCut 切入点​

Advice 通知​

MethodInterceptor 方法的拦截器（继承Advice）​

Advisor 通知器​

PointcutAdvisor 切入点通知器（继承Advisor）​

动态代理的主要接口

AopProxy Aop动态代理​

AOP的源码分析

@EnableAspectJAutoProxy​

AnnotationAwareAspectJAutoProxyCreator​

BeanFactoryAware BeanFactory回调接口​

InstantiationAwareBeanPostProcessor 实例化执行的接口​

InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation 实例化执行的方法​

BeanPostProcessor Bean后置处理器​

BeanPostProcessor#postProcessAfterInitialization 初始化执行的方法​

通过代码实现切面

实现一个PointAdvisor​

实现一个MethodInterceptor​

配置Bean信息​

若是不希望拦截所有的方法，自行实现Pointcut​

事务的注解与源码分析

常用注解​

@EnableTransactionManagement​

@Transactional​

源码分析​

@EnableTransactionManagement​

`@EnableAspectJAutoProxy`

`@Aspect`

`@Pointcut`

切入点表达式

`@Before`

`@AfterReturning`

`@AfterThrowing`

`@After`

`@Around`

`AOP`的执行顺序

`PointCut` 切入点

`Advice` 通知

`MethodInterceptor` 方法的拦截器（继承Advice）

`Advisor` 通知器

`PointcutAdvisor` 切入点通知器（继承Advisor）

`AopProxy` `Aop`动态代理

`AOP`的源码分析

`@EnableAspectJAutoProxy`

`AnnotationAwareAspectJAutoProxyCreator`

`BeanFactoryAware` `BeanFactory`回调接口

`InstantiationAwareBeanPostProcessor` 实例化执行的接口

`InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation` 实例化执行的方法

`BeanPostProcessor` Bean后置处理器

`BeanPostProcessor#postProcessAfterInitialization` 初始化执行的方法

实现一个`PointAdvisor`

实现一个`MethodInterceptor`

配置Bean信息

若是不希望拦截所有的方法，自行实现`Pointcut`

常用注解

`@EnableTransactionManagement`

`@Transactional`

源码分析

`@EnableTransactionManagement`