SpringAOP 有哪些實現方式

SpringAOP 有哪些實現方式？相信很多沒有經驗的人對此束手無策，為此本文總結了問題出現的原因和解決方法，通過這篇文章希望你能解決這個問題。

引入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的?持，在項目中添加到任意個配置類上即可。

看完上述內容，你們掌握SpringAOP 有哪些實現方式的方法了嗎？如果還想學到更多技能或想了解更多相關內容，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！