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