7、Spring AOP 注解方式实现

上官修平

已于 2023-05-10 10:43:22 修改

阅读量90

点赞数

分类专栏： spring 文章标签： spring java maven junit 开发语言

于 2023-05-06 16:27:21 首次发布

本文链接：https://blog.csdn.net/chf_liu/article/details/130529436

版权

spring 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

AspectJ本身并不是spring框架中的组成部分, 是一个独立的AOP框架,一般把AspectJ和Spring框架的AOP依赖一起使用,所以要导入一个独立的依赖

1、准备工作

1.1 导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.maliqiang</groupId>
    <artifactId>spring-aop-test02</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.5</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency><!--spring切面包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.5</version>
        </dependency>
        <!--织入包  spring-aspects 已经导入该包,这里可以不导入-->
        <!--<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>-->
        <!--aop联盟包-->
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>

    </dependencies>

</project>

1.2 切入点表达式

通过一个表达式来确定AOP要增强的是哪个或者那些方法

语法结构:execution([权限修饰符][返回值类型][类的全路径名][方法名](参数列表) )
例子1
execution(* com.maliqiang.dao.UserDaoImpl.add(..)) //指定切点为UserDaoImpl.add方法
execution(* com.maliqiang.dao.UserDaoImpl.*(..)) //指定切点为UserDaoImpl.所有的方法
execution(* com.maliqiang.dao.*.*(..)) //指定切点为dao包下所有的类中的所有的方法
execution(* com.maliqiang.dao.*.add(..)) // 指定切点为dao包下所有的类中的add的方法
execution(* com.maliqiang.dao.*.add*(..)) // 指定切点为dao包下所有的类中的add开头的方法

2、基于注解方式实现

2.1 在resources目录下面添加applicationContext.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util.xsd
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--配置扫描包 将扫描到的交给spring容器管理-->
    <context:component-scan base-package="com.maliqiang"></context:component-scan>

    <!--自动生成代理对象-->
    <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>

</beans>

2.2 添加接口和实现类

public interface EmpDAO {
    int addEmp(int empno, String ename,String job);
}

@Repository
public class EmpDAOImpl implements EmpDAO {
    @Override
    public int addEmp(int empno, String ename, String job) {
        System.out.println("EmpDAOImpl addEmp ... ... ");
        return 1;
    }
}


public interface UserDAO {
    int addUser(int userid,String username);
}

@Repository
public class UserDAOImpl implements UserDAO {
    @Override
    public int addUser(int userid,String username) {
        System.out.println("UserDAOImpl addUser ... ... ");
        return 1;
    }
}

2.3 添加切面类

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

/**
 * 切面类
 * 切入点表达式: 通过一个表达式来确定AOP要增强的是哪个或者那些方法
 * 语法结构:execution([权限修饰符][返回值类型][类的全路径名][方法名](参数 列表) )
 * 例子1
 * execution(* com.maliqiang.dao.UserDaoImpl.add(..))  //指定切点为UserDaoImpl.add方法
 * execution(* com.maliqiang.dao.UserDaoImpl.*(..))      //指定切点为UserDaoImpl.所有的方法
 * execution(* com.maliqiang.dao.*.*(..))                         //指定切点为dao包下所有的类中的所有的方法
 * execution(* com.maliqiang.dao.*.add(..))                     // 指定切点为dao包下所有的类中的add的方法
 * execution(* com.maliqiang.dao.*.add*(..))                   // 指定切点为dao包下所有的类中的add开头的方法
 */
@Component
@Aspect
public class DAOAspect {

    /**
     * 定义公共切点
     */
//    @Pointcut("execution(* com.maliqiang.dao.impl.UserDAOImpl.addUser(..))")
    @Pointcut("execution(* com.maliqiang.dao.*.add*(..))")
    private void commPointcut() {
    }

    /**
     * 前置通知 切点方法执行之前 先执行
     *
     * @param jp 切点对象 接收参数数列表
     */
//    @Before("execution(* com.maliqiang.dao.impl.UserDAOImpl.addUser(..))")
    @Before("commPointcut()")
    public void methodBefore(JoinPoint jp) {
        Object[] args = jp.getArgs();
        for (Object arg : args) {
            System.out.println("arg = " + arg);
        }
        System.out.println("methodBefore invoked");
    }


    /**
     * 后置通知 方法执行之后 要增强的功能
     *
     * @param jp 切点对象 接收参数数列表
     */
//    @After("execution(* com.maliqiang.dao.impl.UserDAOImpl.addUser(..))")
    @After("commPointcut()")
    public void methodAfter(JoinPoint jp) {
        System.out.println("methodAfter invoked");
    }

    /**
     * 返回通知 切点方法正常运行结束后 增强的功能
     * 如果方法运行过程中，出现异常，则该功能不运行
     *
     * @param jp  切点对象 接收参数数列表
     * @param res 返回的结果
     */
//    @AfterReturning(value = "execution(* com.maliqiang.dao.impl.UserDAOImpl.addUser(..))", returning = "res")
    @AfterReturning(value = "commPointcut()", returning = "res")
    public void methodAfterReturning(JoinPoint jp, Object res) {
        System.out.println("res = " + res);
        System.out.println("methodAfterReturning invoked");
    }

    /**
     * 异常通知 切点方法出现异常时 运行增强功能
     * 如果方法运行没有异常，则不执行该方法
     *
     * @param jp 切点对象 接收参数数列表
     * @param ex 异常信息
     */
//    @AfterThrowing(value = "execution(* com.maliqiang.dao.impl.UserDAOImpl.addUser(..))", throwing = "ex")
    @AfterThrowing(value = "commPointcut()", throwing = "ex")
    public void methodThrowing(JoinPoint jp, Exception ex) {
        System.out.println("ex.getMessage() = " + ex.getMessage());
        System.out.println("methodThrowing invoked");
    }

    /**
     * 环绕通知 在切点方法执行之前和执行之后都进行功能增强
     * 需要在通知中定义方法执行的位置，并在执行位置之前和执行位置之后自定义增强功能
     *
     * @param pjp 切点对象 接收参数数列表
     * @return
     * @throws Throwable
     */
//    @Around("execution(* com.maliqiang.dao.impl.UserDAOImpl.addUser(..))")
    @Around("commPointcut()")
    public Object methodAround(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("methodA invoked");
        Object proceed = pjp.proceed();
        System.out.println("methodB invoked");
        return proceed;
    }
}

2.4 添加测试


import com.maliqiang.dao.impl.EmpDAOImpl;
import com.maliqiang.dao.impl.UserDAOImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAOP {
    @Test
    public void testAop() {

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        EmpDAOImpl empDAO = context.getBean(EmpDAOImpl.class);
        empDAO.addEmp(1, "张三", "postman");
        System.out.println("****************************************************");
        UserDAOImpl userDAO = context.getBean(UserDAOImpl.class);
        System.out.println(userDAO.addUser(1, "小明"));
    }
}

2.5 完全使用注解开发

创建配置类



import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.maliqiang")
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class SpringConfig {

}

测试代码

import com.maliqiang.config.SpringConfig;
import com.maliqiang.dao.impl.EmpDAOImpl;
import com.maliqiang.dao.impl.UserDAOImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAOP {
    @Test
    public void testAop() {

//        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        EmpDAOImpl empDAO = context.getBean(EmpDAOImpl.class);
        empDAO.addEmp(1, "张三", "postman");
        System.out.println("****************************************************");
        UserDAOImpl userDAO = context.getBean(UserDAOImpl.class);
        System.out.println(userDAO.addUser(1, "小明"));
    }
}