springAOP的三種實現方式

springAOP的實現方式

三種
純XML方式，XML+註解，純註解方式。

Spring 實現AOP思想使⽤的是動態代理技術
默認狀況下， Spring會根據被代理對象是否實現接⼝來選擇使⽤JDK仍是CGLIB。當被代理對象沒有實現

任何接⼝時， Spring會選擇CGLIB。當被代理對象實現了接⼝， Spring會選擇JDK官⽅的代理技術，不過

咱們能夠經過配置的⽅式，讓Spring強制使⽤CGLIB。

接下來咱們開始實現aop，
需求是：橫切邏輯代碼是打印⽇志，但願把打印⽇志的邏輯織⼊到⽬標⽅法的特定位置(service層transfer⽅法)

純XML方式

引入aop相關的jar包

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-aop</artifactId>
   <version>5.1.12.RELEASE</version>
</dependency>

<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.9.4</version>
</dependency>

TransferServiceImpl.java文件：

package com.lagou.edu.service.impl;

import com.lagou.edu.dao.AccountDao;
import com.lagou.edu.pojo.Account;
import com.lagou.edu.service.TransferService;
import com.lagou.edu.utils.ConnectionUtils;
import com.lagou.edu.utils.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.ImportResource;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;


/**
 * @author 應癲
 */
@Service("transferService")
public class TransferServiceImpl implements TransferService {


    // 最佳狀態
    // @Autowired 按照類型注入 ,若是按照類型沒法惟一鎖定對象，能夠結合@Qualifier指定具體的id
    @Autowired
    @Qualifier("accountDao")
    private AccountDao accountDao;




    @Override
    public void transfer(String fromCardNo, String toCardNo, int money) throws Exception {

        /*try{
            // 開啓事務(關閉事務的自動提交)
            TransactionManager.getInstance().beginTransaction();*/
            System.out.println("執行轉帳業務邏輯");
            Account from = accountDao.queryAccountByCardNo(fromCardNo);
            Account to = accountDao.queryAccountByCardNo(toCardNo);

            from.setMoney(from.getMoney()-money);
            to.setMoney(to.getMoney()+money);

            accountDao.updateAccountByCardNo(to);
            //int c = 1/0;
            accountDao.updateAccountByCardNo(from);



    }
}

打印日誌Util：

package com.lagou.edu.utils;

/**
 * @author 應癲
 */

public class LogUtils {

    /**
     * 業務邏輯開始以前執行
     */
    
    public void beforeMethod(JoinPoint joinPoint) {
          Object[] args = joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            System.out.println(arg);
        }
        System.out.println("業務邏輯開始執行以前執行.......");
    }


    /**
     * 業務邏輯結束時執行（不管異常與否）
     */

    public void afterMethod() {
        System.out.println("業務邏輯結束時執行，不管異常與否都執行.......");
    }

    /**
     * 異常時時執行
     */
    public void exceptionMethod() {
        System.out.println("異常時執行.......");
    }

    /**
     * 業務邏輯正常時執行
     */

    public void successMethod(Object retVal) {
        System.out.println("業務邏輯正常時執行.......");
    }

}

public Object arroundMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("環繞通知中的beforemethod....");

        Object result = null;
        try{
            // 控制原有業務邏輯是否執行
            // result = proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
        }catch(Exception e) {
            System.out.println("環繞通知中的exceptionmethod....");
        }finally {
            System.out.println("環繞通知中的after method....");
        }

        return result;
    }

applicationContext.xml

<!--進行aop相關的xml配置,配置aop的過程其實就是把aop相關術語落地-->
    <!--橫切邏輯bean-->
<bean id="logUtils" class="com.lagou.edu.utils.LogUtils"></bean>
   <!--使用config標籤代表開始aop配置,在內部配置切面aspect-->

   <!--aspect   =    切入點（鎖定方法） + 方位點（鎖定方法中的特殊時機）+ 橫切邏輯 -->
    <aop:config>
        <aop:aspect id="logAspect" ref="logUtils">

           <!--切入點鎖定咱們感興趣的方法，使用aspectj語法表達式-->
           <!--..參數中的兩個點表示能夠有參數，也能夠沒有參數，有的話也能夠是任意類型，參數中的 *表示參數能夠是任意類型，但必須有參數。 -->
           <!--包名中的..兩個點表示中間能夠是任意層-->
           <!--<aop:pointcut id="pt1" expression="execution(* *..*.*(..))"/>-->
         <aop:pointcut id="pt1" expression="execution(public void com.lagou.edu.service.impl.TransferServiceImpl.transfer(java.lang.String,java.lang.String,int))"/>

<!--           <aop:pointcut id="pt1" expression="execution(* com.lagou.edu.service.impl.TransferServiceImpl.*(..))"/>
-->
           <!--方位信息,pointcut-ref關聯切入點-->
           <!--aop:before前置通知/加強-->
            <aop:before method="beforeMethod" pointcut-ref="pt1"/>
           <!--aop:after，最終通知，不管如何都執行-->
           <!--aop:after-returnning，正常執行通知,retValue是接受方法的返回值的-->
            <aop:after-returning method="successMethod" returning="retValue"/>
           <!--aop:after-throwing，異常通知-->

            <aop:around method="arroundMethod" pointcut-ref="pt1"/>

        </aop:aspect>
    </aop:config>-->

測試：

/**
     * 測試xml aop
     */
    @Test
    public void testXmlAop() throws Exception {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        TransferService transferService = applicationContext.getBean(TransferService.class);
        transferService.transfer("6029621011000","6029621011001",100);
    }

環繞通知不和前置及後置通知一塊兒使用，由於環繞通知能夠實現前置和後置的功能，而且能夠控制原有業務邏輯是否執行，很是強大。

XML+註解方式

將上面純XML方式改成註解方式
將applicationContext.xml中的內容取掉，改成類中添加註解：

package com.lagou.edu.utils;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author 應癲
 */
@Component
@Aspect
public class LogUtils {


    @Pointcut("execution(* com.lagou.edu.service.impl.TransferServiceImpl.*(..))")
    public void pt1(){

    }


    /**
     * 業務邏輯開始以前執行
     */
    @Before("pt1()")
    public void beforeMethod(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            System.out.println(arg);
        }
        System.out.println("業務邏輯開始執行以前執行.......");
    }


    /**
     * 業務邏輯結束時執行（不管異常與否）
     */
    @After("pt1()")
    public void afterMethod() {
        System.out.println("業務邏輯結束時執行，不管異常與否都執行.......");
    }


    /**
     * 異常時時執行
     */
    @AfterThrowing("pt1()")
    public void exceptionMethod() {
        System.out.println("異常時執行.......");
    }


    /**
     * 業務邏輯正常時執行
     */
    @AfterReturning(value = "pt1()",returning = "retVal")
    public void successMethod(Object retVal) {
        System.out.println("業務邏輯正常時執行.......");
    }


    /**
     * 環繞通知
     *
     */
    /*@Around("pt1()")*/
    public Object arroundMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("環繞通知中的beforemethod....");

        Object result = null;
        try{
            // 控制原有業務邏輯是否執行
            // result = proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
        }catch(Exception e) {
            System.out.println("環繞通知中的exceptionmethod....");
        }finally {
            System.out.println("環繞通知中的after method....");
        }

        return result;
    }

}

在application.xml中配置註解驅動：

<!--開啓aop註解驅動
        proxy-target-class:true強制使用cglib

    -->
    <aop:aspectj-autoproxy/>

純註解模式

咱們只須要替換掉xml+註解模式中的註解驅動的部分便可，
將

<!--開啓aop註解驅動
        proxy-target-class:true強制使用cglib

    -->
    <aop:aspectj-autoproxy/>

改成 @EnableAspectJAutoProxy //開啓spring對註解AOP的⽀持，在項目中添加到任意個配置類上便可。

歡迎訪問：

微信公衆號（程序員資料站）：code_data