Spring AOP 使用总结

spring AOP 使用总结

第一种形式:基于注解(推荐)
@Aspect
@Component
public class MyAdvice{

  @Before(value="execution(* xxx.xxx.*(..))")
  public void before() {
    System.out.println("前置增强......");
  }

  @AfterReturning(value="execution(* xxx.xxx.*(..))")
  public void after() {
    System.out.println("后置增强......");
  }

  @Around(value="execution(* xxx.xxx.*(..))")
  public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {

    System.out.println("方法之前.....");
    Object retVal = proceedingJoinPoint.proceed();//执行目标方法
    System.out.println("方法之后.....");
    return retVal;
  }

  @AfterThrowing(value="execution(* xxx.xxx.*(..))",throwing="ex")
  public void throwingException(XXXException ex){
    System.out.println("抛出XXX异常时执行.....");
  }

  @After(value="execution(* xxx.xxx.*(..))")
  public void doRelease() {
    //不管方法是正常结束还是抛出异常都会执行,类似于finally,主要用于释放资源
    System.out.println("finally doRelease.....");
  }

}
applicationContext.xml配置
<!-- 开启aop操作 -->
<aop:aspectj-autoproxy/>
<!-- 开启注解 -->
<context:component-scan base-package="xxx.xxx.xxx"/>

------------------------------------------------------------------------------------
第二种形式
public class MyAdvice{
  public void before() {
    System.out.println("前置增强......");
  }

  public void after() {
    System.out.println("后置增强......");
  }

  //环绕增强
  public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    //方法之前
    System.out.println("方法之前.....");

    //执行被增强的方法
    Object ret = proceedingJoinPoint.proceed();

    //方法之后
    System.out.println("方法之后.....");

    return ret;
  }
  //异常增强
  public void throwingException(){
    System.out.println("异常抛出时执行.....");
  }
}

applicationContext.xml配置

<!-- 1 配置Advice对象 -->
<bean id="myAdvice" class="xxx.xxx.MyAdvice"></bean>

<!-- 2 配置aop操作 -->
<aop:config>
  <!-- 2.1 配置切入点 -->
  <aop:pointcut expression="execution(* xxx.xxx.*.*(..))" id="pc"/>
  <!-- 2.2 配置切面 -->
  <aop:aspect ref="myAdvice">
    <aop:before method="before" pointcut-ref="pc"/>
    <aop:after-returning method="after" pointcut-ref="pc"/>
    <aop:around method="around" pointcut-ref="pc"/>
    <aop:after-throwing method="throwingException" pointcut-ref="pc"/>
  </aop:aspect>
</aop:config>
----------------------------------------------------------------------------------------
第三种形式:实现接口
1》前置增强功能
public class BeforeAdvice implements MethodBeforeAdvice{
  /**
  * 在目标方法之前执行
  * method:目标方法对象
  * args:方法的参数
  * target:被代理的目标对象
  */
  @Override
  public void before(Method method, Object[] args, Object target)throws Throwable {

  }
}
2》后置增强功能
public class AfterAdvice implements AfterReturningAdvice{
  //在目标方法之后执行
  @Override
  public void afterReturning(Object ret, Method method, Object[] args, Object target) throws Throwable {

  }
}
3》环绕增强功能
public class AroundAdvice implements MethodInterceptor{
  //methodInvocation:目标方法对象
  @Override
  public Object invoke(MethodInvocation methodInvocation) throws Throwable {
    System.out.println("方法之前");

    Object retVal = methodInvocation.proceed();//调用目标方法

    System.out.println("方法之后");

    return retVal;
  }
}
4》异常时的增强功能(了解)
public class ExceptionAdvice implements ThrowsAdvice {
  //目标中抛出异常时执行
  //ex:抛出的异常对象
  @Override
  public void afterThrowing(Exception ex){

  }
}

applicationContext.xml配置

<!-- 1 配置Advice对象 -->
<bean id="beforeAdvice" class="xxx.xxx.BeforeAdvice"></bean>
<bean id="afterAdvice" class="xxx.xxx.AfterAdvice"></bean>
<bean id="aroundAdvice" class="xxx.xxx.AroundAdvice"></bean>
<bean id="exceptionAdvice" class="xxx.xxx.ExceptionAdvice"></bean>

<!-- 2 配置aop操作 -->
<aop:config>
  <!-- 2.1 配置切入点 -->
  <aop:pointcut expression="execution(* xxx.xxx.*.*(..))" id="pc"/>
  <!-- 2.2 配置切面 -->
  <aop:advisor advice-ref="beforeAdvice" pointcut-ref="pc"/>
  <aop:advisor advice-ref="afterAdvice" pointcut-ref="pc"/>
  <aop:advisor advice-ref="aroundAdvice" pointcut-ref="pc"/>
  <aop:advisor advice-ref="exceptionAdvice" pointcut-ref="pc"/>
</aop:config>

时间: 2024-10-10 23:01:14

Spring AOP 使用总结的相关文章

Spring框架之Spring AOP

一.基于注解管理的AOP 1.Spring配置文件 <!-- 配置自动扫描包,自动扫描Bean组件,切面类 --> <context:component-scan base-package="com.zhoujian.spring.anno,com.zhoujian.spring.test"> <!-- <context:include-filter type="annotation" expression="org.a

Spring AOP中pointcut expression表达式解析 及匹配多个条件

Pointcut 是指那些方法需要被执行"AOP",是由"Pointcut Expression"来描述的. Pointcut可以有下列方式来定义或者通过&& || 和!的方式进行组合. args() @args() execution() this() target() @target() within() @within() @annotation 其中 execution 是用的最多的,其格式为: execution(modifiers-pat

spring aop 原理

http://blog.csdn.net/moreevan/article/details/11977115 Spring AOP 实现原理 2013-09-24 15:23 79554人阅读 评论(11) 收藏 举报  分类: spring(2)  版权声明:本文为博主原创文章,未经博主允许不得转载. 目录(?)[+] 什么是AOP AOP(Aspect-OrientedProgramming,面向方面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)

Spring AOP进行日志记录

在java开发中日志的管理有很多种.我一般会使用过滤器,或者是Spring的拦截器进行日志的处理.如果是用过滤器比较简单,只要对所有的.do提交进行拦截,然后获取action的提交路径就可以获取对每个方法的调用.然后进行日志记录.使用过滤器的好处是可以自己选择性的对某一些方法进行过滤,记录日志.但是实现起来有点麻烦. 另外一种就是使用Spring的AOP了.这种方式实现起来非常简单,只要配置一下配置文件就可以了.可是这种方式会拦截下所有的对action的每个操作.使得效率比较低.不过想做详细日志

spring AOP和通知

1.  spring的通知 1.1.  AOP的概念 切面(Aspect):一个关注点的模块化,这个关注点可能会横切多个对象.事务管理是J2EE应用中一个关于横切关注点的很好的例子.在Spring AOP中,切面可以使用基于模式或者基于注解的方式来实现. 连接点(Joinpoint):在程序执行过程中某个特定的点,比如某方法调用的时候或者处理异常的时候.在Spring AOP中,一个连接点总是表示一个方法的执行. 通知(Advice):在切面的某个特定的连接点上执行的动作.其中包括了"aroun

spring aop 整理

aop常见概念 1.切面 事务.日志.安全性框架.权限等都是切面(就是类,事务有事务类,日志有日志类,权限有权限类) 2.通知 切面中的方法就是通知(类中针对目标方法所要插入的方法,即事务类中执行事务的方法,日志类中执行日志操作的方法) 3.目标类 (你想要侵入修改的方法所在的类,诸如我们想在查询存款时加入一些其他操作,存款管理类就是目标类) 4.切入点 只有符合切入点,才能让通知和目标方法结合在一起 (就是你想要加强的方法,就是查看工资的方法showSalary()) 5.织入: 形成代理对象

JavaEE学习之Spring aop

一.基本概念 AOP——Aspect-Oriented Programming,面向切面编程,它是spring框架的一个重要组成部分.一般的业务逻辑都有先后关系,我们可以理解为纵向关系,而AOP关注的是横向关系,每一个关注点可以理解为一个横切面.例如我们的大部分代码都会涉及到日志记录,很多的数据库操作都会涉及到事务的创建和提交.那么从横向关注这些逻辑,他们都一个个的切面. AOP技术的具体实现,可以通过动态代理技术或者是在程序编译期间进行静态的"织入"方式.AOP经常使用的场景包括:日

Spring AOP详解(转载)

此前对于AOP的使用仅限于声明式事务,除此之外在实际开发中也没有遇到过与之相关的问题.最近项目中遇到了以下几点需求,仔细思考之后,觉得采用AOP 来解决.一方面是为了以更加灵活的方式来解决问题,另一方面是借此机会深入学习Spring AOP相关的内容.本文是权当本人的自己AOP学习笔记,以下需求不用AOP肯定也能解决,至于是否牵强附会,仁者见仁智者见智. 对部分函数的调用进行日志记录,用于观察特定问题在运行过程中的函数调用情况 监控部分重要函数,若抛出指定的异常,需要以短信或邮件方式通知相关人员

Spring AOP 之 通知、连接点、切点、切面。

1:知识背景 软件系统可以看成是由一组关注点组成的,其中,直接的业务关注点,是直切关注点.而为直切关注点提供服务的,就是横切关注点. 2:面向切面的基本原理 什么是面向切面编程 横切关注点:影响应用多处的功能(安全.事务.日志) 切面: 横切关注点被模块化为特殊的类,这些类称为切面 优点: 每个关注点现在都集中于一处,而不是分散到多处代码中 服务模块更简洁,服务模块只需关注核心代码. AOP 术语 通知: 定义:切面也需要完成工作.在 AOP 术语中,切面的工作被称为通知. 工作内容:通知定义了

深入理解Spring AOP之基本概念

深入理解Spring AOP之基本概念 AOP到底是什么 Spring AOP和IOC是听到的关于Spring最频繁的两个词了.现在来重点关注AOP这个词,IOC先放一边,下面这段话摘自Spring优势中关于面向切面的介绍: 面向切面--Spring提供了面向切面编程的丰富支持,允许通过分离应用的业务逻辑与系统级服务(例如审计(auditing)和事务(transaction)管理)进行内聚性的开发.应用对象只实现它们应该做的--完成业务逻辑--仅此而已.它们并不负责(甚至是意识)其它的系统级关