spring aop 配置

最新推荐文章于 2024-10-23 13:10:14 发布
最新推荐文章于 2024-10-23 13:10:14 发布 · 107 阅读 · 0
文章标签：

#AOP #Spring #Bean #XML #编程

本文通过实战案例介绍了Spring AOP的基础概念与应用，包括Advice、Pointcut和Advisor等核心组件的实现方式，并演示了如何使用Spring AOP进行前置通知、后置通知、环绕通知和异常通知。
Spring -Aop入门
 
AOP全名Aspect-oriented programming。Spring framework是很有前途的AOP技术。作为一种非侵略性的，轻型的AOP framework，你无需使用预编译器或其他的元标签，便可以在Java程序中使用它。这意味着开发团队里只需一人要对付AOP framework，其他人还是像往常一样编程。
关键性概念：
1)          Advice 是代码的具体实现，例如一个实现日志记录的代码。
2)          Pointcut 是在将Advice 插入到程序的条件。
3)           advisor是把pointcut和advice的组合在一起装配器。
 
图例：
你的程序可能如上，现在要在三个流程上同时加入日志控制和权限控制，如下：
 

 你的程序可能如上，现在要在三个流程上同时加入日志控制和权限控制，如下：

 

         其中拿日志为例，日志控制和流程之间的穿插点处叫做连接点（Joinpoint），而Advice就是我们日志处理的具体代码，Pointcut就是定义一个规则，对三个和业务有关的连接点进行过滤和匹配（例如我们对于业务1不做日志处理）。Advisor就是将符合的规则的剩下的两个连接点和具体的日志记录代码组合在一起。
 
三. Spring-Aop 前置通知、后置通知、环绕通知、异常通知实现
 
我以Spring In Action 提供的例子进行二次改造，完成我们自己的流程。业务流程很简单，顾客到商店买东西，店员根据顾客的需要给于顾客提供服务。实现方法前插入，方法后插入，环绕，异常四种。
 
       代码：
          建立一个用户类；
public class Customer {
     private String name = "悠~游!";
     public String getName() {
          return name;
     }
}
三个产品
public class Cheese {
   public String toString(){
         return "奶酪!";
   }
}
public class Pepper {
     public String toString(){
          return "胡椒粉!";
     }
}
public class Squish {
     public String toString(){
          return "果酱!";
     }
}
          建立一个接口；
public interface KwikEMart {
     Squish buySquish(Customer customer) throws KwikEMartException;
     Pepper buyPepper(Customer customer) throws KwikEMartException;
     Cheese buyCheese(Customer customer) throws KwikEMartException;
}
 
实现这个接口，我们实现三个方法，买奶酪，买胡椒粉，买果酱；
public class ApuKwikEMart implements KwikEMart {
     private boolean cheeseIsEmpty = false;
 
     private boolean pepperIsEmpty = false;
 
     private boolean squishIsEmpty = false;
 
     public Cheese buyCheese(Customer customer) throws NoMoreCheeseException{
 
          if (cheeseIsEmpty) {
               throw new NoMoreCheeseException();
          }
 
          Cheese s = new Cheese();
          System.out.println("--我想买:" + s);
          return s;
 
     }
 
     public Pepper buyPepper(Customer customer) throws NoMorePepperException{
 
          if (pepperIsEmpty) {
               throw new NoMorePepperException();
          }
 
          Pepper s = new Pepper();
          System.out.println("--我想买:" + s);
          return s;
 
     }
 
     public Squish buySquish(Customer customer) throws NoMoreSquishException{
 
          if (squishIsEmpty) {
               throw new NoMoreSquishException();
          }
 
          Squish s = new Squish();
          System.out.println("--我想买:" + s);
          return s;
 
     }
 
     public void setCheeseIsEmpty(boolean cheeseIsEmpty) {
          this.cheeseIsEmpty = cheeseIsEmpty;
     }
 
     public void setPepperIsEmpty(boolean pepperIsEmpty) {
          this.pepperIsEmpty = pepperIsEmpty;
     }
 
     public void setSquishIsEmpty(boolean squishIsEmpty) {
          this.squishIsEmpty = squishIsEmpty;
     }
 
}
环绕通知的实现，必须实现invoke方法，通过调用invoke.proceed()手工调用对象方法：
public class OnePerCustomerInterceptor implements MethodInterceptor {
    
     private Set customers=new HashSet();
 
     public Object invoke(MethodInvocation invoke) throws Throwable {
         
          Customer customer=(Customer)invoke.getArguments()[0];
          if(customers.contains(customer)){
               throw new KwikEMartException("One per customer.");
          }
         
          System.out.println("店员:"+customer.getName() + " ,Can I help you ?");
          Object squishee=invoke.proceed(); //手工调用对象方法;
          System.out.println("店员:OK! " + customer.getName() + ".give you! " );
         
          customers.add(squishee);
 
          return squishee;
     }
}
前置通知的实现；
public class WelcomeAdvice implements MethodBeforeAdvice {
 
     public void before(Method method, Object[] args, Object target) throws Throwable {
         
          Customer customer = (Customer) args[0];
          System.out.println("店员::Hello " + customer.getName() + " . How are you doing?");
 
     }
}
public class Customer {
     private String name = "悠~游!";
     public String getName() {
          return name;
     }
}
后置通知实现；
public class ThankYouAdvice implements AfterReturningAdvice {
 
     public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
         
          Customer customer = (Customer) args[0];
          System.out.println("店员:Thank you " + customer.getName() + " . Come again! " );
 
     }
}
系统异常处理通知实现；
public class KwikEmartExceptionAdvice implements ThrowsAdvice {
 
     public void afterThrowing(NoMoreSquishException e) {
          System.out.println("系统:NoMoreSquisheesException异常截获了: " + e.getMessage());
     }
     public void afterThrowing(NoMoreCheeseException e) {
          System.out.println("系统:NoMoreCheeseException异常截获了: " + e.getMessage());
     }
     public void afterThrowing(NoMorePepperException e) {
          System.out.println("系统:NoMorePepperException异常截获了: " + e.getMessage());
     }
}
自定义的异常接口；
public class KwikEMartException extends Exception {
 
     private static final long serialVersionUID = -3962577696326432053L;
 
     String retValue = "KwikEMartException 异常!";
 
     public KwikEMartException(String name) {
          retValue = name;
     }
     public KwikEMartException() {
 
     }
     public String getMessage() {
          return retValue;
     }
 
}
没有更多的奶酪异常；
public class NoMoreCheeseException extends KwikEMartException {
     private static final long serialVersionUID = -3961123496322432053L;
 
     String retValue = "NoMoreCheeseException 异常!";
 
     public NoMoreCheeseException() {
          super();
     }
 
     public NoMoreCheeseException(String name) {
          super(name);
     }
 
     public String getMessage() {
 
          return retValue;
     }
}
没有更多的胡椒粉异常；
public class NoMorePepperException extends KwikEMartException {
     private static final long serialVersionUID = -3961234696322432053L;
 
     String retValue = "NoMorePepperException 异常!";
 
     public NoMorePepperException() {
          super();
     }
 
     public NoMorePepperException(String name) {
          super(name);
     }
 
     public String getMessage() {
 
          return retValue;
     }
}
没有更多的果酱异常；
public class NoMoreSquishException extends KwikEMartException {
     private static final long serialVersionUID = -3121234696322432053L;
 
     String retValue = "NoMoreSquishException 异常!";
 
     public NoMoreSquishException() {
          super();
     }
 
     public NoMoreSquishException(String name) {
          super(name);
     }
 
     public String getMessage() {
 
          return retValue;
     }
}
运行实例类；
         
public class RunDemo {
 
               public static void kwikEMart() {
 
               ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("demo/kwikemart.xml");
 
                    //如果你想通过类来引用这个的话,就要用到CGLIB.jar了,同时在代理工厂里面设置:
                    //<property name="proxyTargetClass" value="true" />
                    KwikEMart akem = (KwikEMart) context.getBean("kwikEMart");
    
                    try {
                         akem.buySquish(new Customer());
                         akem.buyPepper(new Customer());
                         akem.buyCheese(new Customer());
                    } catch (KwikEMartException e) {
                         //异常已经被截获了,不信你看控制台!~;
                    }
               }
 
               public static void main(String[] args) {
                    kwikEMart();
               }
}
     Xml文件配置：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
 
 
<beans>
     <bean id="kwikEMartTarget" class="demo.ApuKwikEMart">
          <!--
               把这里注释去掉的话,程序调用的时候测试异常通知;
               <property name="cheeseIsEmpty">
                    <value>true</value>
               </property>
               <property name="pepperIsEmpty">
                    <value>true</value>
               </property>
               <property name="squishIsEmpty">
                    <value>true</value>
               </property>
          -->
     </bean>
 
     <!-- 方法调用前通知 -->
     <bean id="welcomeAdvice" class="demo.advice.WelcomeAdvice" />
     <!-- 方法调用后通知 -->
     <bean id="thankYouAdvice" class="demo.advice.ThankYouAdvice" />
     <!-- 环绕调用通知 -->
     <bean id="onePerCustomerInterceptor" class="demo.advice.OnePerCustomerInterceptor" />
     <!-- 异常调用通知 -->
     <bean id="kwikEmartExceptionAdvice" class="demo.advice.KwikEmartExceptionAdvice" />
    
     <bean id="kwikEMart" class="org.springframework.aop.framework.ProxyFactoryBean">
          <property name="proxyInterfaces" value="demo.KwikEMart" />
          <property name="interceptorNames">
               <list>
                   
                         <value>welcomeAdvice</value>
                         <value>thankYouAdvice</value>
                         <value>onePerCustomerInterceptor</value>
                         <value>kwikEmartExceptionAdvice</value>
                   
               </list>
          </property>
          <property name="target">
               <ref bean="kwikEMartTarget" />
          </property>
     </bean>
 
</beans>
     这个例子东西很多，不过每个类的代码都不大。如果你对org.springframework.aop.framework.ProxyFactoryBean不是很了解的话可以看我下篇尾处的介绍。读清楚之后，我们运行RunDemo 类，查看控制台结果，如下：
 
店员::Hello 悠~游! . How are you doing?
店员:悠~游! ,Can I help you ?
--我想买:果酱!
店员:OK! 悠~游!.give you!
店员:Thank you 悠~游! . Come again!
店员::Hello 悠~游! . How are you doing?
店员:悠~游! ,Can I help you ?
--我想买:胡椒粉!
店员:OK! 悠~游!.give you!
店员:Thank you 悠~游! . Come again!
店员::Hello 悠~游! . How are you doing?
店员:悠~游! ,Can I help you ?
--我想买:奶酪!
店员:OK! 悠~游!.give you!
店员:Thank you 悠~游! . Come again!
 
    我们将kwikEMartTarget里面的注释去掉，测试异常实现，如下：
    
店员::Hello 悠~游! . How are you doing?
店员:悠~游! ,Can I help you ?
系统:NoMoreSquisheesException异常截获了: NoMoreSquishException 异常!
     好好理解一下，我就不废话了，我们进行下一节。
 
 
 
四. Spring-Aop 之Pointcut＋advice＋Advisor 实现
 
我们修改我们的xml文档后如下：
 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
 
<beans>
 
     <bean id="kwikEMartTarget" class="demo.ApuKwikEMart"></bean>
 
     <!-- 环绕调用通知 -->
     <bean id="onePerCustomerInterceptor" class="demo.advice.OnePerCustomerInterceptor" />
 
     <!-- 使用NameMatchMethodPointcut -->
     <bean id="nameMatchfilterPointcut" class="org.springframework.aop.support.NameMatchMethodPointcut">
          <property name="mappedName">
               <!--
                    buy.* 以buy开头的方法;
               -->
               <value>buy*</value>
          </property>
     </bean>
 
     <!-- 使用Perl5RegexpMethodPointcut -->
     <bean id="regexpFilterPointcut" class="org.springframework.aop.support.Perl5RegexpMethodPointcut">
          <property name="pattern">
               <!--
                    .*buy.+ 以buy开头的方法;
                    .*buyS.+ 以buyS开头的方法;
               -->
               <value>.*suy.+</value>
          </property>
     </bean>
 
     <bean id="runDemofilterPointcutAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
          <property name="pointcut">
               <ref bean="nameMatchfilterPointcut" />
          </property>
          <property name="advice">
               <ref bean="onePerCustomerInterceptor" />
          </property>
     </bean>
     <bean id="kwikEMart" class="org.springframework.aop.framework.ProxyFactoryBean">
          <property name="proxyInterfaces" value="demo.KwikEMart" />
          <property name="interceptorNames">
               <list>
                    <value>runDemofilterPointcutAdvisor</value>
               </list>
          </property>
          <property name="target">
               <ref bean="kwikEMartTarget" />
          </property>
     </bean>
 
</beans>
 
运行，结果如下：
店员:悠~游! ,Can I help you ?
--我想买:果酱!
店员:OK! 悠~游!.give you!
店员:悠~游! ,Can I help you ?
--我想买:胡椒粉!
店员:OK! 悠~游!.give you!
店员:悠~游! ,Can I help you ?
--我想买:奶酪!
        店员:OK! 悠~游!.give you!
 
在这里简单说明一下xml文档：nameMatchfilterPointcut和regexpFilterPointcut 是我们自己定义好规则的Pointcut。nameMatchfilterPointcut 根据mappedName来设置过滤规则, regexpFilterPointcut则是用pattern来设置过滤规则。runDemofilterPointcutAdvisor则将我们的Pointcut和advice组合在一起。
读者可以自己修改runDemofilterPointcutAdvisor的pointcut来切换不同的Pointcut。如果需要RegexpMethodPointcut 的子类的实现，必须要oro包支持。（注：RegexpMethodPointcut有俩个子类的实现，JdkRegexpMethodPointcut和Perl5RegexpMethodPointcut）。
     但是，如果我们想让我们的Advisor同时实现多个Pointcut＋advice怎么办呢？利用Spring In Action里面的实例，我们来自己实现我们的Pointcut。
 
    代码：
 
 
public class MyUnionPointcut implements Pointcut {
    
     private Pointcut delegate;
 
     public ClassFilter getClassFilter() {
          return getDelegate().getClassFilter();
     }
 
     private Pointcut getDelegate() {
          if (delegate == null) {
             
Spring AOP配置（注解+java配置类）
Mr_Zerone的博客
03-07 955
文末有本篇文章的项目源码文件可供下载学习AOP（Aspect-Oriented Programming）是一种编程思维，它将程序中的业务逻辑和横切关注点（cross-cutting concerns）进行分离。横切关注点是指那些通常会在软件系统的多个部分重复出现的功能，比如日志记录、性能监测、安全控制等，这些与核心业务代码无关的非核心业务代码主要是通过AOP思维来去解决。
SpringAOP配置，是基于java配置类和注解的方式。
03-05
基于java配置类的SpringAOP配置通常涉及创建一个配置类，并使用特定的注解来定义切面（Aspect）、通知（Advice）、连接点（Join Point）等AOP概念。比如，@Configuration注解用于标记一个类作为配置类，@Aspect注解...
SpringAOP配置详解
成长，编程，生活
03-23 2590
面向切面编程，Java的JDK动态代理与CGLib动态代理，基于XML的AOP配置，基于注解的AOP配置，切入点表达式说明
Spring AOP配置过程详解
YonminMa的博客
07-02 1912
文章目录AOP中的专业术语AOP整体配置过程项目中的角色分工基于XML的AOP配置基于注解的AOP配置保留bean.xml情况删除bean.xml情况 AOP中的专业术语 Joinpoint（连接点）：连接点是指哪些被拦截到的点，在spring中，这些点指的是方法，因为spring只支持方法类型的连接点 Pointcut（切入点）：指我们要对哪些连接点进行拦截的定义 Advice（通知/增强）：拦截到连接点之后要做的事情 通知的类型：前置通知（在调用invoke方法前），后置通知（在调用invoke方法后）
Spring AOP 详解
2301_80035594的博客
10-19 6550
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
spring AOP配置切点及基础使用
oak_javaLearner的博客
07-20 1385
配置切点： //自定义注解方式 @Pointcut("@annotation(com.example.aop_test.annotation.OperationAnnonation)") public void pointcut(){ } //粒度精确至方法级别方式 @Pointcut("execution(public * com.example.aop_test.controller.TestController.test2(..))") public void Gia
spring配置AOP
weixin_52831324的博客
11-30 982
Aop中有三种主要通知方式，分别为前置通知--@Before("")，后置通知--@After("")，环绕通知@Around("")，execution(* com.Aop.service.dao.save() 就是选择某个方法注入切面aop。如图所示，我在Aop包下创建了AopMethod的Aop操作类。如图所示，创建service接口层和impl实现类层。第三步，创建service层，用于测试Aop操作类。Aop操作类中，需注入切入点，即。第二步，创建AOP的方法类。第四步，书写Aop操作类。
【Spring篇】Spring的Aop详解
m0_74202856的博客
10-23 5071
一个有趣爱睡觉的intp，期待和更多人分享自己所学知识的真诚大学生。
Spring AOP - 配置文件方式实现
xujinwei_gingko的专栏
09-22 1301
1、配置文件：applicationContext.xml。
Spring AOP配置通配符
zsg88的专栏
03-22 5782
Spring AOP 用户可能会经常使用 execution切入点指示符。执行表达式的格式如下： execution（modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern（param-pattern） throws-pattern?） 除了返回类型模式（上面代码片断中的ret-t
Spring-AOP配置(XML)
汤键的博客
09-17 3477
Spring-AOP配置(XML)
springAOP配置动态代理实现
03-28
2. **注解配置**：Spring 2.5引入了基于注解的AOP配置，可以在切面类上使用@Aspect注解，@Before、@After、@AfterReturning、@AfterThrowing和@Around定义通知，@Pointcut定义切点。例如： ```java @Aspect ...
springAop的配置实现
05-25
在Spring XML配置文件中，我们可以定义以下元素来实现AOP配置： - `<aop:config>`：声明AOP配置。 - `<aop:pointcut>`：定义切入点表达式，例如`execution(* com.example.service.*.*(..))`表示匹配...
Spring AOP配置与管理
04-22
**Spring AOP配置与管理** 在Java开发中，Spring框架以其强大的功能和灵活性深受开发者喜爱。其中，AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架的一个重要特性，它允许开发者定义“切面”，即...
手机端AIDE安卓的音乐播放器软件代码QZQ.txt
12-17
手机端AIDE安卓的音乐播放器软件代码QZQ.txt
PythonPytorch基于小波时频图与SwinTransformer的轴承故障诊断研究
12-17
Python【Pytorch】基于小波时频图与SwinTransformer的轴承故障诊断研究内容概要：本文介绍了基于小波时频图与SwinTransformer的轴承故障诊断方法，利用Pytorch框架实现深度学习模型的应用。通过将振动信号转化为小波时频图，提取故障特征，并结合SwinTransformer这一基于Transformer架构的视觉模型进行分类识别，提升故障诊断的准确率与鲁棒性。该研究展示了深度学习在工业设备故障诊断中的潜力，特别是在处理非平稳信号和复杂工况下的有效性。; 适合人群：具备一定Python编程基础和深度学习理论知识的高校研究生、科研人员及工业界从事设备状态监测与故障诊断的工程师；熟悉Pytorch框架者更佳。; 使用场景及目标：①应用于旋转机械如电机、风机、齿轮箱等关键部件的轴承故障早期识别；②为智能制造与预测性维护系统提供技术支持；③推动传统信号处理与前沿深度学习模型（如SwinTransformer）在工业场景中的融合研究。; 阅读建议：建议读者结合文中提供的代码实践操作，理解从小波变换到图像输入再到SwinTransformer建模的全流程，重点关注数据预处理与模型结构设计细节，并可通过更换数据集或调整网络参数进一步验证模型泛化能力。
通过短时倒谱(Cepstrogram)计算进行时-倒频分析研究（Matlab代码实现）
12-17
通过短时倒谱(Cepstrogram)计算进行时-倒频分析研究（Matlab代码实现）内容概要：本文主要介绍了一项关于短时倒谱（Cepstrogram）计算在时-倒频分析中的研究，并提供了相应的Matlab代码实现。通过短时倒谱分析方法，能够有效提取信号在时间与倒频率域的特征，适用于语音、机械振动、生物医学等领域的信号处理与故障诊断。文中阐述了倒谱分析的基本原理、短时倒谱的计算流程及其在实际工程中的应用价值，展示了如何利用Matlab进行时-倒频图的可视化与分析，帮助研究人员深入理解非平稳信号的周期性成分与谐波结构。; 适合人群：具备一定信号处理基础，熟悉Matlab编程，从事电子信息、机械工程、生物医学或通信等相关领域科研工作的研究生、工程师及科研人员。; 使用场景及目标：①掌握倒谱分析与短时倒谱的基本理论及其与傅里叶变换的关系；②学习如何用Matlab实现Cepstrogram并应用于实际信号的周期性特征提取与故障诊断；③为语音识别、机械设备状态监测、振动信号分析等研究提供技术支持与方法参考； 阅读建议：建议读者结合提供的Matlab代码进行实践操作，先理解倒谱的基本概念再逐步实现短时倒谱分析，注意参数设置如窗长、重叠率等对结果的影响，同时可将该方法与其他时频分析方法（如STFT、小波变换）进行对比，以提升对信号特征的理解能力。
无人水下航行器(UUV)仿真研究（Matlab代码实现）
最新发布
12-17
无人水下航行器(UUV)仿真研究（Matlab代码实现）内容概要：本文围绕无人水下航行器（UUV）的仿真研究展开，基于Matlab代码实现对UUV的动力学模型、运动控制及导航仿真进行系统构建与验证。研究重点包括UUV的六自由度数学建模、环境干扰（如水流、浮力、阻力）的引入、姿态与轨迹控制算法的设计（如PID、滑模控制等），并通过Matlab/Simulink平台完成仿真验证，帮助理解UUV在复杂水下环境中的行为特性。此外，文档还提及与其他技术（如路径规划、信号处理、水下图像增强）的交叉应用，展现了UUV仿真的综合性与工程实用性。; 适合人群：具备一定Matlab编程基础，从事海洋工程、自动化、机器人、控制理论等相关领域的研究生、科研人员及工程技术人员。; 使用场景及目标：①用于UUV控制系统的设计与算法验证；②支持水下机器人相关课程教学与实验仿真；③为水下探测、救援、勘探等实际应用场景提供技术预研和方案测试平台； 阅读建议：建议结合文中提供的Matlab代码进行逐模块调试与仿真，重点关注动力学建模与控制算法实现部分，同时可拓展学习文档中提到的路径规划、传感器融合等相关技术，以构建完整的UUV系统认知体系。
【泰迪杯数据分析】超市销售赛题程序 落地即用！.zip
12-17
【泰迪杯数据分析】超市销售赛题程序 落地即用！.zip
Spring AOP配置全面解析
“Spring AOP配置的几种方式” 在Spring框架中，面向切面编程（AOP）是一种重要的设计模式，它允许程序员将关注点分离，比如日志、事务管理等，从核心业务逻辑中抽离出来。Spring AOP的配置涉及多个组件，包括通知...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值