Spring AOP面向切面知识整理(maven+ssm)

最新推荐文章于 2023-11-21 20:40:53 发布
翻译 最新推荐文章于 2023-11-21 20:40:53 发布 · 1.3k 阅读 · 3
文章标签：

#Spring #AOP #面向切面

本文详细介绍了Spring AOP的概念、应用场景、实现原理，包括基于XML和注解的配置方法。通过实例展示了切面表达式、切面通知和执行顺序的配置，并探讨了AOP在日志、事务等场景中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、Spring AOP概述

1.AOP是什么

AOP 是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善

2.AOP应用场景

AOP目的：基于OCP(开闭原则)在不改变原有系统核心业务代码的基础上动态添加一些扩展功能并可以控制对象的执行。

应用场景示例：AOP常应用于日志的处理，事务处理，权限处理，缓存处理等

3.AOP实现原理

AOP底层基于代理机制实现：

  • 被代理对象实现了接口时，采用JDK动态代理机制：代理类和被代理类默认实现相同接口；
  • 被代理对象未实现接口时，采用CGLIB代理机制：代理类默认继承被代理类；

4.AOP相关术语

  • 切面aspect:用于封装扩展业务的类的对象；
  • 连接点joinpoint
  • 切入点pointcut
  • 通知advice：切面扩展业务中的一个操作（方法）；

二、Spring AOP基于XML配置及应用

1.配置Spring AOP依赖

    <dependency>
		  <groupId>org.springframework</groupId>
		  <artifactId>spring-context</artifactId>
		  <version>4.3.9.RELEASE</version>
	</dependency>
		<!--
		 Spring AOP的实现依托于Aspect框架(AOP框架)
		 所以要引用1.8.5有问题 -->
	<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>1.8.9</version>
	</dependency>
	<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.8.9</version>
	</dependency>

2.添加Spring配置文件

  • 向IOC注入核心业务类HelloServiceImpl.java
  • 向IOC注入扩展业务类LoggingAspect.java
    • 增加AOP配置<aop:config>
      • 含切入点配置<aop:pointcut >
      • 含<aop:aspect>....</aop:aspect>含<aop:before method="..." pointcut-ref="..."/>等
<?xml version="1.0" encoding="UTF-8"?>
<beans 
    default-lazy-init="true"
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="  
       http://www.springframework.org/schema/beans   
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd  
       http://www.springframework.org/schema/mvc   
       http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd   
       http://www.springframework.org/schema/tx   
       http://www.springframework.org/schema/tx/spring-tx-4.3.xsd   
       http://www.springframework.org/schema/aop 
       http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
       http://www.springframework.org/schema/util 
       http://www.springframework.org/schema/util/spring-util-4.3.xsd
       http://www.springframework.org/schema/data/jpa 
       http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.3.xsd"> 
   
    <!-- 核心业务对象 -->
    <bean id="helloService"
          class="spring.beans.HelloServiceImpl"/>
<!-- 配置非核心业务对象(日志处理对象)：切面 -->
<bean id="log" 
          class="spring.aop.LoggingAspect"/>
    <!-- AOP配置(切入点，切面) -->  
    <aop:config>
       <!-- 配置切入点(bean,@annotation,within) -->
       <aop:pointcut 
            expression="within(spring.beans.HelloServiceImpl)" 
            id="logPointCut"/>
       <!-- 配置日志处理 -->
       <aop:aspect ref="log" >
           <aop:before method="beforeMethod" 
                       pointcut-ref="logPointCut"/>
           <aop:after  method="afterMethod"
                       pointcut-ref="logPointCut"/>
       </aop:aspect>
    </aop:config>
</beans>

3.Spring AOP应用

  • 业务层接口HelloService--核心业务接口
public interface HelloService {
	 void sayHello(String msg);
}
  • 业务层接口实现类HelloServiceImpl--核心业务实现类
public class HelloServiceImpl implements HelloService {
	public void sayHello(String msg) {
		//假设这条语句是我们系统中的核心业务
		System.out.println(msg);
	}
}
  • 日志处理类LoggingAspect:通过此横切面实现扩展业务
public class LoggingAspect {
	 public void beforeMethod(){
		 System.out.println("method start");
	 }
	 public void afterMethod(){
		 System.out.println("method end");
	 }
}
  • 利用测试类测试效果
public class TestAOP01 {
	private ClassPathXmlApplicationContext ctx;
	@Before
	public void init(){
	    ctx=new ClassPathXmlApplicationContext("spring-configs.xml");
	}
	@Test
	public void testSayHello(){
		HelloService helloService=
        ctx.getBean("helloService",HelloService.class);
		helloService.sayHello("cgb1712");
	}
	@After
	public void destory(){
		ctx.close();
	}
}
  • 以上简单应用的原理分析

三、Spring AOP基于注解配置及应用

1.pom.xml略

2.核心业务订单接口+实现类，这里实现类为展示

public interface OrderService {
	 public void saveOrder();
	 public void deleteOrder();
}

3.时间处理类：作为核心业务功能扩展<横切面>

  • 切面@Aspect  修饰一个AOP横切面对象
  • 切入点@Pointcut("bean(orderService)") 定义本类中的切入点
  • 前置通知@Before 
  • 后置通知@After
@Aspect
@Service
public class TimeAspect {
	@Pointcut("bean(orderService)")
	public void pointcut(){}
	/**增强功能：前置通知(业务方法执行之前执行)*/
	@Before("pointcut()")
    public void begin(){
	  System.out.println("start:"+System.nanoTime());
	}
	/**增强功能：最终通知(业务方法执行最后执行，
	 *无论业务方法是否执行成功，此功能都要执行)*/
	@After("pointcut()")
	public void end(){
	  System.out.println("end:"+System.nanoTime());
	}
}

4.基于注解方式配置AOP实现两种方式

1.基于xml方式配置对注解的应用

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    default-lazy-init="true"
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="  
       http://www.springframework.org/schema/beans   
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd  
       http://www.springframework.org/schema/mvc   
       http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd   
       http://www.springframework.org/schema/tx   
       http://www.springframework.org/schema/tx/spring-tx-4.3.xsd   
       http://www.springframework.org/schema/aop 
       http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
       http://www.springframework.org/schema/util 
       http://www.springframework.org/schema/util/spring-util-4.3.xsd
       http://www.springframework.org/schema/data/jpa 
       http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.3.xsd"> 
   
       <!-- 配置对类组件的扫描 -->
       <context:component-scan base-package="com.spring"/>
       <!-- 启用AOP注解(自动为目标对象创建代理对象) -->
       <aop:aspectj-autoproxy/>
</beans>

2.在类中基于注解方式的配置

@ComponentScan("com.spring.beans")
@EnableAspectJAutoProxy
public class AppConfig {
}

5.利用测试类测试效果

1.基于xml方式注解配置的测试实现：ClassPathXmlApplicationContext初始化

public class TestAOP01 {
	public static void main(String[] args) {
		//1.初始化容器
		ClassPathXmlApplicationContext ctx=
		new ClassPathXmlApplicationContext(
				"applicationContext.xml");
	    //2.获取bean对象
		OrderService os=(OrderService)
		ctx.getBean("orderService", 
				OrderService.class);
		//3.执行业务方法
		os.saveOrder();
		os.deleteOrder();
		//4.释放资源
		ctx.close();
	}
}

2.基于类中注解方式配置的测试实现：AnnotationConfigApplicationContext初始化

public class TestAOP02 {
	public static void main(String[] args) {
		//1.初始化容器对象
		AnnotationConfigApplicationContext ctx=
		new AnnotationConfigApplicationContext(
				AppConfig.class);
		//2.获取Bean对象
		OrderService orderService=
		ctx.getBean("orderService", OrderService.class);
		//3.执行业务
		orderService.saveOrder();
		//orderService.deleteOrder();
		//4.释放资源
		ctx.close();
	}
}

四、Spring AOP切面表达式+切面通知+切面执行顺序

1.切面表达式

指示符作用
bean匹配指定bean id的方法执行
within指定包下类型内的方法执行
@annotation指定注解修饰的方法执行
execution细粒度方法匹配执行具体业务

1.bean应用于类级别，实现粗粒度的控制：

bean("userServiceImpl"))

指定一个类

bean("*ServiceImpl")

指定所有的后缀为service的类

2.within应用于类级别，实现粗粒度的切面表达式定义：

within("aop.service.UserServiceImpl")

指定类，只能指定一个类

within("aop.service.*")

只包括当前目录下的类

within("aop.service..*")

指定当前目录包含所有子目录中的类

3.execution方法级别，细粒度的控制：

语法：execution(返回值类型 包名.类名.方法名(参数列表))

execution(void aop.service.UserServiceImpl.addUser())

匹配方法

execution(void aop.service.PersonServiceImpl.addUser(String))

方法参数必须为字符串

execution(* aop.service..*.*(..))

万能配置

4.@annotaion应用于方法级别，实现细粒度的控制：

@annotation("com.jt.common.anno.RequestLog"))

指定一个需要实现增强功能的方法

2.切面通知

1.在AOP编程中有五种类型的通知：

  1. 前置通知 (@Before) 方法执行之前执行
  2. 返回通知 (@AfterReturning) 方法return之后执行
  3. 异常通知 (@AfterThrowing) 方法出现异常之后执行
  4. 后置通知 (@After) : 又称之为最终通知(finally)
  5. 环绕通知 (@Around) 

2.五种类型可以通过try...catch...finally...来模拟

A.try{    @Before核心业务  @AfterReturning     }catch(Exception e){    ... @AfterThrowing      }finally{      @After         }

B.以上四个一起使用时可以直接用@Around通知替换

3.xml方式通知配置

A.切入点及前置通知，后置通知，返回通知，异常通知，环绕通知的配置

<aop:config>
		<aop:pointcut id="pc"expression="execution(* 
com.company.spring.service..*.*(..))" >
		<aop:aspect ref="loggingAspect">
			<aop:before method="beforeMethod" pointcut-ref="pc"/>
			<aop:after method="afterMethod" pointcut-ref="pc"/>
			<aop:after-returning method="returnMethod"
 pointcut-ref="pc"/>
			<aop:after-throwing method="throwMethod" 
pointcut-ref="pc"/>
		</aop:aspect>
</aop:config>

B.切入点及环绕通知的配置

<aop:config>
		<aop:pointcut id="pc"expression="execution(* 
com.company.spring.service..*.*(..))" >
		<aop:aspect ref="loggingAspect">
			<aop:around method="aroundMethod" pointcut-ref="pc"/>
		</aop:aspect>
</aop:config>

4.注解方式通知配置

A.切入点及前置通知，后置通知，返回通知，异常通知，环绕通知的配置

@Aspect
@Service
public class LogAspect {
       @Pointcut("bean(orderServiceImpl)")
	   public void doLog(){}
		   
	   @Before("doLog()")
	   public void doBefore(){
		   System.out.println("log before");
	   }
	   @After("doLog()")
	   public void doAfter(){
		   System.out.println("log after");
	   }
	   /**核心业务正常结束时执行
	    * 说明：假如有after，先执行after,再执行returning*/
	   @AfterReturning("doLog()")
	   public void doAfterReturning(){
		   System.out.println("log doAfterReturning");
	   }
	   /**核心业务出现异常时执行
                   说明：假如有after，先执行after,再执行Throwing*/
	   @AfterThrowing("doLog()")
	   public void doAfterThrowing(){
		   System.out.println("log doAfterThrowing");
	   }
}

B.切入点及环绕通知

@Component
@Aspect
public class TxManager {
	@Pointcut("execution(com.company.spring.service..*.*(..))")
	public void pointCut() {}
	@Around("pointCut()")
	public Object around(ProceedingJoinPoint joinPoint) 
			throws Throwable{
            try{
			System.out.println("事务开始");
			Object result = joinPoint.proceed();//执行目标方法
			System.out.println("提交事务");
return result;
}catch(Exception e){
System.out.println("回滚事务");
throw e;
}finally{
System.out.println("释放资源");
}
				}
}

5.切面执行顺序配置

实际项目中可能会有多个切面，切面之间的执行可能需要一定的顺序。

A.xml方式配置执行顺序

<aop:config>
		<aop:pointcut id="pc"
		     expression="execution(* 
com.company.spring.service..*.*(..))"/>
		<aop:aspect ref="loggingAspect" order="1">
			<aop:around method="aroundMethod" pointcut-ref="pc"/>
		</aop:aspect>
		<aop:aspect ref="txManager" order="2">
		    <aop:around method="aroundMethod" pointcut-ref="pc"/>
		</aop:aspect>
</aop:config>

B.注解方式配置执行顺序：借助@Order注解

@Order(1)
@Aspect
@Component
public class TxManager {
	@Pointcut("execution(* com.company.spring.service..*.(..))")
	public void pointCut() {}
	@Around("pointCut()")
	public Object around(ProceedingJoinPoint joinPoint) 
			throws Throwable{
			System.out.println("事务开始");
			Object result = joinPoint.proceed();
			System.out.println("事务结束");
			return result;
	}
}

@Order(2)
@Aspect
@Component
public class LoggingAspect {
	@Pointcut("execution(* com.company.spring.service..*.(..))")
	public void pointCut() {}
	@Before("pointCut()")
	public void beforeMethod() {
		System.out.println("beforeMethod");
	}
	@After("pointCut()")
	public void afterMethod() {
		System.out.println("afterMethod");
	}
}

五、AOP相关知识

  • OCP原则（开闭原则）：允许扩展，不允许修改
  • 单一职责原则（一个类或者接口的职责不要太多）
  • Spring AOP配置方式xml和注解
  • Spring AOP通知基本类型
  • Spring AOP为Bean对象创建代理对象代码实现
  • 用JDK代理方式为某类创建代理对象
  • 用CGLIB代理方式为某类创建代理对象（依赖于cglib库）

 

 

 

 

 

 

 

 

 

 

 

 

Spring 4.0 AOP 面向切面Maven测试程序
01-19
Spring 4.0 AOP 面向切面测试程序,涉及通知类型包括前置通知\后置通知\返回通知\异常通知\环绕通知,项目采用Maven搭建!
Spring+Maven学习实验- Spring AOP面向切面编程（一）
weixin_30826761的博客
08-21 362
Spring AOP 即 Aspect-oriented programming，面向切面编程，是作为面向对象编程的一种补充，专门用于处理系统中分布于各个模块（不同方法）中的交叉关注点的问题。简单地说，就是一个拦截器（ interceptor ）拦截一些处理过程。 例如，当一 个method 被执行，Spring AOP 能够劫持正在运行的 method ，在 method 执行前或者...
SSM之Spring AOP
weixin_51018979的博客
10-12 218
Spring AOP概念 1）AOP（Aspect Oriented Programming）是面向切面编程。 就是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 简单说 就是在不改变方法原代码的基础上，对方法进行功能增强 本质上是生成了一个新的类，叫做代理类 （2）AOP对程序的扩展方式采用动态代理的方式. (JDK动态代理和Cglib动态代理两种方式) Spring 动态代理 （1）JDK的动态代理 》Proxy类的方法 Proxy类的静态方法可以创建代理对象 static Obj
Spring切面编程
BadBoyxiaolin的博客
05-08 2236
*** @Description: 操作日志注解*/ @Documented @Target(ElementType . METHOD) // 作用在方法上 @Retention(RetentionPolicy . RUNTIME) // 运行时有效 public @interface Operation {/*** 操作模块/*** 操作类型/*** 操作说明。
SSM框架 --- Spring AOP
weixin_39281866的博客
02-07 833
代理设计模式；Spring AOP相关概念（连接点，切入点，切面，通知等），配置文件方式实现AOP，注解方式实现AOP
maven+ssm整合
12-15
**Spring框架**是企业级Java应用的核心框架，它提供了依赖注入（DI）和面向切面编程（AOP）等核心功能。依赖注入允许开发者在运行时动态地将对象和服务绑定在一起，提高了代码的可测试性和可维护性。面向切面编程则...
maven+SSM框架简单实例(Spring+SpringMVC+Mybatis)
10-19
Spring是一个全面的企业级应用开发框架，提供了诸如IOC（控制反转）和AOP（面向切面编程）等核心特性，使得代码更加模块化和易于测试。在这个实例中，Spring将作为核心框架，负责管理组件（如服务层和DAO层），并...
Maven+SSM示例
03-26
Spring是一个全面的企业级应用开发框架，提供了IOC（控制反转）和AOP（面向切面编程）等功能，简化了Java企业级应用的开发。SpringMVC是Spring的一个模块，专门用于处理Web请求，提供模型-视图-控制器（MVC）架构，...
Maven+SSM整合框架
12-06
Spring是一个全面的后端应用框架，它提供IOC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）等核心特性，简化了Java应用程序的开发。在SSM框架中，Spring负责管理对象的生命...
ssm+maven+shiro
03-29
首先，Spring框架作为基础，它提供了依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）的功能。依赖注入使得组件之间解耦，提高了代码的可测试性和可维护性；而面向切面编程...
使用maven工具完成spring IOC（控制反转）和AOP（面向切面编程）的简单应用
weixin_51872424的博客
06-08 359
使用maven工具完成spring IOC（控制反转）和AOP（面向切面编程）的简单应用
SSM框架之Spring（4）AOP
gyhdxwang的博客
05-09 176
Spring（4）AOP 1、AOP概述 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降...
SpringBoot（十二） 集成切面Aspect
weisian的博客
08-15 897
1、添加maven依赖 <!-- 切面 --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjtools</artifactId> <version>1.8.9</version>...
SSM框架学习-AOP编程
qq_38491310的博客
05-03 290
这里其实主要想记录一下自己遇到的问题，流程倒是蛮简单的。 1.配置 ——2.写aspect 就这两步！ 我先贴上代码，然后说一下我的问题 1 配置 配置主要配置三点 引入AOP依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spri...
Spring-AOP详解
guorenhao的博客
06-08 471
AOP(Aspect Oriented Programming)：面向切面编程，一种编程范式，指导开发者如何组织程序结构。作用：在不惊动原始设计的基础上为其进行功能增强。Spring理念：无入侵式/无侵入式。
SSM框架学习笔记之Spring的AOP
weixin_45068278的博客
10-27 197
Spring的AOP简介 1.什么是AOP？   AOP是AspectOrientedProgramming的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。   AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发效率。 2.AOP的作用及其优势 （1）作用：在程序运行期间，在不修改源码
SSM框架（二）：AOP和事物
最新发布
shendaiyan的博客
11-21 215
导入坐标定义dao接口和实现类定义通知类：定义切入点，绑定切入点与通知的关系//通知类必须配置成Spring管理的bean@Component//设置当前类为切面类类@Aspect//设置切入点，要求配置在方法上方//设置在切入点pt()的前面运行当前操作（前置通知）开启Spring对AOP注解驱动的支持//开启注解开发AOP功能在业务层接口的方法或者接口类（表示里面所有方法都事务管理）上添加事务管理注解/*** 转账操作* @param out 传出方。
SSM框架
举目沧桑的博客
07-26 1805
Spring的核心容器是其他模块建立的基础，由Beans模块、Core核心模块、Context上下文模块和SpEL表达式语言模块组成，没有这些核心容器，也不可能有AOP、Web等上层的功能。Spring的Web层包括Web、Servlet、WebSocket和Portlet组件，具体介绍如下。数据访问／集成层包括JDBC、ORM、OXM、JMS和Transactions模块，具体介绍如下。.....................
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值