Spring AOP

最新推荐文章于 2021-08-08 19:11:13 发布
最新推荐文章于 2021-08-08 19:11:13 发布
阅读量366 收藏
点赞数
分类专栏： java 文章标签： java

AOP(Aspect Oriented Programming，面向切面编程)是Spring框架的一个重要特征
Spring推荐使用接口编程
Spring提供三种拦截器：方法前拦截器、返回后拦截器、异常抛出拦截器

拦截器定义

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //Service接口  
  2. public interface IAopService{  
  3.     public void withAop() throws Exception;         //将会被拦截  
  4.     public void withoutAop() throws Exception;      //不会被拦截  
  5. }  
  6.   
  7. public class AopServiceImpl implements IAopService{  
  8.     private String name;  
  9.     public void withAop() throws Exception{  
  10.         System.out.println("有AOP的函数运行。name："+name);  
  11.         if(name.trim().length() == 0){  
  12.             throw new AccountException("name属性不能为空");  
  13.         }  
  14.     }  
  15.   
  16.     public void withoutAop() throws Exception{  
  17.             System.out.println("没有AOP的函数运行。");  
  18.     }  
  19.   
  20.     public void setName(String name){  
  21.         this.name = name;  
  22.     }  
  23.   
  24.     public String getName(){  
  25.         return this.name;  
  26.     }  
  27. }  
//Service接口
public interface IAopService{
	public void withAop() throws Exception;			//将会被拦截
	public void withoutAop() throws Exception;		//不会被拦截
}

public class AopServiceImpl implements IAopService{
	private String name;
	public void withAop() throws Exception{
		System.out.println("有AOP的函数运行。name："+name);
		if(name.trim().length() == 0){
			throw new AccountException("name属性不能为空");
		}
	}

	public void withoutAop() throws Exception{
			System.out.println("没有AOP的函数运行。");
	}

	public void setName(String name){
		this.name = name;
	}

	public String getName(){
		return this.name;
	}
}


[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //方法前拦截器，检查name是否为空  
  2. import  org.springframework.aop.MethodBeforeAdvice;  
  3. public class MethodBeforeInterceptor implements MethodBeforeAdvice{  
  4.     //调用对象的方法前执行该方法  
  5.     //参数分别为被调用的方法、被调用方法的参数、对象  
  6.     public void before(Method method,Object [] args,Object instance) throws Throwable{  
  7.         System.out.println("即将执行方法："+method.getName());  
  8.         //  
  9.         if(instance instanceof AopServiceImpl){  
  10.             String name = ((AopServiceImpl)instance).getName();  
  11.             if(name == null){  
  12.                 throw new NullPointerException("name不能为空");  
  13.             }  
  14.         }  
  15.     }  
  16.           
  17. }  
//方法前拦截器，检查name是否为空
import  org.springframework.aop.MethodBeforeAdvice;
public class MethodBeforeInterceptor implements MethodBeforeAdvice{
	//调用对象的方法前执行该方法
	//参数分别为被调用的方法、被调用方法的参数、对象
	public void before(Method method,Object [] args,Object instance) throws Throwable{
		System.out.println("即将执行方法："+method.getName());
		//
		if(instance instanceof AopServiceImpl){
			String name = ((AopServiceImpl)instance).getName();
			if(name == null){
				throw new NullPointerException("name不能为空");
			}
		}
	}
		
}


[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //返回后拦截器  
  2. import  org.springframework.aop.AfterReturningAdvice;  
  3. public class MethodAfterInteceptor implements AfterReturningAdvice{  
  4.     //参数分别为方法返回值、被调用方法、方法参数、被拦截的对象  
  5.     public void afterReturning(Object value,Method method,Object [] args,Object instance) throws Throwable{  
  6.                 System.out.println("方法："+method.getName()+"执行完毕，返回值为："+value);  
  7.     }  
  8.       
  9. }  
//返回后拦截器
import  org.springframework.aop.AfterReturningAdvice;
public class MethodAfterInteceptor implements AfterReturningAdvice{
	//参数分别为方法返回值、被调用方法、方法参数、被拦截的对象
	public void afterReturning(Object value,Method method,Object [] args,Object instance) throws Throwable{
				System.out.println("方法："+method.getName()+"执行完毕，返回值为："+value);
	}
	
}


[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //异常拦截器捕获异常  
  2. import  org.springframework.aop.ThrowAdvice;  
  3. public class ThrowsInterceptor implements ThrowAdvice{  
  4.     //参数分别为被调用的方法、方法参数、对象实例、抛出的异常  
  5.     //前三个参数可以省略，第四个参数是必须的，这样设计是为了使开发者灵活地定义多个方法捕获各种不同的异常  
  6.     public void afterThrowing(Method method,Object [] args,Object instance,AccountException ex) throws Throwable {  
  7.         System.out.println("方法："+method.getName()+"抛出了异常："+ex);  
  8.     }  
  9.   
  10.     public void afterThrowing(NullPointerException ex) throws Throwable {  
  11.         System.out.println("抛出了异常："+ex);  
  12.     }  
  13.   
  14. }  
//异常拦截器捕获异常
import  org.springframework.aop.ThrowAdvice;
public class ThrowsInterceptor implements ThrowAdvice{
	//参数分别为被调用的方法、方法参数、对象实例、抛出的异常
	//前三个参数可以省略，第四个参数是必须的，这样设计是为了使开发者灵活地定义多个方法捕获各种不同的异常
	public void afterThrowing(Method method,Object [] args,Object instance,AccountException ex) throws Throwable {
		System.out.println("方法："+method.getName()+"抛出了异常："+ex);
	}

	public void afterThrowing(NullPointerException ex) throws Throwable {
		System.out.println("抛出了异常："+ex);
	}

}


拦截器配置

Spring无法将Service的实现类与拦截器直接组装，因为没有对应的setter、getter方法。安装时借助的是Spring的代理类，把拦截器安装到NameMatchMethodPointcutAdvisor中，把自动以的Service安装到ProxyFactoryBean中，然后组装到一块

[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <!-- 方法前拦截器MethodBeforeInterceptor安装到NameMatchMethodPointcutAdvisor中 -->  
  2. <bean id="aopMethodBeforeInterceptor" class="org.springframework.aop.support. NameMatchMethodPointcutAdvisor">  
  3.     <!--  拦截器的实现类-->  
  4.     <property name="advice">  
  5.         <bean class="com.clf.spring. MethodBeforeInterceptor">  
  6.     </property>  
  7.     <!--  欲拦截的方法名-->  
  8.     <property name="mappedName" value="withAop">  </property>  
  9. </bean>  
  10.   
  11. <!-- 类似的方式配置返回后前拦截器MethodAfterInteceptor -->  
  12. <bean id="aopMethodAfterInterceptor" class="org.springframework.aop.support. NameMatchMethodPointcutAdvisor">  
  13.     <property name="advice">  
  14.         <bean class="com.clf.spring. MethodAfterInteceptor">  
  15.     </property>  
  16.     <property name="mappedName" value="withAop">  </property>  
  17. </bean>  
  18.   
  19. <!-- 类似的方式配置异常前拦截器MethodAfterInteceptor -->  
  20. <bean id="aopThrowsInterceptor" class="org.springframework.aop.support. NameMatchMethodPointcutAdvisor">  
  21.     <property name="advice">  
  22.         <bean class="com.clf.spring. ThrowsInterceptor">  
  23.     </property>  
  24.     <property name="mappedName" value="withoutAop">   </property>  
  25. </bean>  
  26.   
  27. <!-- Service实现类，安装到ProxyFactoryBean -->  
  28. <bean id="aopService" class="org.springframework.aop.ProxyFactoryBean">  
  29.     <!-- 安装拦截器-->  
  30.     <property name="interceptorNames">  
  31.         <list>  
  32.             <value>aopMethodBeforeInterceptor</value>  
  33.             <value>aopMethodAfterInterceptor</value>  
  34.             <value>aopThrowsInterceptor</value>  
  35.         </list>  
  36.     </property>  
  37.     <!—被拦截的对象-->  
  38.     <property name="target">  
  39.         <bean class="com.clf.spring.AopServiceImpl">  
  40.             <property name="name" value="HelloSpring"></property>  
  41.         </bean>  
  42.     </property>  
  43. </bean>  
<!-- 方法前拦截器MethodBeforeInterceptor安装到NameMatchMethodPointcutAdvisor中 -->
<bean id="aopMethodBeforeInterceptor" class="org.springframework.aop.support. NameMatchMethodPointcutAdvisor">
	<!--  拦截器的实现类-->
	<property name="advice">
		<bean class="com.clf.spring. MethodBeforeInterceptor">
	</property>
	<!--  欲拦截的方法名-->
	<property name="mappedName" value="withAop"> 	</property>
</bean>

<!-- 类似的方式配置返回后前拦截器MethodAfterInteceptor -->
<bean id="aopMethodAfterInterceptor" class="org.springframework.aop.support. NameMatchMethodPointcutAdvisor">
	<property name="advice">
		<bean class="com.clf.spring. MethodAfterInteceptor">
	</property>
	<property name="mappedName" value="withAop"> 	</property>
</bean>

<!-- 类似的方式配置异常前拦截器MethodAfterInteceptor -->
<bean id="aopThrowsInterceptor" class="org.springframework.aop.support. NameMatchMethodPointcutAdvisor">
	<property name="advice">
		<bean class="com.clf.spring. ThrowsInterceptor">
	</property>
	<property name="mappedName" value="withoutAop"> 	</property>
</bean>

<!-- Service实现类，安装到ProxyFactoryBean -->
<bean id="aopService" class="org.springframework.aop.ProxyFactoryBean">
	<!-- 安装拦截器-->
	<property name="interceptorNames">
		<list>
			<value>aopMethodBeforeInterceptor</value>
			<value>aopMethodAfterInterceptor</value>
			<value>aopThrowsInterceptor</value>
		</list>
	</property>
	<!—被拦截的对象-->
	<property name="target">
		<bean class="com.clf.spring.AopServiceImpl">
			<property name="name" value="HelloSpring"></property>
		</bean>
	</property>
</bean>


AOP相关概念

切面Aspect
在本例中，方法withAop()、withoutAop()中都有一些代码，这些代码可以看做是AOP中的切面，可以将切面理解为模块
通知Advisor
本例的三个拦截器都是实现自某个接口，从类名上看就知道三个拦截器都是AOP中的通知。一旦Spring符合条件，就会派发出通知，即一些需要执行的代码，能实现某种功能
切入点Pointcut
在配置拦截器时，XML中只配置了withAop()方法使用拦截器，而withoutAop()方法没有配置拦截器，这种配置是借助于org.springframework.aop.support. NameMatchMethodPointcutAdvisor完成的。这就是一个切入点，配置时可以使用通配符。该类明上也带有Advisor是因为它也是用通知实现的

简单地说，切入点负责往什么地方插入代码，而通知负责插入什么代码
Spring提供灵活的切入点配置，例如使用正则表达式
[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <bean id="advisorTest" class="org.springframework.aop.support.RegexMethodPointcutAdvisor">  
  2.     <property name="interceptor">  
  3.         <ref local="someInterceptor">  
  4.     </property>  
  5.     <property name="pattern">  
  6.         <list>  
  7.             <value>.*get*</value>  
  8.             <value>.*set*</value>  
  9.         </list>  
  10.     </property>  
  11. </bean>  
LLYJ666666
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring AOP 模块概述
JAVA上尉
04-06 475
概述AOP从功能的角度来讲，可能看作OOP编程方式的一种补充，提供了一种不同的代码或者系统组织方式。OOP中的核心概念是Class，而在AOP中则是Aspect。spir...
Spring的AOP模块
KevinLee的博客
04-16 2443
概述什么是AOP？AOP（Aspect Oriented Programming，面向切面编程）是Spring另一个重要特征。AOP把一个业务流程分成几个部分，例如：日志记录、权限检查、业务处理等，然后把它们组装成完整的业务流程。每个部分被称为切面(Aspect)或者，关注点。与OOP进行比较？在OOP(Object Oriented Programming)中，关键单元模块度是类，而AOP中是方面
Spring【AOP模块】就是这么简单
weixin_34375054的博客
03-14 152
前言 到目前为止，已经简单学习了Spring的Core模块、....于是我们就开启了Spring的AOP模块了...在讲解AOP模块之前，首先我们来讲解一下cglib代理、以及怎么手动实现AOP编程 cglib代理 在讲解cglib之前，首先我们来回顾一下静态代理和动态代理....我之前就写过了静态代理、动态代理的博文：blog.csdn.net/hon_3y/arti… 由于静态代理需要实现目标...
Spring(4)——面向切面编程（AOP模块）
我没有三颗心脏的博客
04-12 411
Spring AOP 简介 如果说 IoC 是 Spring 的核心，那么面向切面编程就是 Spring 最为重要的功能之一了，在数据库事务中切面编程被广泛使用。 AOP 即 Aspect Oriented Program 面向切面编程 首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。 - 所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务 - 所...
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
Spring源码最难问题：当Spring AOP遇上循环依赖.docx
06-15
Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...
Spring aop失效的几种解决方案
08-19
Spring AOP失效解决方案详解 作为一名IT行业大师，我将从给定的文件中生成相关知识点，主要介绍Spring AOP失效的几种解决方案。 标题解释 Spring AOP失效的几种解决方案是指在使用Spring框架时，Aspect Oriented ...
spring AOP 引入jar包，spring IOC 引入Jar包
09-07
Spring AOP 和 Spring IOC 是 Spring 框架的两个核心组件，它们对于任何基于 Java 的企业级应用开发都至关重要。Spring AOP（面向切面编程）允许开发者在不修改源代码的情况下，通过“切面”来插入新的行为或增强已...
Spring【AOP模块】就这么简单
WantFlyDaCheng的博客
08-13 292
前言到目前为止，已经简单学习了Spring的Core模块….于是我们就开启了Spring的AOP模块了…在讲解AOP模块之前，首先我们来讲解一下cglib代理、以及怎么手...
Spring-Aop模块
ZP_2019_07_18的博客
03-27 168
aop
Spring AOP模块
一直在追逐，一直在妥协
01-21 844
1.Aop把一个业务流程分为几个部分，每个部分单独处理，然后把它们组装成完整的业务流程。每个部分都被称为切面或者关注点 2.贴上Aop使用拦截器拦截方法的一个例子;    a)Service接口： package com.spring.inter; public interface IAopService { //定义两个方法 public void withAop() throws
解释AOP模块
weixin_45712075的博客
05-30 680
解释AOP模块 AOP是Aspect Oriented Programming缩写，面向切面编程，他使程序员可以更好的将本不应该彼此粘合在一起的功能分开，AOP是一种思想主要作用就是对代码段进行增强处理，目的降低代码的耦合性，从而达到易维护和重用的目的。其设计思想来源于代理模式，在此基础上进行了封装扩展，最终形成一些功能强大的aop框架，如AspectJ简单的说：就是在不改变原程序的基础上为代码段增加新功能，如日志输出，启动数据库事务等，下图可呈现出运行机制： 在代理模式中可以为该对象设置一个代理对象，代理
Spring学习路之初级AOP模块
Burnup_110的博客
08-15 259
以下内容集成到了GitHub项目中，有兴趣的朋友可以看一下GitHub https://github.com/HeShuai-GitHub/springDemo.git 随手记 ideaj中不可以建立和java关键字名字等同的包名 一、spring依赖引入（Maven） <!--spring依赖 start--> <!--这个jar文件包含Spring 框架基本的核心工具类。Spring 其它组件要都要使用到这个包里的类，是其它组件的基本核心--> <
Spring七大模块之AOP
qq_21954477的博客
09-13 339
AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理
Spring核心模块:Aop的解释以及应用
weixin_46300935的博客
06-29 1081
AOP AOP简介 OOP开发思路 转存失败重新上传取消转存失败重新上传取消 AOP开发思想 转存失败重新上传取消转存失败重新上传取消 AOP概念 AOP(Aspect Oriented Programing)面向切面编程，一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构 AOP弥补了OOP的不足，基于OOP基础之上进行横向开发 uOOP规定程序开发以类为主体模型，一切围绕对象进行，完成某个任务先构建模型 uAOP程序开发主要关注基于OO
Srping全注解开发---AOP模块
m0_53157173的博客
08-08 298
AOP模块回顾五个通知注解使用演示1.切面类（@Aspect）业务逻辑类在配置类中将切面类和业务逻辑类都加入到容器中切记给配置类上加上@EnableAspectJAutoProxy，开启基于注解的aop模式测试注意:spring中很多Enablexxx都是开启某一项功能在切面类的方法中获取切入方法的相关信息joinpoint必须出现在方法参数的首位JoinPoint对象详细使用方法，参考下面这篇文章AOP注解开发三部曲AOP原理剖析部分创建和注册AnnotationAwareAspectJAutoProxy
spring aop
最新发布
09-11
Spring AOP（Aspect-Oriented Programming）是Spring框架中的一个重要特性，它提供了一种在应用程序中实现横切关注点（cross-cutting concerns）的方法。所谓横切关注点，指的是那些在应用程序中散布于各个模块之中、具有共同逻辑的行为，例如日志记录、事务管理、安全检查等。 通过使用Spring AOP，开发者可以将这些横切关注点从业务逻辑代码中剥离出来，以便于在不同模块中重复使用，并且能够更好地实现模块化开发。Spring AOP基于AOP的思想，通过在运行时动态地将横切关注点织入到目标对象的方法中，实现了与业务代码的解耦。 Spring AOP主要通过定义切面（Aspect）和连接点（Join Point）来实现，其中切面定义了横切关注点的逻辑，而连接点则指定了在目标对象中哪些方法需要织入切面逻辑。Spring AOP支持多种类型的通知（Advice），包括前置通知（Before Advice）、后置通知（After Advice）、异常通知（After-Throwing Advice）、返回通知（After-Returning Advice）和环绕通知（Around Advice），开发者可以根据需要选择合适的通知类型。 总的来说，Spring AOP是Spring框架中的一个重要特性，它通过在运行时动态地将横切关注点织入到目标对象的方法中，实现了对应用程序中横切关注点的解耦，提高了代码的可维护性和可重用性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值