Spring5.0源碼深度解析之SpringBean的Aop的使用

SpringAOP

什麼是Aop編程

Aop面向切面編程，在方法以前和以後實現處理 應用場景在於：日誌打印、事務實現、安全等。

由於AOP能夠解決咱們程序上的代碼冗餘問題

Spring的AOP

前置通知

後置通知

環繞通知

運行通知

異常通知

Aop編程底層的原理

動態代理技術

• 基於Jdk實現InvocationHandler 底層使用反射技術
• 基於CGLIB實現 字節碼技術

基於註解方式啓動Aop

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.13</version>
    </dependency>
</dependencies>

日誌AOP

@Aspect//定義切面類
@Component//注入spring容器
@EnableAspectJAutoProxy//開啓AOP
public class LogAop {
    //定義切入點,表示開始攔截的入口
    @Pointcut("execution (* com.xuyu.service..*.*(..))")
    public void logAop(){

    }
    @Before("logAop()")
    public void doBefor(){
        System.out.println("前置通知....在調用方法以前攔截");
    }
    @After("logAop()")
    public void doAfter(){
        System.out.println("後置通知....在調用方法以後攔截");
    }
}

Config

@Configuration
@ComponentScan(basePackages = {"com.xuyu.service","com.xuyu.aop"})
public class MyConfig {
}

service

@Component
public class OrderService {

    public void addOrder(){
        System.out.println("執行目標方法....");
    }
}

啓動類

public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
        OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
        orderService.addOrder();
    }
}

執行結果

前置通知....在調用方法以前攔截
執行目標方法....
後置通知....在調用方法以後攔截

咱們開始分析下源碼

因此咱們能夠直接使用@Import註解把AspectJAutoProxyRegistrar這個類注入IOC容器中

@Import(AspectJAutoProxyRegistrar.class)

等價於這個註解

@EnableAspectJAutoProxy//開啓AOP

完整的五個通知

@Aspect//定義切面類
@Component//注入spring容器
@EnableAspectJAutoProxy//開啓AOP
public class LogAop {
    //定義切入點,表示開始攔截的入口
    @Pointcut("execution (* com.xuyu.service..*.*(..))")
    public void logAop(){

    }
    @Before("logAop()")
    public void doBefore(){
        System.out.println("前置通知....在調用方法以前攔截");
    }
    @After("logAop()")
    public void doAfter(){
        System.out.println("後置通知....在調用方法以後攔截");
    }
    @AfterReturning("logAop()")
    public void  around(JoinPoint joinpoint) throws Throwable {
        String name = joinpoint.getSignature().getName();
        System.out.println("返回通知...."+name);
    }
    @AfterThrowing("logAop()")
    public void afterThrowing(JoinPoint joinPoint) {
        System.out.println("異常通知....");
    }
    @Around("logAop()")
    public void doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("環繞通知，在目標方法以前處理....");
        joinPoint.proceed();//執行目標方法
        System.out.println("環繞通知，在目標方法以後處理....");
    }
}

打印結果

環繞通知，在目標方法以前處理....
前置通知....在調用方法以前攔截
目標方法執行....
環繞通知，在目標方法以後處理....
後置通知....在調用方法以後攔截
返回通知....addOrder

springBoot手動事務實現方式

手動begin commit rollback

@Component
public class TransactionalUtils {
    //TransactionAspectSupport currentTransactionStatus().setRollbackOnly();
    /**
     * 獲取當前事務管理器
     */
    @Autowired
    private DataSourceTransactionManager dataSourceTransactionManager;

    public TransactionStatus begin() {
        TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
        System.out.println("獲取當前的事務>>>>>");
        return transaction;
    }
    /**
     * 提交事務
     */
    public void commit(TransactionStatus transactionStatus) {
        System.out.println("提交當前的事務>>>>>");
        dataSourceTransactionManager.commit(transactionStatus);
    }
    public void rollback(TransactionStatus transactionStatus) {
        System.out.println("回滾當前的事務>>>>>");
        dataSourceTransactionManager.rollback(transactionStatus);
    }
}

@Service
public class OrderService {
    @Autowired
    private OrderInfoMapper orderInfoMapper;
    @Autowired
    private TransactionalUtils transactionalUtils;


        public int addOrderInfo(int j) {
        TransactionStatus begin = transactionalUtils.begin();
        try {
            int i = orderInfoMapper.addOrderInfo();
            int result = 1 / j;
            transactionalUtils.commit(begin);
        } catch (Exception e) {
            e.printStackTrace();
            transactionalUtils.rollback(begin);
        }
        return 1;
    }

手動begin commit rollback代碼會冗餘，因此咱們使用AOP重構下手動事務

使用SpringAop實現重構實現聲明式事務

@Aspect
@Component
@Scope("prototype")//單例會有問題，這裏設置爲多例
public class TransactionalAop {
    //Aspect 定義切點類
    @Autowired
    private TransactionalUtils transactionalUtils;
    /**
     * @Pointcut 定義切入點
     */
    @Pointcut("execution (* com.mayikt.service..*.*(..))")
    public void transactionalAop() {
    }
    @Around("transactionalAop()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 獲取方法名稱
        String methodName = joinPoint.getSignature().getName();
        // 獲取目標對象
        Class<?> classTarget = joinPoint.getTarget().getClass();
        // 獲取目標對象類型
        Class<?>[] par = ((MethodSignature) joinPoint.getSignature()).getParameterTypes();
        // 獲取目標對象方法
        Method objMethod = classTarget.getMethod(methodName, par);
        // 判斷該目標方法上是否有加上自定義事務註解
        ExtTransactional extTransactional = objMethod.getDeclaredAnnotation(ExtTransactional.class);
        if (extTransactional == null) {
            return joinPoint.proceed();// 執行目標方法
        }
        TransactionStatus begin = transactionalUtils.begin();
        try {
            System.out.println(">>>>環繞通知以前執行...>>>>>>");
            Object proceed = joinPoint.proceed();// 執行目標方案
            System.out.println(">>>>環繞通知以後執行...>>>>>>");
            transactionalUtils.commit(begin);
            return proceed;
        } catch (Exception e) {
            // 目標方法拋出異常的狀況下 回滾當前事務
            transactionalUtils.rollback(begin);
            return 0;
        }
    }
}

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface  ExtTransactional {
}

@ExtTransactional
public int addOrderInfo(int j) {
    int i = orderInfoMapper.addOrderInfo();
    return i;
}

注意的問題 若是在service 層 拋出異常的狀況下 最好使用 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

本文參考：

螞蟻課堂：http://www.mayikt.com/