`

AOP例子(spring配置实现)

阅读更多

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

    事实上,以上需求没有AOP也能搞定,只是在实现过程中比较郁闷摆了。
需要打印日志的函数分散在各个包中,只能找到所有的函数体,手动添加日志。然而这些日志都是临时的,待问题解决之后应该需要清除打印日志的代码,只能再次手动清除^_^!
类似1的情况,需要捕获异常的地方太多,如果手动添加时想到很可能明天又要手动清除,只能再汗。OK,该需求相对比较固定,属于长期监控的范畴,并不需求临时添加后再清除。然而,客户某天要求,把其中20%的异常改为短信提醒,剩下的80%改用邮件提醒。改之,两天后,客户抱怨短信太多,全部改成邮件提醒...
该需求通常用于监控某些函数的执行时间,用以判断系统执行慢的瓶颈所在。瓶颈被解决之后,烦恼同情况1


    终于下定决心,采用AOP来解决!代码如下:

    切面类TestAspect

Java代码 
package com.spring.aop;   
/**  
 * 切面  
 *  
 */  
public class TestAspect {   
  
    public void doAfter(JoinPoint jp) {   
        System.out.println("log Ending method: "  
                + jp.getTarget().getClass().getName() + "."  
                + jp.getSignature().getName());   
    }   
  
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {   
        long time = System.currentTimeMillis();   
        Object retVal = pjp.proceed();   
        time = System.currentTimeMillis() - time;   
        System.out.println("process time: " + time + " ms");   
        return retVal;   
    }   
  
    public void doBefore(JoinPoint jp) {   
        System.out.println("log Begining method: "  
                + jp.getTarget().getClass().getName() + "."  
                + jp.getSignature().getName());   
    }   
  
    public void doThrowing(JoinPoint jp, Throwable ex) {   
        System.out.println("method " + jp.getTarget().getClass().getName()   
                + "." + jp.getSignature().getName() + " throw exception");   
        System.out.println(ex.getMessage());   
    }   
  
    private void sendEx(String ex) {   
        //TODO 发送短信或邮件提醒   
    }   
}   
Java代码 
package com.spring.service;   
/**  
 * 接口A  
 */  
public interface AService {   
       
    public void fooA(String _msg);   
  
    public void barA();   
}  

  
Java代码 
package com.spring.service;   
/**  
 *接口A的实现类  
 */  
public class AServiceImpl implements AService {   
  
    public void barA() {   
        System.out.println("AServiceImpl.barA()");   
    }   
  
    public void fooA(String _msg) {   
        System.out.println("AServiceImpl.fooA(msg:"+_msg+")");   
    }   
}  
Java代码 
package com.spring.service;   
  
/**  
 *   Service类B  
 */  
public class BServiceImpl {   
  
    public void barB(String _msg, int _type) {   
        System.out.println("BServiceImpl.barB(msg:"+_msg+" type:"+_type+")");   
        if(_type == 1)   
            throw new IllegalArgumentException("测试异常");   
    }   
  
    public void fooB() {   
        System.out.println("BServiceImpl.fooB()");   
    }   
  
} 

 

 ApplicationContext
Java代码 
<?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"  
    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-2.5.xsd"   
    default-autowire="autodetect">   
    <aop:config>   
        <aop:aspect id="TestAspect" ref="aspectBean">   
            <!--配置com.spring.service包下所有类或接口的所有方法-->   
            <aop:pointcut id="businessService"  
                expression="execution(* com.spring.service.*.*(..))" />   
            <aop:before pointcut-ref="businessService" method="doBefore"/>   
            <aop:after pointcut-ref="businessService" method="doAfter"/>   
            <aop:around pointcut-ref="businessService" method="doAround"/>   
            <aop:after-throwing pointcut-ref="businessService" method="doThrowing" throwing="ex"/>   
        </aop:aspect>   
    </aop:config>   
       
    <bean id="aspectBean" class="com.spring.aop.TestAspect" />   
    <bean id="aService" class="com.spring.service.AServiceImpl"></bean>   
    <bean id="bService" class="com.spring.service.BServiceImpl"></bean>   
  
</beans>  

 

 测试类AOPTest
Java代码 
public class AOPTest extends AbstractDependencyInjectionSpringContextTests {   
       
    private AService aService;   
       
    private BServiceImpl bService;   
       
    protected String[] getConfigLocations() {   
        String[] configs = new String[] { "/applicationContext.xml"};   
        return configs;   
    }   
       
       
    /**  
     * 测试正常调用  
     */  
    public void testCall()   
    {   
        System.out.println("SpringTest JUnit test");   
        aService.fooA("JUnit test fooA");   
        aService.barA();   
        bService.fooB();   
        bService.barB("JUnit test barB",0);   
    }   
       
    /**  
     * 测试After-Throwing  
     */  
    public void testThrow()   
    {   
        try {   
            bService.barB("JUnit call barB",1);   
        } catch (IllegalArgumentException e) {   
               
        }   
    }   
       
    public void setAService(AService service) {   
        aService = service;   
    }   
       
    public void setBService(BServiceImpl service) {   
        bService = service;   
    }   
}  

 

 运行结果如下:
Java代码 
log Begining method: com.spring.service.AServiceImpl.fooA   
AServiceImpl.fooA(msg:JUnit test fooA)   
log Ending method: com.spring.service.AServiceImpl.fooA   
process time: 0 ms   
log Begining method: com.spring.service.AServiceImpl.barA   
AServiceImpl.barA()   
log Ending method: com.spring.service.AServiceImpl.barA   
process time: 0 ms   
log Begining method: com.spring.service.BServiceImpl.fooB   
BServiceImpl.fooB()   
log Ending method: com.spring.service.BServiceImpl.fooB   
process time: 0 ms   
log Begining method: com.spring.service.BServiceImpl.barB   
BServiceImpl.barB(msg:JUnit test barB type:0)   
log Ending method: com.spring.service.BServiceImpl.barB   
process time: 0 ms   
  
log Begining method: com.spring.service.BServiceImpl.barB   
BServiceImpl.barB(msg:JUnit call barB type:1)   
log Ending method: com.spring.service.BServiceImpl.barB   
method com.spring.service.BServiceImpl.barB throw exception   
测试异常  

 

《Spring参考手册》中定义了以下几个AOP的重要概念,结合以上代码分析如下:
切面(Aspect) :官方的抽象定义为“一个关注点的模块化,这个关注点可能会横切多个对象”,在本例中,“切面”就是类TestAspect所关注的具体行为,例如,AServiceImpl.barA()的调用就是切面TestAspect所关注的行为之一。“切面”在ApplicationContext中<aop:aspect>来配置。
连接点(Joinpoint) :程序执行过程中的某一行为,例如,AServiceImpl.barA()的调用或者BServiceImpl.barB(String _msg, int _type)抛出异常等行为。
通知(Advice) :“切面”对于某个“连接点”所产生的动作,例如,TestAspect中对com.spring.service包下所有类的方法进行日志记录的动作就是一个Advice。其中,一个“切面”可以包含多个“Advice”,例如TestAspect
切入点(Pointcut) :匹配连接点的断言,在AOP中通知和一个切入点表达式关联。例如,TestAspect中的所有通知所关注的连接点,都由切入点表达式execution(* com.spring.service.*.*(..))来决定
目标对象(Target Object) :被一个或者多个切面所通知的对象。例如,AServcieImpl和BServiceImpl,当然在实际运行时,Spring AOP采用代理实现,实际AOP操作的是TargetObject的代理对象。
AOP代理(AOP Proxy) 在Spring AOP中有两种代理方式,JDK动态代理和CGLIB代理。默认情况下,TargetObject实现了接口时,则采用JDK动态代理,例如,AServiceImpl;反之,采用CGLIB代理,例如,BServiceImpl。强制使用CGLIB代理需要将 <aop:config> 的 proxy-target-class 属性设为true

       通知(Advice)类型
前置通知(Before advice) :在某连接点(JoinPoint)之前执行的通知,但这个通知不能阻止连接点前的执行。ApplicationContext中在<aop:aspect>里面使用<aop:before>元素进行声明。例如,TestAspect中的doBefore方法
后通知(After advice) :当某连接点退出的时候执行的通知(不论是正常返回还是异常退出)。ApplicationContext中在<aop:aspect>里面使用<aop:after>元素进行声明。例如,TestAspect中的doAfter方法,所以AOPTest中调用BServiceImpl.barB抛出异常时,doAfter方法仍然执行
返回后通知(After return advice) :在某连接点正常完成后执行的通知,不包括抛出异常的情况。ApplicationContext中在<aop:aspect>里面使用<after-returning>元素进行声明。
环绕通知(Around advice) :包围一个连接点的通知,类似Web中Servlet规范中的Filter的doFilter方法。可以在方法的调用前后完成自定义的行为,也可以选择不执行。ApplicationContext中在<aop:aspect>里面使用<aop:around>元素进行声明。例如,TestAspect中的doAround方法。
抛出异常后通知(After throwing advice) : 在方法抛出异常退出时执行的通知。 ApplicationContext中在<aop:aspect>里面使用<aop:after-throwing>元素进行声明。例如,TestAspect中的doThrowing方法。

       切入点表达式
通常情况下,表达式中使用”execution“就可以满足大部分的要求。表达式格式如下:
Java代码
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?) 

modifiers-pattern:方法的操作权限

ret-type-pattern:返回值

declaring-type-pattern:方法所在的包

name-pattern:方法名

parm-pattern:参数名

throws-pattern:异常

其中,除ret-type-pattern和name-pattern之外,其他都是可选的。上例中,execution(* com.spring.service.*.*(..))表示com.spring.service包下,返回值为任意类型;方法名任意;参数不作限制的所有方法。
通知参数

可以通过args来绑定参数,这样就可以在通知(Advice)中访问具体参数了。例如,<aop:aspect>配置如下

Java代码 
<aop:config>   
    <aop:aspect id="TestAspect" ref="aspectBean">   
        <aop:pointcut id="businessService"  
            expression="execution(* com.spring.service.*.*(String,..)) and args(msg,..)" />   
            <aop:after pointcut-ref="businessService" method="doAfter"/>   
    </aop:aspect>   
</aop:config>  

 

TestAspect的doAfter方法中就可以访问msg参数,但这样以来AService中的barA()和BServiceImpl中的barB()就不再是连接点,因为execution(* com.spring.service.*.*(String,..))只配置第一个参数为String类型的方法。其中,doAfter方法定义如下:
Java代码
public void doAfter(JoinPoint jp,String msg) 
  访问当前的连接点

任何通知(Advice)方法可以将第一个参数定义为 org.aspectj.lang.JoinPoint 类型。JoinPoint 接口提供了一系列有用的方法, 比如 getArgs() (返回方法参数)、getThis() (返回代理对象)、getTarget() (返回目标)、getSignature() (返回正在被通知的方法相关信息)和 toString() (打印出正在被通知的方法的有用信息。

 

通知(Advice)类型

前置通知(Before advice) :在某连接点(JoinPoint)之前执行的通知,但这个通知不能阻止连接点前的执行。ApplicationContext中在<aop:aspect>里面使用<aop:before>元素进行声明。例如,TestAspect中的doBefore方法
后通知(After advice) :当某连接点退出的时候执行的通知(不论是正常返回还是异常退出)。ApplicationContext中在<aop:aspect>里面使用<aop:after>元素进行声明。例如,TestAspect中的doAfter方法,所以AOPTest中调用BServiceImpl.barB抛出异常时,doAfter方法仍然执行
返回后通知(After return advice) :在某连接点正常完成后执行的通知,不包括抛出异常的情况。ApplicationContext中在<aop:aspect>里面使用<after-returning>元素进行声明。
环绕通知(Around advice) :包围一个连接点的通知,类似Web中Servlet规范中的Filter的doFilter方法。可以在方法的调用前后完成自定义的行为,也可以选择不执行。ApplicationContext中在<aop:aspect>里面使用<aop:around>元素进行声明。例如,TestAspect中的doAround方法。
抛出异常后通知(After throwing advice) : 在方法抛出异常退出时执行的通知。 ApplicationContext中在<aop:aspect>里面使用<aop:after-throwing>元素进行声明。例如,TestAspect中的doThrowing方法。

分享到:
评论

相关推荐

    使用Spring配置文件实现AOP

    这篇教程将详细讲解如何通过Spring的配置文件来实现AOP。 一、理解AOP概念 AOP的核心思想是将分散在各个模块中的交叉性代码(如日志、事务处理)抽取出来,形成独立的切面,以便于复用和维护。它提供了一种模块化的...

    简单spring aop 例子

    现在,我们来看如何创建一个简单的Spring AOP例子: 1. **定义切面(Aspect)**:切面是包含通知(Advice)和切入点(Pointcut)的类。通知定义了要执行的逻辑,切入点定义了何时执行。例如,我们可以创建一个名为`...

    Spring 2.5 AOP 例子

    Spring 2.5 AOP(面向切面编程)...综上所述,Spring 2.5 AOP例子展示了如何利用类扫描和XML配置实现面向切面编程。通过理解这些概念和实践,我们可以更高效地管理和维护我们的应用程序,使其更具可扩展性和可维护性。

    springAop的配置实现

    **Spring AOP 配置实现详解** Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架的重要组成部分,它允许我们通过分离关注点来简化应用程序的开发。在传统的面向对象编程中,业务逻辑与日志记录...

    Spring AOP完整例子

    在Spring AOP的例子中,我们可能会创建一个`@RunWith(SpringJUnit4ClassRunner.class)`标记的测试类,以利用Spring的测试支持。在测试方法中,可以注入需要的bean,然后调用方法来触发AOP代理。这样,通知将在适当的...

    spring mvc框架下的aop例子

    在Spring MVC框架中,AOP(面向切面编程)是一种强大的设计模式,它允许开发者将关注点分离,比如日志、...同时,确保你的Spring配置文件和Java类都正确地导入了所需库,并且类路径设置正确,这样才能使AOP功能生效。

    spring的aop简单例子

    这个简单例子将帮助我们理解AOP的基本概念和如何在Spring框架中实现它。 首先,我们要知道AOP的核心概念:切面、通知、连接点、切点、目标对象和代理。切面是包含横切关注点(如日志记录、事务管理等)的模块化组件...

    spring aop例子

    在"spring aop例子"中,我们可以看到`src`目录,这个通常包含Java源代码,其中可能包含了切面类、通知方法以及使用了切面的业务逻辑类。`extjstest`可能是测试目录,用于验证AOP配置和功能是否正确工作。`QQ五笔截图...

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

    1. **启用AOP代理**:在Spring配置文件中,通过&lt;aop:aspectj-autoproxy/&gt;元素启用基于注解的AOP。 ```xml &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=...

    Spring AOP 的实现例子(基于XML配置实现)

    下面我们将详细探讨如何通过XML配置实现Spring AOP。 首先,我们需要在Spring配置文件中启用AOP支持。这通常通过在`&lt;beans&gt;`标签内添加`&lt;aop:config&gt;`或`&lt;aop:aspectj-autoproxy&gt;`标签来实现。`&lt;aop:config&gt;`是...

    Spring.net Aop 例子

    通过这个例子,你可以学习到如何在Spring.NET环境中实现AOP,理解动态代理的工作原理,并掌握如何在实际项目中应用AOP来提高代码的灵活性和可维护性。这将有助于你编写更加模块化、易于维护的软件系统。

    springAop与spring定时器

    Spring AOP(面向切面编程)是Spring框架中的一个重要组件,它允许我们在不修改源代码的情况下,通过在程序运行时动态地将代码插入到方法调用中,来实现跨切面的关注点,如日志记录、性能监控、事务管理等。而Spring...

    Spring AOP例子实现源码

    在Spring配置文件中,我们需要启用AOP代理并声明切面。例如: ```xml &lt;aop:aspectj-autoproxy /&gt; ``` 6. **实际应用** 在`springAop`目录下,你应该会看到如`LoggingAspect.java`这样的源码文件,它实现了切...

    spring-boot aop

    本示例是关于如何在Spring Boot项目中实现AOP功能的一个简单演示。 首先,我们需要了解AOP的基本概念。AOP的核心是切面(Aspect),它封装了跨越多个对象的行为或关注点,如日志记录。切点(Pointcut)定义了在何处...

    SpringAOP的例子

    在这个"SpringAOP的例子"中,我们将深入探讨如何在Eclipse环境下利用Spring AOP和动态代理来实现这些功能。 首先,让我们理解什么是AOP。AOP是一种编程范式,旨在减少代码的重复性和增强可维护性。在传统的OOP中,...

    Spring AOP的简单实现

    在Spring配置中,我们需要开启AOP代理,以便Spring能够识别并处理切面。如果使用的是基于注解的配置,可以在`@Configuration`类中添加`@EnableAspectJAutoProxy`注解。 5. **装配切面** 最后,我们需要将`...

    myeclipse spring IOC和AOP 例子

    下面是一个简单的AOP例子,创建一个记录方法执行时间的通知: ```java @Aspect public class LoggingAspect { @Before("execution(* com.example.service.*.*(..))") public void logBefore(JoinPoint joinPoint)...

    Spring3.1AOP简单例子

    5. **启用AOP**:为了使AOP生效,我们需要在Spring配置中启用AOP支持,这可以通过在XML配置中添加`&lt;aop:aspectj-autoproxy&gt;` 或者在Java配置中使用`@EnableAspectJAutoProxy` 注解来实现。 在"Spring3.1.0Demo2-AOP...

    spring-aop标签和配置文件两种方式实例

    然后,只需在Spring配置中启用基于注解的AOP支持: ```xml &lt;aop:aspectj-autoproxy /&gt; ``` 对比这两种方式,XML配置方式更为灵活,适合复杂的AOP配置,而AOP标签方式更简洁,适用于大多数日常需求。在实际项目中,...

    理解Spring AOP实现与思想 案例代码

    - **XML配置**:在Spring的配置文件中,可以使用`&lt;aop:config&gt;`标签定义切面,`&lt;aop:pointcut&gt;`定义切入点,`&lt;aop:advisor&gt;`定义通知。 - **注解配置**:使用`@Aspect`定义切面,`@Pointcut`定义切入点,`@Before`...

Global site tag (gtag.js) - Google Analytics