`
marb
  • 浏览: 418786 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Spring 的 AOP :基于Annotation 的“零配置”方式

    博客分类:
  • JAVA
 
阅读更多

AOP(Aspect Orient Programming ) , 面向切面编程 。 

1、AOP的基本概念:

  AOP框架并不与特定的代码耦合,AOP框架能处理程序执行中特定的切入点(Pointcut),而不与具体某个类耦合。AOP框架具有如下特征:

  1、各步骤之间的良好隔离性。

  2、源代码无关性。

  AOP的专业术语:

  1、Aspect(切面) : 应用运行过程中的关注点,关注点可以横切多个对象,被称为横切关注点。

  2、pointcut(切入点):可插入增强处理的连接点。

  3、joinpoint(连接点):程序执行过程中明确的点,如方法的调用,或者异常的抛出。

  4、advice(增强处理):AOP框架特定的切入点执行的增强处理

如何使用表达式来定义切入点:

  1、引入:将方法或字段添加到被处理的类中。

  2、目标对象:被AOP框架进行增强处理的对象,也被称为被增强的对象。如果AOP框架是通过运行时代理来实现的,那么这个对象是一个被代理的对象。

  3、AOP代理:AOP框架创建的对象,简单的说,代理就是对目标对象的增强。

  4、织入(Weaving):将增强处理添加到目标对象中,并创建一个被增强的处理的过程就是织入。

 

2、Spring的 AOP支持

  在AOP编程,我们需要做如下三部分:

  1、定义普通组件。

  2、定义切入点、一个切入点可能横切多个业务组件。

  3、定义增强处理,增强处理就是在AOP框架为普通业务组件织入的处理动作。

  AOP编成的关键是 定义切入点 和 定义增强处理,Spring依然有如下两个方法来实现:

  1、基于Annotation 的“零配置”方式。

  2、使用XML配置文件的管理方式。

 

3、基于Annotation 的“零配置”方式

  为了启动Spring对@AspectJ切面配置的支持,并保证Spring容器中的目标Bean被一个或多个切面自动增强,必须在Spring配置文件下配置如下代码:

  

<?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"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
    <!-- 启动@AspectJ支持-->
   <aop:aspectj-autoproxy />
</beans>

  但是希望完全启动Spring的“零配置”功能,则配置代码中还需添加:

  

<?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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <!-- 启动@AspectJ支持-->
   <aop:aspectj-autoproxy />
</beans>

 

   

  这里给出下面 增强处理的目标类:

  

package org.service.imp;

import org.service.Person;
import org.springframework.stereotype.*;

@Component
public class Chinese implements Person {

    public String sayHello(String name) {
        // TODO Auto-generated method stub
        return name + "你好 , Spring Aop";
    }

    public void eat(String food) {
        // TODO Auto-generated method stub
        System.out.println("我正在吃:" + food) ;
    }

}

 

  3.1 定义切面Bean

  在启动@AspectJ 支持以后,只要在Sping 容器中配置一个带@Aspect 注释的Bean ,Spring将会自动识别该Bean,并将该Bean作为切面处理。

使用@Aspect标注一个Java类,该Java类将会作为切面Bean  

@Aspect
public class AspectTest
{
   //定义类的其他类容 ...... }

  3.2 定义Before增强处理

  使用@Before来标注一个方法,使该方法作为一个Before增强处理。使用@Before标注时,通常需要指定一个value值,改值指定一个切入表达式,用于指定该增强处理将被织入哪些切入点。

  如:@Before("execution(* com.cnblogs.jbelial.*.*(..))") 

  在被它标注的方法将匹配com.cnblogs.jbelial包下的所有类的、所有方法的执行作为切入点。

  如: 

package org.advice.Before;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

//定义一个切面
@Aspect
public class BeforeAdviceTest {
    //匹配该包下的所有类
    @Before( "execution(* org.service.imp.*.*(..))")
    public void authority()
    {
        System.out.println("模拟执行权限检查") ;
    }
}

  注:在定义增强处理时的Spring配置文件如何配置,可以参考Spring 的“零配置”支持“ 的学习

  

  3.3 定义AfterReturning增强处理

   类似于使用@Before ,使用@AfterReturning 来标注一个增强处理,该增强处理将会在目标方法正常完成后被织入。在使用@AfterReturning Annotation时可以指定如下两个常量属性。

  1、pointcut/value : 用于指定切入点对于的表达式。

  2、returning :制定一个返回值形参名,增强处理定义的方法可以通过该形参名来访问目标方法的返回值。

  如:@AfterReturning(returning ="rvt" , pointcut = "execution(* com.cnblogs.jbelial.*.*(..))") ; 

  指定一个 returning 属性,该属性值为 rvt , 表示 允许在 增强处理方法中使用名为rvt的形参,该形参代表目标方法的返回值。

  @AfterReturning Annotation 的 returning 属性所制定的的形参名必须对应于增强处理中的一个形参名。当目标方法执行返回后,返回值作为相应的参数值传入增强处理的方法。

  如下:

package org.advice.AfterReturning;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class AfterReturningAdivceTest {
    @AfterReturning( returning = "rvt" ,
            pointcut = "execution(* org.service.imp.*.*(..))")
    public void log(Object rvt)
    {
        System.out.println("获取目标方法返回值:"+rvt) ; 
        System.out.println("模拟记录日志功能...") ; 
    }
}

  3.4 定义AfterThrowing 增强处理:

  AfterThrowing 增强处理主要用于处理程序中未处理的异常。

  @AfterThrowing Annotation 两个常用的属性:

   > pointcut/value : 如上。

   > throwing : 指定一个返回参数名,增强处理定义的方法可通过该形参名来访问目标方法中所抛出的异常对象。

  如:@AfterThrowing(throwing = "ex" ,pointcut = "execution(* com.cnblogs.jbelial.*.*(..))")

  

  3.5 After 增强处理:

  After 与 AfterReturning 的区别:

  After : 增强处理不管目标方法如何结束,他都会被织入。因此,After 增强处理必须准备处理正常返回和异常返回两种情况,这种增强处理通常用于释放资源

  AfterReturning : 增强处理只有在目标方法成功完成才会被织入。

  如下: 

package org.advice.After;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.After;
@Aspect
public class AfterAdviceTest 
{
    
    @After ("execution(* org.service.imp.*.*(..))")
    
    public void release()
    {
        System.out.println("模拟方法结束后的释放资源....");
    }    
}

  

  3.6 Around 增强处理 :

   Around 增强处理既可以在执行目标方法之前织入增强处理,可以在执行目标方法之后织入增强动作。同时,Around 增强处理甚至可以决定目标方法在什么时候执行,如何执行,甚至可以完全阻止目标方法的执行。

   Around 增强处理可以改变执行目标方法的参数值,也可以改变执行目标方法之后的返回值。

   当定义一个 Around 增强处理方法时,该方法的第一个形参必须是 ProceedingJoinPoint 类型,调用 ProceedingJoinPoint 的 proceed() 方法才会执行目标方法。

  如下: 

package org.advice.Around;
 
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
@Aspect
public class AroundAdviceTest {
    @Around ( "execution(* org.service.imp.*.*(..))")
    public void processText(ProceedingJoinPoint PJ) throws Throwable
    {
        System.out.println("执行目标方法之前,模拟开始事务。");
        PJ.proceed() ; 
        System.out.println("执行目标方法之后,模拟结束事务。");
    }
}

  

  3.7  访问目标方法的参数:

  访问目标方法的做法是定义增强处理时将第一个参数定义为JoinPoint 类型,当该增强处理方法被调用时,该JoinPoint 参数就代表了织入增强处理的连接点。该JoinPoint 里包含了如下常用的方法:

  > Object[] getArgs() :  返回执行目标方法时的参数。  

  > Signature getSignature() : 返回被增强的方法的相关信息。

  > Object getTarget() : 返回被织入增强处理的目标对象。

  > Object getThis() : 返回AOP框架为目标的相关信息。

  注意:ProceedingJoinPoint 该类是JoinPoint 的子类。

  

   3.8 定义切入点:

  为一个切入表达式起一个名称,从而允许在多个增强处理中重用该名称。Spring AOP 只支持以Spring Bean 的方法执行组 作为连接点,所以可以把切入点看错所有能和切入表达式匹配的Bean 方法。

  切入点定义包含两个部分:

  > 一个切入点表达式。

  > 一个包含名字和任意参数的方法签名。

  如下: 

package org.advice.AfterReturning;

import org.aspectj.lang.annotation.*;

@Aspect
public class adviceExpression {
    @Pointcut("execution(* org.service.imp.*.*(..))")
    public void test() {  }
}

  注意:上面代码中的 test方法的返回值必须是void , 且当用private 访问控制符修饰时,则仅能在切面类中使用该切入点。

package org.advice.AfterReturning;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect; 
@Aspect
public class AfterReturningAdivceTest {
    @AfterReturning( returning = "rvt" ,
            pointcut = "adviceExpression.test()")
    public void log(Object rvt)
    {
        System.out.println("获取目标方法返回值:"+rvt) ; 
        System.out.println("模拟记录日志功能...") ; 
    }
}

  

  3.9 切入点指示符

  Spring AOP 仅仅支持部分 Aspect J 的切入指示符。

  Spring AOP 支持的切入点指示符有:

    > exection : 用于匹配执行方法的连接点,

    > within : 限定匹配特定类型的连接点,当使用Spring AOP 的时候,只能匹配方法执行的连接点。

        如下:

          within(org.service.imp.*) // imp 包中的任意连接点

          within(org.service.imp..*) // imp 包或子包中的任意连接点

    > this : 用于限定AOP 代理必须是指定类型的实例,用于匹配该对象的所有连接点。当使用Spring AOP 的时候,只能匹配方法执行的连接点。

    > target : 用于限定目标对象必须是指定类型的实例,用于匹配该对象的所有连接点。当使用Spring AOP 的时候,只能匹配方法执行的连接点。

        如下:

          // 匹配实现了Person 接口的目标对象的所有连接

          // 在Spring AOP 中只是方法执行的连接点

          target(org.service.imp.Person)

    > args : 用于对限定目标参数类型的限定,要求参数类型是指定类型的实例。当使用Spring AOP 的时候,只能匹配方法执行的连接点。

   Spring 支持使用如下路基运算符来组合切入点表达式。

    > !! : 只要连接点匹配任意一个切入点表达式。

    > && : 

    > ! : 要求连接点不匹配指定切入点表达式。

分享到:
评论

相关推荐

    spring 2.0使用AOP实例(基于Annotation的配置方式)

    以上就是Spring 2.0中使用AOP的一个基本实例,基于注解的配置方式使得AOP的使用更加直观和简洁。在实际开发中,我们可以根据需求灵活地定义切面和通知,以实现各种横切关注点的功能。 通过阅读提供的压缩包中的`src...

    Spring 基于基于XML配置方式实现AOP

    然而,随着Spring的发展,基于注解的AOP配置逐渐成为主流,因为它的简洁性和可读性更强。但这并不意味着XML配置方式失去了价值,尤其是在需要更细粒度控制或者与旧项目集成时,XML配置依然有着其独特的优势。 总的...

    spring aop实例annotation方法实现

    本实例将详细探讨如何通过注解(Annotation)来实现Spring AOP的方法拦截。 一、Spring AOP基础 Spring AOP是Spring框架的一部分,它提供了一种在运行时织入横切关注点(如日志、事务管理等)到目标对象的能力。AOP...

    Spring基础:Spring AOP简单使用

    - **注解配置**:Spring 2.5引入了基于注解的AOP,可以直接在切面类上使用@Aspect,@Before、@After、@Around等注解定义通知,@Pointcut定义切点。 4. **切点表达式** - 切点表达式是用于匹配连接点的语句,如`...

    spring aop xml 实例

    Spring AOP主要通过两种方式实现:XML配置和注解。本实例主要探讨的是使用XML配置的方式来实现AOP。XML配置虽然相比注解方式略显繁琐,但它提供了更大的灵活性,尤其是在需要对多个类或方法应用相同通知(Advice)时...

    简单spring aop 例子

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种模块化和声明式的方式来处理系统中的交叉关注点问题,如日志、事务管理、安全性等。本示例将简要介绍如何在Spring应用中实现AOP,通过实际的...

    Spring AOP + AspectJ annotation example

    AspectJ注解是与Spring AOP集成的一种方式,使得我们可以直接在Java类和方法上定义切面。例如,`@Aspect`注解标记一个类为切面,`@Before`、`@After`、`@Around`、`@AfterReturning`和`@AfterThrowing`分别用于定义...

    基于xml的SpringAOP实例

    在基于XML的配置方式下,Spring AOP提供了直观且灵活的声明式方法来实现这些关注点的分离,使得业务逻辑代码更为简洁。 在Spring AOP中,我们首先需要定义一个切面(Aspect),它包含了若干个通知(Advice)。通知...

    spring aop的两种配置方式.docx

    Spring AOP提供了两种主要的配置方式:XML配置和注解配置。接下来我们将详细探讨这两种配置方式。 **一、基于XML的Spring AOP配置** 在传统的Spring AOP配置中,我们通常会在`applicationContext.xml`或类似的配置...

    Spring_Annotation_AOP

    在Spring中,AOP主要通过两种方式实现:基于XML配置和基于注解。随着Java注解的普及,越来越多的开发者倾向于使用注解来简化配置。在"Spring_0200_Annotation_AOP"中,我们重点关注的是注解驱动的AOP。 1. **@...

    Spring aop 性能监控器

    尤其是`org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator`和`org.springframework.aop.aspectj.AspectJExpressionPointcut`这两个类,它们分别处理了基于注解的切面创建和切入点...

    Spring用AspectJ开发AOP(基于Annotation)

    文章指出,在Spring框架中,尽管可以使用XML配置文件来实现AOP开发,但是这种方式会导致XML配置文件过于臃肿,从而给维护和升级带来一定的困难。因此,AspectJ框架提供了基于Annotation的声明式方式来开发AOP。 在...

    Spring AOP面向方面编程原理:AOP概念

    Spring AOP支持多种方式来定义切入点,包括但不限于方法名、类名、注解等。 5. **引入(Introduction)**:允许向被通知对象添加新的接口实现或者新的方法。例如,可以使用引入让任何对象实现`IsModified`接口,...

    基于注解配置和使用spring AOP(spring mvc框架)

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种在不修改源代码的情况下,通过插入额外的代码(称为切面)来增强应用程序功能的方式。在Spring MVC框架中,AOP通常用于实现日志记录、事务管理...

    Spring AOP 1.0示例

    在Spring AOP中,我们可以使用XML配置或者注解的方式来声明切面。例如,创建一个名为`WriteLogAspect`的切面类,该类可能包含一个`@Before`注解的方法,表示在目标方法执行前执行的日志记录代码: ```java import ...

    spring aop的demo

    切面可以通过两种方式实现:基于注解(Annotation-based)和基于XML配置。在本Demo中,我们可能会看到使用注解的方式来创建切面,例如使用`@Aspect`来声明一个类作为切面,`@Before`、`@After`、`@Around`等来定义...

    Spring AOP 常用的四种实现方式的代码

    本篇文章将详细讲解Spring AOP的四种常见实现方式,以帮助开发者更好地理解和运用这一功能。 一、基于接口的代理(Interface-Based Proxy) 这是Spring AOP的默认实现方式,适用于目标对象实现了接口的情况。Spring...

    SpringAOP简单项目实现

    总结,这个"SpringAOP简单项目实现"涵盖了Spring AOP的基础知识,包括切面、通知、切入点的定义与配置,以及如何在实际项目中使用Maven进行构建和依赖管理。对于初学者来说,这是一个很好的实践案例,能够帮助他们...

    Spring中的AOP不生效

    在Spring框架中,AOP可以通过基于XML的配置或者基于注解的方式实现。但在实际开发过程中,可能会遇到配置好的AOP切面不生效的问题,本文将针对这一现象进行深入分析,并提供相应的解决方案。 #### 一、问题定位 当...

    Spring AOP 常用的四种实现方式

    本篇文章将深入探讨Spring AOP的四种常见实现方式。 一、基于接口的代理(Interface-Based Proxy) 这是Spring AOP最基础的实现方式,适用于目标对象实现了特定接口的情况。Spring会创建一个代理对象,该对象实现...

Global site tag (gtag.js) - Google Analytics