spring（四）SpringAOP

已于 2022-01-18 22:06:42 修改
阅读量595 收藏
点赞数 1
分类专栏： Spring framework 文章标签： spring java aspect aop
于 2022-01-18 22:06:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lj15559275886/article/details/122569825
版权

一、概念

SpringAOP的底层实现就是对动态代理进行了封装，封装后我们只需要对关注的部分进行编码，并通过配置的方式完成指定目标方法的增强。

相关概念：

  • Target（目标对象）：要被增强的对象，一般指业务逻辑类的对象。
  • Proxy（代理）：一个类被AOP织入增强以后，就产生了一个结果代理类。
  • Aspect（切面）：表示增强的功能，就是一些代码完成的某些功能，即非业务功能。是切入点和通知的结合。
  • Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在Spring中，这些点是指方法（一般是类中业务方法），Spring只支持方法类型的连接点。
  • Pointcut（切入点）：指的是声明的一个或多个连接点的集合，通过切入点指定一组方法。被标记为final的方法是不能作为连接点或切入点的，因为它不能被修改，也不能增强。
  • Advice（通知/增强）：拦截到Joinpoint之后需要做的事情就是通知。通知定义了增强代码切入到目标代码的时间点，即目标执行方法之前还是之后。通知类型不同，切入时间不同。 通知类型：前置通知，后置通知，异常通知，最终通知，环绕通知。
    切入点定义切入位置，通知定义切入时间。
  • Weaving（织入）：指把增强应用到目标对象来创建新的代理对象的过程。Spring采用动态代理方式织入，而AspectJ采用编译期织入和类装载期织入。

切面的三个关键因素：

  • 切面的功能
  • 切面的执行位置（pointCut）
  • 切面的执行时间（advice）

二、AspectJ对AOP的实现

对于AOP的编程思想，很多框架都进行了实现，Spring就是其中之一，可以完成面向切面编程。AspectJ也实现了AOP功能，且其实现方式更为简洁还支持注解式开发。所以，Spring又将AspectJ对AOP的实现引入到自己的框架中。

AspectJ是一个优秀的面向切面的框架，它扩展了Java语言，提供了强大的切面实现。

2.1、AspectJ的通知类型

AspectJ支持5种通知类型：

  • 前置通知
  • 后置通知
  • 异常通知
  • 最终通知
  • 环绕通知

2.2、AspectJ切入点表达式

AspectJ定义了专门的表达式用于指定切入点。
表达式原型：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

execution(访问权限 方法返回值 方法声明(参数) 异常类型)

说明：

表达式描述
modifiers-pattern访问权限类型
ret-type-pattern返回值类型
declaring-type-pattern包名类名
name-pattern(param-pattern)方法名（参数类型和参数个数）
throws-pattern抛出异常类型
？可选部分

切入点表达式要匹配的对象就是目标方法的方法名。所以，execution表达式中就是方法的签名。表达式各部分间用空格分隔，在其中可以使用以下符号：

符号含义
*0-多个任意字符
…用在方法参数中，表示任意个参数；用在包后，表示当前及其子包路径
+用在类名后，表示当前及其子类；用在接口后，表示当前接口及其实现

示例：

// 指定切点为：定义在service包中任意类 任意方法
execution(* com.kkb.service.*.*(..)) 

// 指定切点为：定义在service包或者子包中任意类 任意方法。 ..出现在类名中，后面必须跟*，表示包、子包下所有类。
execution(* com.kkb.service..*.*(..)) 

// 指定切点为：IUserService若为接口，则表示接口中任意方法及其实现类中任意方法；若为类，则表示该类及其子类中任意方法
execution(* com.kkb.service.IUserService+.*(..))

三、注解方式实现AOP

开发阶段：关心核心代码和AOP代码

运行阶段：spring框架会在运行时将核心业务和AOP代码通过动态代理方式编织在一起

代理方式选择：如果实现了接口就选择JDK动态代理；没有就选择CGLIB动态代理。

3.1、新建maven项目添加pom依赖

 <dependencies>
        <!--   单元测试    -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--   spring依赖    -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!--   编译插件    -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

3.2、添加配置文件application.xml

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

    <!--  包扫描  -->
    <context:component-scan base-package="com.jsonliu.test.service,com.jsonliu.test.config" />
    <!--  开启aop注解使用  -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
<!--
   aop:aspectj-autoproxy 底层是由 AnnotationAwareAspectJAutoProxyCreator 实现的，是基于AspectJ的注解适配自动代理生成器。
   工作原理：aop:aspectj-autoproxy通过扫描找到@Aspect定义的切面，再由切面根据切点找到目标类的目标方法，再由通知类型找到切入的时间点。
 -->

</beans>

3.3、添加接口

public interface IService {

    void add(int id,String name);

    boolean update(int num);

}

3.4、添加实现类

@Service
public class TeamService implements IService{
    @Override
    public void add(int id, String name) {
        System.out.println("TeamService-------------add------------------");
    }

    @Override
    public boolean update(int num) {
        System.out.println("TeamService-------------update------------------");
        // 模拟异常
        int k=num/0;
        if(num>999) return true;
        return false;
    }
}


@Service("userService")
public class UserService implements IService{
    @Override
    public void add(int id, String name) {
        System.out.println("UserService-------------add------------------");
    }

    @Override
    public boolean update(int num) {
        System.out.println("UserService-------------update------------------");
        if(num<999) return true;
        return false;
    }
}

3.5、添加切面

@Aspect
@Component
public class MyAspect {

    /**
     * 当多个通知增强方法使用相同的execution切入点表达式，编写维护较为麻烦。
     * AspectJ提供了@Pointcut注解，用于定义execution切入点表达式
     * 用法：将@Pointcut注解在一个方法上，以后所有的execution的value值都可以使用该方法名作为切入点。
     * 代表的就是@Pointcut定义的切入点
     * 这个使用@Pointcut的注解方法一般使用private标识的方法，即没有实际作用的方法
     */
    @Pointcut("execution(* com.jsonliu.test.service..*.*(..))")
    private void pointCut(){

    }

    /**
     * 前置通知
     * @param jp
     */
    @Before("pointCut()")
    public void before(JoinPoint jp) {
        System.out.println("前置通知before：目标方法执行之前调用的通知");
        String name = jp.getSignature().getName();
        System.out.println("拦截的方法名称：" + name);
        Object[] args = jp.getArgs();
        System.out.println("拦截的方法个数：" + args.length);
        for (Object arg : args) {
            System.out.println("拦截的参数：" + arg);
        }
    }

    /**
     * 后置通知
     * value：切入点表达式，returning：返回的结果，可以在后置通知中修改
     * @param result
     * @return
     */
    @AfterReturning(value = "pointCut()",returning = "result")
    public Object afterReturn(Object result){
        System.out.println("后置通知afterReturn：目标方法执行之后被调用的通知，result="+result);
        return result==null?"":result.toString();
    }

    /**
     * 环绕通知
     * ProceedingJoinPoint中的proceed()方法表示目标方法被执行
     * @param pjp
     * @return
     * @throws Throwable
     */
    @Around(value = "pointCut()")
    public Object around(ProceedingJoinPoint pjp)throws Throwable {
        System.out.println("环绕通知--目标方法执行之前");
        Object proceed = pjp.proceed();
        System.out.println("环绕通知--目标方法执行之后");
        return proceed;
    }

    /**
     * 异常通知
     * value：切入点表达式，ex：异常信息
     * @param jp
     * @param ex
     */
    @AfterThrowing(value = "pointCut()",throwing = "ex")
    public void exception(JoinPoint jp,Throwable ex){
        //一般用于记录异常发生的时间、位置、原因
        System.out.println("异常通知exception：目标方法执行出现异常时才会调用的通知，否则不会执行");
        System.out.println(jp.getSignature().getName()+"方法出现异常，异常的信息："+ex.getMessage());
    }

    /**
     * 最终通知
     */
    @After("pointCut()")
    public void myFinally(){
        System.out.println("最终通知after：无论是否出现异常都是最后执行的通知");
    }

}

3.6、添加测试类

    @Test
    public void test1(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        TeamService teamService = (TeamService) applicationContext.getBean("teamService");
        System.out.println("-----------------------------add---------------------------------");
        teamService.add(1,"阿森纳");
        System.out.println("-----------------------------update---------------------------------");
        teamService.update(9999);

        System.out.println("-----------------------------UserService---------------------------------");
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.add(22,"曼联");

    }

运行结果：

在这里插入图片描述

四、XML方式实现AOP

4.1、修改Aspect

@Aspect    //aspectj 框架的注解 标识当前类是一个切面
@Component  //切面对象的创建权限依然交给spring容器
public class XmlAspect { 

    /**
     * 前置通知
     * @param jp
     */
    public void before(JoinPoint jp) {
        System.out.println("前置通知before：目标方法执行之前调用的通知");
        String name = jp.getSignature().getName();
        System.out.println("拦截的方法名称：" + name);
        Object[] args = jp.getArgs();
        System.out.println("拦截的方法个数：" + args.length);
        for (Object arg : args) {
            System.out.println("拦截的参数：" + arg);
        }
    }

    /**
     * 后置通知
     * @param result
     * @return
     */
    public Object afterReturn(Object result){
        System.out.println("后置通知afterReturn：目标方法执行之后被调用的通知，result="+result);
        return result==null?"":result.toString();
    }

    /**
     * 环绕通知
     * @param pjp
     * @return
     * @throws Throwable
     */
    public Object around(ProceedingJoinPoint pjp)throws Throwable {
        System.out.println("环绕通知--目标方法执行之前");
        Object proceed = pjp.proceed();
        System.out.println("环绕通知--目标方法执行之后");
        return proceed;
    }

    /**
     * 异常通知
     * value：切入点表达式，ex：异常信息
     * @param jp
     * @param ex
     */
    public void exception(JoinPoint jp,Throwable ex){
        //一般用于记录异常发生的时间、位置、原因
        System.out.println("异常通知exception：目标方法执行出现异常时才会调用的通知，否则不会执行");
        System.out.println(jp.getSignature().getName()+"方法出现异常，异常的信息："+ex.getMessage());
    }

    /**
     * 最终通知
     */
    public void myFinally(){
        System.out.println("最终通知after：无论是否出现异常都是最后执行的通知");
    }

}

4.2、添加XML

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

    <!--  包扫描  -->
    <context:component-scan base-package="com.jsonliu.test.service,com.jsonliu.test.config" />
    <!--  开启aop注解使用  -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
<!--
   aop:aspectj-autoproxy 底层是由 AnnotationAwareAspectJAutoProxyCreator 实现的，是基于AspectJ的注解适配自动代理生成器。
   工作原理：aop:aspectj-autoproxy通过扫描找到@Aspect定义的切面，再由切面根据切点找到目标类的目标方法，再由通知类型找到切入的时间点。
 -->
    <aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.jsonliu.test.service..*.update*(..))"/>
        <aop:pointcut id="pt2" expression="execution(* com.jsonliu.test.service..*.add*(..))"/>
        <aop:aspect ref="xmlAspect">
            <aop:before method="before" pointcut="execution(* com.jsonliu.test.service..*.*(..))"/>
            <aop:after-returning method="afterReturn" pointcut-ref="pt1" returning="result"/>
            <aop:after-throwing method="exception" pointcut-ref="pt1" throwing="ex"/>
            <aop:after method="myFinally" pointcut-ref="pt2" />
            <aop:around method="around" pointcut-ref="pt1" />
        </aop:aspect>
    </aop:config>

</beans>

4.3、添加测试类

    @Test
    public void test2(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("xmlAop.xml");
        TeamService teamService = (TeamService) applicationContext.getBean("teamService");
        System.out.println("-----------------------------add---------------------------------");
        teamService.add(1,"阿森纳");
        System.out.println("-----------------------------update---------------------------------");
        teamService.update(9999); 
    }
笑谈子云亭
关注
专栏目录
SpringAOP(图文详解)
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
spring aop jar 包
07-26
Spring AOP(Aspect Oriented Programming，面向切面编程)是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口，...
＜aop:aspectj-autoproxy /＞作用
weixin_38987366的博客
11-06 3426
通过配置织入@Aspectj切面 虽然可以通过编程的方式织入切面，但是一般情况下，我们还是使用spring的配置自动完成创建代理织入切面的工作。 通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-au
Spring源码学习(十八)---基于注解配置Aop的aspectj-autoproxy解析
https://juejin.cn/user/4248168663101239/posts
02-16 1340
这里主要是使用org.springframework:spring-beans:5.2.0.RELEASE进行分析 文章目录①. aspectj-autoproxy标签1. proxy-target-class属性2. expose-proxy属性②. aspectj-autoproxy标签解析③. DefaultBeanDefinitionDocumentReader类的parseBeanDefinitions方法④. 通过parseCustomElement解析自定义标⑤. Namespacehand.
【Spring】AOP（面向切面编程），动态代理详解，AspectJ注解
放开这颗白菜让我来
09-04 1176
大家好，我是被白菜拱的猪。 一个热爱学习废寝忘食头悬梁锥刺股，痴迷于girl的潇洒从容淡然coding handsome boy。 文章目录一、写在前言二、AOP（一）概念介绍（二）底层原理1、动态代理简单介绍2、JDK动态代理代码实现（三）操作术语（四）AOP操作（AspectJ注解）1、前期准备2、具体步骤3、通知执行顺序4、注意事项（五）AOP操作（基于AspectJ配置文件）三、结束语 一、写在前言 二、AOP （一）概念介绍 AOP为Aspect Oriented Programming的缩写，
spring框架 aop:aspectj-autoproxy proxy-target-class=“true“用法理解
最新发布
weixin_43860634的博客
09-28 2320
CGLIB动态代理
SpringAOP源码解析之aop:aspectj-autoproxy标签解析
0xZzzz的博客
01-11 9728
阅读须知文章中使用//单行注释做代码的简单注释，而/**/多行注释的代码会做深入分析，为了避免篇幅过长，删掉了Spring原来的注释和空行，建议配合Spring源代码进行阅读，本文对应的Spring源码的版本为4.3.8。本文的主要内容是分析Spring AOP配置解析的源码。正文Spring AOP是我们日常开发中经常使用的工具，常被用来做统一的日志、异常处理、监控等功能，使用方法在此不多赘述，有
Spring AOP教程
12-07
Spring框架的关键组件之一是面向方面编程(AOP)框架。 面向方面的编程需要将程序逻辑分解成不同的部分。 此教程将通过简单实用的方法来学习Spring框架提供的AOP/面向方面编程。
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
Spring IOC和Spring AOP_spring aop_springIOC
09-24
4. **Bean的作用域**：Spring支持单例（Singleton）、原型（Prototype）、会话（Session）和请求（Request）四种作用域，满足不同场景下的需求。 **Spring AOP** 面向切面编程（AOP）是Spring框架的另一大特色，它...
＜aop:aspectj-autoproxy /＞AOP自动代理
qq_31856061的博客
03-21 1825
<aop:aspectj-autoproxy />作用 通过配置织入@Aspectj切面 虽然可以通过编程的方式织入切面，但是一般情况下，我们还是使用spring的配置自动完成创建代理织入切面的工作。 通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工
Spring MVC和Spring配置AOP
来啊 快活啊
01-09 5739
1.首先Spring MVC和Spring是两个东西，配置文件是分开的，配置文件的加载也是分开的。所以要想给Spring MVC的Controller添加AOP的话，得在Spring MVC的配置文件中配置，要想给Service和Repository添加AOP的话得在Spring的配置文件中配置。 2.以一个例子说明，有人配置了Service层的事务AOP之后，事务不起作用。原因是在Spring
spring基于aspectj的AOP配置 aop:aspectj-autoproxy proxy-target-class="true"
热门推荐
qq_36063677的博客
09-21 1万+
精通Spring4.x--企业应用开发实战 8.5.1@AfterReturning("@annotation()")切点函数详解   代码实现的目标是为NaugthyWaiter类的greetTo()方法实现后置增强，其中greetTo()方法被@NeedTest注解标注。增强类为TestAspect。 增强类： @Aspect @Component public class Te...
SpringAOP之@EnableAspectJAutoProxy注解如何实现自动代理？
我神级欧文的博客
07-15 2275
前面我们主要说了关于SpringAOP底层的API，这篇文章就来说说这些底层的API与SpringIOC容器的结合是如何实现对象的自动代理的 @EnableAspectJAutoProxy 通常我们在一个spring项目中要使用SpringAOP的功能的时候，除了要加上AOP和AspectJ的依赖，还要在配置类上面加上@EnableAspectJAutoProxy注解，该注解的作用就是开启SpringAOP的自动代理功能，下面我们来看这个注解的作用 @EnableAspectJAutoProxy..
aop:aspectj-autoproxy,SpringAOP拦截Controller，Service实现日志管理（自定义注解方式）
金溪的博客
01-15 642
可以用拦截器，也可以用aop。 第一步定义注解：   @Target({ElementType.PARAMETER, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface SystemControllerLog { St...
配置Spring AOP aspectj-autoproxy标签源码解析
innerpeacez成长之路
03-10 2609
配置AOP标签 在配置文件中配置了以下标签，即可开启AOP： &lt;aop:aspectj-autoproxy /&gt; 此标签有以下两个属性： &lt;aop:aspectj-autoproxy proxy-target-class="false" expose-proxy="false"/&gt; 开启AOP之后：会使用AspectJAutoProxyBeanDefini...
<aop:aspectj-autoproxy />作用
tsuguA的专栏
02-19 1947
有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。
spring代理注解<aop:aspectj-autoproxy />
偶是一只小小鸟~
02-04 9661
spring默认使用jdk的代理方式, 使用jdk的代理方式我们知道,代理的类需要实现一个接口,若果没有就会报,java.lang.NoSuchMethodException: com.sun.proxy.$Proxy83.loginPage()异常, 这时候我们可以使用让spring使用cglib的代理方式, cglib的时候需要有默认的构造方法,class不能为final的,
Spring AOP的实现原理之<aop:aspectj-autoproxy />的解析
09-06 2800
本文主要针对注解形式的AOP作分析，即在application.xml用<aop:aspectj-autoproxy /> 当Spring 解析application.xml遇到上面提及的aop标签，而这个标签属于自定义标签，DefaultBeanDefinitionDocumentReader 委托delegate处理自定义标签 /** * Parse the elements
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

笑谈子云亭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值