Spring框架学习笔记（二）：AOP面向切片编程

最新推荐文章于 2023-05-08 19:18:07 发布
最新推荐文章于 2023-05-08 19:18:07 发布
阅读量225 收藏 1
点赞数
文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36833171/article/details/104603598
版权

AOP面向切片编程

AspectJ AOP

使用AspectJ注解开发

开发准备

porn.xml

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <!--引入Spring的基本开发包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>1.0</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.9</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
  </dependencies>

XML配置模版：https://docs.spring.io/spring-framework/docs/4.2.4.RELEASE/spring-framework-reference/html/xsd-configuration.html#xsd-config-body-schemas-beans

<?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:aop="http://www.springframework.org/schema/aop" 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">

    <!--开启aspectj注解开发，自动代理-->
    <aop:aspectj-autoproxy/>

</beans>

@AspectJ提供的通知类型

@Before前置通知，相当于BeforeAdvice

@AfterReturning后置通知，相当于AfterReturningAdvice

@Around环绕通知，相当于MethodInterceptor

@AfterThrowing异常抛出通知，相当于ThrowAdvice

@After最终通知，不管是否异常，该通知都会执行

@DeclareParents引介通知，相当于IntroductionInterceptor

在通知中通过Value属性定义切点

通过execution函数，可以定义切点的方法切入

语法

execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

匹配所以类public方法 execution(public * *(..))

匹配指定包下所有类方法execution(* com.company.dao.*(..))

包、子孙包下的所有类execution(* com.company.dao..*(..)) …*

匹配指定类的所有方法execution(* com.company.service.UserService.*(..))

匹配实现特定接口所有类方法execution(* com.company.dao.GenericDAO+.*(..)) +表示接口的所有子类

匹配所以save开头的方法execution(* save*(..))

注解开发基础案例

​ 为一个类中的一个方法实现前置代理

步骤

  1. 定义目标类
  2. 为目标类定义切面类
  3. 配置Bean
  4. 配置测试类

目标类ProductDao

public class ProductDao {
    public void save() {
        System.out.println("保存商品");
    }

    public void update() {
        System.out.println("更新商品");
    }

    public void delete() {
        System.out.println("删除商品");
    }

    public void findOne() {
        System.out.println("查找一个商品");
    }

    public void findAll() {
        System.out.println("查找所有商品");
    }
}

为目标类定义切面类

@Aspect
public class MyAspectAnno {

    @Before(value = "execution(* com.company.aspectJ.ProductDao.save(..))")
    public void before() {
        System.out.println("前置通知========");
    }
}

配置Bean：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:aop="http://www.springframework.org/schema/aop" 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">

    <!--开启AspectJ的注解开发，自动代理-->
    <aop:aspectj-autoproxy/>

    <!--目标类-->
    <bean id="productDao" class="com.company.aspectJ.ProductDao"/>

    <!--定义切面-->
    <bean class="com.company.aspectJ.MyAspectAnno"/>
</beans>

配置测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Text {
    @Resource(name = "productDao")
    private ProductDao productDao;

    @Test
    public void demo1() {
        productDao.save();
        productDao.delete();
        productDao.update();
        productDao.findOne();
        productDao.findAll();
    }
}

@Before 前置通知：利用JoinPoint获取切点信息

可以在方法中传入JoinPoint对象，用来获取切点信息。

@Before(value = "execution(* com.company.aspectJ.ProductDao.save(..))")
    public void before(JoinPoint joinPoint) {
        System.out.println("前置通知========" + joinPoint);
    }

前置通知========execution(void com.company.aspectJ.ProductDao.save())
保存商品

@AfterReturning后置通知：获取后置通知返回值

由于方法具有返回值类型，后置通知又是在方法执行之后执行的通知，因此可以后置通知可以拿到目标方法的返回值进行调用。

通过returning属性可以定义方法返回值，作为参数。

  1. 目标方法，切入点

    public String update() {
        System.out.println("更新商品");
        return "后置通知返回值";
    }

  2. 通知

    @AfterReturning(value = "execution(* com.company.aspectJ.ProductDao.update(..))",returning = "result")
    public void afterReturning(Object result) {
        System.out.println("后置通知========" + result);
    }

  3. 打印结果

    更新商品
后置通知========后置通知返回值

@Around 环绕通知

@Around(value = "execution(* com.company.aspectJ.ProductDao.delete(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前通知========");
        Object obj = joinPoint.proceed();    //如果不调用该方法，目标方法就会被拦截。
        System.out.println("环绕后通知========");
        return obj;
    }

  • around方法的返回值就是目标代理方法执行返回值

  • 参数为ProceedingJoinPoint可以调用拦截目标方法执行

  • 如果不调用ProceedingJoinPoint的proceed()方法，目标方法就会被拦截，就不会被执行。

@AfterThrowing 异常抛出通知

AspectJ可以在切点发生异常时捕获异常并进行异常抛出通知的处理。常用在事务处理的回滚操作上。

public void findOne() {
        System.out.println("查找一个商品");
        int i = 1/0;
    }

定义通知

@AfterThrowing(value = "execution(* com.company.aspectJ.ProductDao.findOne(..))",throwing = "e")
    public void afterThrowing(Throwable e) {
      // e.getMessage())可以捕获异常并获取异常信息
        System.out.println("异常抛出通知========" + e.getMessage());
    }
  • 通过设置throwing属性，可以设置发生异常对象参数。

@After 最终通知

无论是否实现异常，最终通知总是被执行的。

public void findAll() {
        System.out.println("查找所有商品");
        int i = 1/0;
    }

@After(value = "execution(* com.company.aspectJ.ProductDao.findAll(..))")
    public void after() {
        System.out.println("最终通知========");
    }

最终通知========

java.lang.ArithmeticException: / by zero
	...

@Pointcut为切点命名

可以使用**@Pointcut**定义切点，提高代码维护性。

切点方法：praivite void 无参数构造方法，方法名为切点名

当使用多个切点，可以用||进行连接。

​ 使用PointCut定义之后的切点

@Before(value = "myPointCut1()")
    public void before(JoinPoint joinPoint) {
        System.out.println("前置通知========" + joinPoint);
    }

    @AfterReturning(value = "myPointCut2()",returning = "result")
    public void afterReturning(Object result) {
        System.out.println("后置通知========" + result);
    }

    @Around(value = "myPointCut3()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前通知========");
        Object obj = joinPoint.proceed();    //如果不调用该方法，目标方法就会被拦截。
        System.out.println("环绕后通知========");
        return obj;
    }

    @AfterThrowing(value = "myPointCut4()",throwing = "e")
    public void afterThrowing(Throwable e) {
        System.out.println("异常抛出通知========" + e.getMessage());
    }

    @After(value = "myPointCut5()")
    public void after() {
        System.out.println("最终通知========");
    }

    @Pointcut(value = "execution(* com.company.aspectJ.ProductDao.save(..))")
    public void myPointCut1() {}

    @Pointcut(value = "execution(* com.company.aspectJ.ProductDao.update(..))")
    public void myPointCut2() {}

    @Pointcut(value = "execution(* com.company.aspectJ.ProductDao.delete(..))")
    public void myPointCut3() {}

    @Pointcut(value = "execution(* com.company.aspectJ.ProductDao.findOne(..))")
    public void myPointCut4() {}

    @Pointcut(value = "execution(* com.company.aspectJ.ProductDao.findAll(..))")
    public void myPointCut5() {}

XML方式进行AOP开发

使用XML改写注解方法进行开发。

porn.xml参见上面的注解依赖

// CustomerDao	接口
public interface CustomerDao {
	public void save();
	...
}

// CustomerDaoImpl	接口实现类
public class CustomerDaoImpl implements CustomerDao {
	 @Override
    public void save() {
        System.out.println("save...");
    }
    ...
}

// MyAspectXml	通知类
public class MyAspectXml {

    public void before(JoinPoint joinPoint) {
        System.out.println("前置通知========" + joinPoint);
    }

    public void afterReturning(Object result) {
        System.out.println("后置通知========" + result);
    }

    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前通知========");
        Object obj = joinPoint.proceed();    //如果不调用该方法，目标方法就会被拦截。
        System.out.println("环绕后通知========");
        return obj;
    }

    public void afterThrowing() {
        System.out.println("异常抛出通知========");
    }

    public void after() {
        System.out.println("最终通知========");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!--applicationContext2.xml-->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop" 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">

    <!--XML的配置完成AOP开发-->
    <!--配置目标类-->
    <bean id="customerDao" class="com.company.aspectJ.demo2.CustomerDaoImpl"/>

    <!--配置切面类-->
    <bean id="myAspectXml" class="com.company.aspectJ.demo2.MyAspectXml"/>

    <!--aop的相关配置-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="pointcut1" expression="execution(* com.company.aspectJ.demo2.CustomerDao.save(..))"/>
        <aop:pointcut id="pointcut2" expression="execution(* com.company.aspectJ.demo2.CustomerDao.update(..))"/>
        <aop:pointcut id="pointcut3" expression="execution(* com.company.aspectJ.demo2.CustomerDao.delete(..))"/>
        <aop:pointcut id="pointcut4" expression="execution(* com.company.aspectJ.demo2.CustomerDao.findOne(..))"/>
        <aop:pointcut id="pointcut5" expression="execution(* com.company.aspectJ.demo2.CustomerDao.findAll(..))"/>

        <!--配置AOP的切面-->
        <aop:aspect ref="myAspectXml">
            <!--配置前置增强-->
            <aop:before method="before" pointcut-ref="pointcut1"/>
            <!--配置后置通知-->
            <aop:after-returning method="afterReturning" pointcut-ref="pointcut2" returning="result"/>
            <!--配置环绕通知-->
            <aop:around method="around" pointcut-ref="pointcut3"/>
            <!--配置异常抛出通知-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4"/>
            <!--配置最终通知-->
            <aop:after method="after" pointcut-ref="pointcut5"/>
        </aop:aspect>
    </aop:config>
</beans>

// 测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "classpath:applicationContext2.xml")
public class SpringDemo2 {

    @Resource(name = "customerDao")
    private CustomerDao customerDao;

    @Test
    public void demo1() {
        customerDao.save();
        customerDao.update();
        customerDao.delete();
        customerDao.findOne();
        customerDao.findAll();
    }
}
清紫悠悠
关注
Spring学习笔记——二、面向切片编程（AOP）
ajacker的博客
10-11 376
文章目录第二部分 AOP面向切片编程A. 代码冗余与装饰器模式(AOPTest)一、代码冗余现象二、动态代理解决方案B. AOP解决代码冗余一、 AOP相关术语二、 使用XML配置AOP的步骤1. 添加Aop的依赖2. 在`bean.xml`中引入约束3. 使用``标签声明AOP配置4. 使用``标签配置切面5. 使用``配置切入点6. 配置具体的通知方法*.1 切入点表达式*.2 环绕通知C. ...
Spring学习笔记
qq_46161942的博客
02-25 305
Spring是轻量级的开源的JavaEE框架Spring可以解决企业应用开发的复杂性Spring有两个核心部分：IOC和AOP(1) IOC:控制反转：把创建对象的过程交给Spring进行管理(2) AOP:面向切片，不修改源代码进行功能增强Spring特点(1) 方便解耦，简化开发(2) AOP编程支持(3) 方便程序测试(4) 方便和其他框架进行整合(5) 方便进行事务操作(6) 降低API开发难度课程以Spring5.x为例。
面向切面编程（AOP）框架AspectJ
老头儿ii的博客
03-22 235
AOP
Spring框架-面向切面（AOP）
趁年轻不如拼一拼
06-01 227
文章目录1. 1.
Spring切面编程
最新发布
BadBoyxiaolin的博客
05-08 1818
*** @Description: 操作日志注解*/ @Documented @Target(ElementType . METHOD) // 作用在方法上 @Retention(RetentionPolicy . RUNTIME) // 运行时有效 public @interface Operation {/*** 操作模块/*** 操作类型/*** 操作说明。
spring实现aop面向切片编程的方式
热门推荐
吴名氏的博客
10-20 16万+
aop底层将采用代理机制进行实现，所以我们从底层开始讲，再到springaop，会有如下几种方式： 1.JDK动态代理（该方法必须要有接口和实现类都存在），代码如下： 切面类： 工厂类： 测试类： 2.使用cglib 增强字节码（该方法接口可以不存在），代码如下： 工厂类： 测试结果： 3.Spring编写代理半自动，代码如下： spring...
spring-AOP面向切面编程所需jar包.zip
06-22
该压缩包包含--学习笔记(05):轻松搞定Spring全家桶(初识篇)-面向切片编程AOP：--系列博客中新需要的三个jar包。包括spring-aspects-5.2.7.RELEASE.jar和spring-aop-5.2.7.RELEASE.jar和...
Spring框架笔记
sd517125的博客
06-18 195
Spring是用来将普通的javabean变成ejb来处理业务 Spring是一个轻量级的用于简化商业应用开发的容器框架。它的核心是控制反转（IOC）【也叫依赖注入】和（AOP）面向切片编程 IOC：控制反转 bean产生的实例交给Spring容器，基于工厂设计模式 依赖注入 配置依赖类，用这个类代替xml文件 配置要托管的bean @Configuration 配置配置类 @Co...
spring-analizy:spring源码分析
03-23
这个名为"spring-analizy-master"的项目，很可能是包含一系列关于Spring源码分析的文章、笔记或者代码示例，为开发者提供了一个系统化的学习资源。通过研究这些资料，开发者可以逐步揭开Spring框架的神秘面纱，提升...
String AOP（面向切片编程）是什么？如何实现？
Josvin
06-16 481
是什么？？？ 面向切面编程（AOP）和面向对象编程（OOP）类似，也是一种编程模式。Spring AOP 是基于 AOP 编程模式的一个框架，它的使用有效减少了系统间的重复代码，达到了模块间的松耦合目的。 AOP 的全称是“Aspect Oriented Programming”，即面向切面编程，它将业务逻辑的各个部分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。 AOP 采取横向抽取机制，取代了传统纵向继承体系的重复性代码，其应用主要体现在事务处理、日志管理、权限控制、异常
Spring实战：（2）面向切片的Spring
CAOJUN_FANG的博客
11-18 778
1.面向切面编程 在面向切面编程时，我们在一个地方定义通用功能，但是可以通过声明的方式定义这个功能要以何种方式在何处应用，而无需修改受影响的类。横切关注点（散布于应用中多处的功能） 可以被模块化为特殊的类，这些类被称为切面。 1.1 定义AOP术语 1.1.1 通知（Advice） 在AOP术语中，切面的工作称为通知，通知定义了切面是什么以及何时使用，除了描述切面要完成的工作，通知还解决了何时执行这个工作的问题。 Spring切面可以应用5种类型的通知： 前置通知（Before）： 在目标方法被调用之前调
SSM学习笔记9 Spring的AOP （一种思想）
internetv的博客
02-21 183
Spring的AOP简介 A功能和B功能，代码分离，但在程序运行时AB动态结合，类似于代码抽取 基于jdk的动态代理 用Advice去增强Target ProxyTest package com.itheima.proxy.jdk; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; publ....
Spring-AOP 面向切面编程
Specif1c的博客
02-05 411
一.Spring 的 AOP 简介 1. 什么是 AOP AOP 为 Aspect Oriented Programming 的缩写，意思为 面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP (面对对象) 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 2 .AOP 的
图文详解Spring AOP，你学会了吗？
qq_39652397的博客
04-28 3129
如果说 IOC 是 Spring 的核心，那么面向切面编程AOP就是 Spring 另外一个最为重要的核心，需要重点掌握@mikechen 本篇主要会详解以下六点： 1.AOP的定义 2.AOP的作用 3.AOP的应用场景 4.Spring AOP的术语 AOP核心概念 Spring AOP 通知分类 Spring AOP 织入时期 5.Spring AOP三种使用方式 方式1：使用Spring自带的AOP 方式2：使用Aspectj实现切面(普通POJO的实现方式) 方式3：使用As
面向切面编程AOP
Gem_dzq的博客
04-13 524
面向切面编程AOP
关于Aop切面中的@Before @Around等操作顺序的说明
weixin_30521649的博客
04-01 326
【转】http://www.cnblogs.com/softidea/p/6123307.html 话不多说，直接上代码： package com.cdms.aop.aspectImpl; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org...
spring AspectJ的Execution表达式-备忘笔记(转)
zhuchengzzcc的专栏
04-28 2288
Aspectj切入点语法定义 在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点" 例如定义切入点表达式  execution (* com.sample.service.impl..*.*(..)) execution()是最常用的切点函数，其语法如下所示：  整个表达式可以分为五个部分：  1、execution():...
Spring中的AOP你还晓得怎么用吗？
希冀
05-05 279
文章目录AOP切面编程什么是AOP一个简单计算数功能加日记原始方法统一日记处理。使用代理实现日记使用jdk动态代理统一日记使用cglib代理AOP编程的专业术语使用Spring实现AOP简单切面编程Spring的切入点表达式Spring切面中的代理对象Spring通知的执行顺序获取连接点信息获取拦截方法的返回值和抛的异常信息 AOP切面编程 什么是AOP AOP是面向切面编程。全称：Aspect ...
Spring框架复习14-AOP通知类型前/后/环绕/异常/最终通知
05-10 244
<!--配置aop--> <aop:config> <!--配置切入点:也就是要给那个方法进行增强--><!--*表示返回类型为任意类型；..表示传递的参数为任意参数--> <aop:pointcut id="pointcut" expression="execution(* com.ctbu.dao....
Spring框架学习笔记：IoC与AOP解析
"Spring_in_action_学习笔记" Spring框架是Java开发中的一个重要组成部分，以其轻量级、非侵入式的设计理念赢得了广泛的认可。本学习笔记主要涵盖了Spring的基础知识，包括核心特性和模块组成。 1. Spring核心特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值