`
wangyanlong0107
  • 浏览: 501826 次
  • 性别: Icon_minigender_1
  • 来自: 沈阳
社区版块
存档分类
最新评论

【转】Spring Aop实例 .

 
阅读更多

一、XML方式

1. TestAspect：切面类

[java] view plaincopyprint?
  1. package com.spring.aop;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.ProceedingJoinPoint;  
  5.   
  6. public class TestAspect {  
  7.   
  8.     public void doAfter(JoinPoint jp) {  
  9.         System.out.println("log Ending method: " + jp.getTarget().getClass().getName() + "." + jp.getSignature().getName());  
  10.     }  
  11.   
  12.     public Object doAround(ProceedingJoinPoint pjp) throws Throwable {  
  13.         long time = System.currentTimeMillis();  
  14.         Object retVal = pjp.proceed();  
  15.         time = System.currentTimeMillis() - time;  
  16.         System.out.println("process time: " + time + " ms");  
  17.         return retVal;  
  18.     }  
  19.   
  20.     public void doBefore(JoinPoint jp) {  
  21.         System.out.println("log Begining method: " + jp.getTarget().getClass().getName() + "." + jp.getSignature().getName());  
  22.     }  
  23.   
  24.     public void doThrowing(JoinPoint jp, Throwable ex) {  
  25.         System.out.println("method " + jp.getTarget().getClass().getName() + "." + jp.getSignature().getName() + " throw exception");  
  26.         System.out.println(ex.getMessage());  
  27.     }  
  28. }  
package com.spring.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

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());
	}
}

2. AServiceImpl：目标对象

[java] view plaincopyprint?
  1. package com.spring.service;  
  2.   
  3. // 使用jdk动态代理   
  4. public class AServiceImpl implements AService {  
  5.   
  6.     public void barA() {  
  7.         System.out.println("AServiceImpl.barA()");  
  8.     }  
  9.   
  10.     public void fooA(String _msg) {  
  11.         System.out.println("AServiceImpl.fooA(msg:" + _msg + ")");  
  12.     }  
  13. }  
package com.spring.service;

// 使用jdk动态代理
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 + ")");
	}
}

3. BServiceImpl：目标对象

[java] view plaincopyprint?
  1. package com.spring.service;  
  2.   
  3. // 使用cglib   
  4. public class BServiceImpl {  
  5.   
  6.     public void barB(String _msg, int _type) {  
  7.         System.out.println("BServiceImpl.barB(msg:" + _msg + " type:" + _type + ")");  
  8.         if (_type == 1)  
  9.             throw new IllegalArgumentException("测试异常");  
  10.     }  
  11.   
  12.     public void fooB() {  
  13.         System.out.println("BServiceImpl.fooB()");  
  14.     }  
  15.   
  16. }  
package com.spring.service;

// 使用cglib
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()");
	}

}

4. ApplicationContext：Spring配置文件

[html] view plaincopyprint?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xmlns:aop="http://www.springframework.org/schema/aop"  
  5.     xmlns:context="http://www.springframework.org/schema/context"  
  6.     xmlns:tx="http://www.springframework.org/schema/tx"  
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
  8.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd  
  9.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd  
  10.         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">  
  11.     <aop:config>  
  12.         <aop:aspect id="TestAspect" ref="aspectBean">  
  13.             <!--配置com.spring.service包下所有类或接口的所有方法-->  
  14.             <aop:pointcut id="businessService" expression="execution(* com.spring.service.*.*(..))" />  
  15.             <aop:before pointcut-ref="businessService" method="doBefore"/>  
  16.             <aop:after pointcut-ref="businessService" method="doAfter"/>  
  17.             <aop:around pointcut-ref="businessService" method="doAround"/>  
  18.             <aop:after-throwing pointcut-ref="businessService" method="doThrowing" throwing="ex"/>  
  19.         </aop:aspect>  
  20.     </aop:config>  
  21.       
  22.     <bean id="aspectBean" class="com.spring.aop.TestAspect" />  
  23.     <bean id="aService" class="com.spring.service.AServiceImpl"></bean>  
  24.     <bean id="bService" class="com.spring.service.BServiceImpl"></bean>  
  25. </beans>   
<?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:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">
    <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>

 

二、注解（Annotation）方式

1. TestAnnotationAspect

[java] view plaincopyprint?
  1. package com.spring.aop;  
  2.   
  3. import org.aspectj.lang.ProceedingJoinPoint;  
  4. import org.aspectj.lang.annotation.After;  
  5. import org.aspectj.lang.annotation.AfterReturning;  
  6. import org.aspectj.lang.annotation.AfterThrowing;  
  7. import org.aspectj.lang.annotation.Around;  
  8. import org.aspectj.lang.annotation.Aspect;  
  9. import org.aspectj.lang.annotation.Before;  
  10. import org.aspectj.lang.annotation.Pointcut;  
  11.   
  12. @Aspect  
  13. public class TestAnnotationAspect {  
  14.   
  15.     @Pointcut("execution(* com.spring.service.*.*(..))")  
  16.     private void pointCutMethod() {  
  17.     }  
  18.   
  19.     //声明前置通知   
  20.     @Before("pointCutMethod()")  
  21.     public void doBefore() {  
  22.         System.out.println("前置通知");  
  23.     }  
  24.   
  25.     //声明后置通知   
  26.     @AfterReturning(pointcut = "pointCutMethod()", returning = "result")  
  27.     public void doAfterReturning(String result) {  
  28.         System.out.println("后置通知");  
  29.         System.out.println("---" + result + "---");  
  30.     }  
  31.   
  32.     //声明例外通知   
  33.     @AfterThrowing(pointcut = "pointCutMethod()", throwing = "e")  
  34.     public void doAfterThrowing(Exception e) {  
  35.         System.out.println("例外通知");  
  36.         System.out.println(e.getMessage());  
  37.     }  
  38.   
  39.     //声明最终通知   
  40.     @After("pointCutMethod()")  
  41.     public void doAfter() {  
  42.         System.out.println("最终通知");  
  43.     }  
  44.   
  45.     //声明环绕通知   
  46.     @Around("pointCutMethod()")  
  47.     public Object doAround(ProceedingJoinPoint pjp) throws Throwable {  
  48.         System.out.println("进入方法---环绕通知");  
  49.         Object o = pjp.proceed();  
  50.         System.out.println("退出方法---环绕通知");  
  51.         return o;  
  52.     }  
  53. }  
package com.spring.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class TestAnnotationAspect {

	@Pointcut("execution(* com.spring.service.*.*(..))")
	private void pointCutMethod() {
	}

	//声明前置通知
	@Before("pointCutMethod()")
	public void doBefore() {
		System.out.println("前置通知");
	}

	//声明后置通知
	@AfterReturning(pointcut = "pointCutMethod()", returning = "result")
	public void doAfterReturning(String result) {
		System.out.println("后置通知");
		System.out.println("---" + result + "---");
	}

	//声明例外通知
	@AfterThrowing(pointcut = "pointCutMethod()", throwing = "e")
	public void doAfterThrowing(Exception e) {
		System.out.println("例外通知");
		System.out.println(e.getMessage());
	}

	//声明最终通知
	@After("pointCutMethod()")
	public void doAfter() {
		System.out.println("最终通知");
	}

	//声明环绕通知
	@Around("pointCutMethod()")
	public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("进入方法---环绕通知");
		Object o = pjp.proceed();
		System.out.println("退出方法---环绕通知");
		return o;
	}
}

2. ApplicationContext：Spring配置文件

[java] view plaincopyprint?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xmlns:aop="http://www.springframework.org/schema/aop"  
  5.     xmlns:context="http://www.springframework.org/schema/context"  
  6.     xmlns:tx="http://www.springframework.org/schema/tx"  
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd   
  8.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd   
  9.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd   
  10.         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">   
  11.     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>  
  12.     <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />  
  13.   
  14.     <bean id="aspectBean" class="com.spring.aop.TestAnnotationAspect" />  
  15.     <bean id="aService" class="com.spring.service.AServiceImpl"></bean>  
  16.     <bean id="bService" class="com.spring.service.BServiceImpl"></bean>  
  17. </beans>  
<?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:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />

    <bean id="aspectBean" class="com.spring.aop.TestAnnotationAspect" />
    <bean id="aService" class="com.spring.service.AServiceImpl"></bean>
    <bean id="bService" class="com.spring.service.BServiceImpl"></bean>
</beans>

 

关于切入点表达式，大家需要好好练习才能深入理解其中含义。即使看的懂，但是写起来却非常麻烦，并没有想象中那么简单。

最后，再告诉大家：

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

其中getSignature()返回的Signature对象可强制转换为MethodSignature，其功能非常强大，能获取包括参数名称在内的一切方法信息。

 

============友情链接============

Spring Aop详尽教程 http://blog.csdn.net/wangpeng047/article/details/8556800

分享到：
| 【转】Oracle 游标使用全解
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring aop日志.doc

    &lt;bean id="testBeforeAdvice" class="com.company.springaop.test.TestBeforeAdvice" /&gt; &lt;bean id="beanImpl" class="com.company.springaop.test.BeanImpl" /&gt; ``` 在这个配置中，`aop:before`元素定义了一个切点...

    基于java的企业级应用开发：Spring AOP简介.ppt

    **Spring AOP 简介** 面向切面编程（AOP），全称为 Aspect-Oriented Programming，是一种编程范式，旨在解决传统面向对象编程（OOP）中的代码重复和分散问题。在OOP中，诸如事务管理、日志记录等功能往往会分散在多...

    spring aop注解所需要的三个jar包，aspectjrt.jar，aspectjweaver.jar，aopalliance.jar

    在Spring AOP中，aspectjrt.jar提供了与AspectJ相关的运行时支持，包括切面的实例化、通知的执行等。它使得Spring可以理解并执行基于AspectJ的切面，即使这些切面是在常规的Java环境中编译的。 其次，`...

    spring-aop实例

    Spring AOP（面向切面编程）是Spring框架的重要组成部分，它提供了一种强大的方式来实现横切关注点，如日志、事务管理、安全性等，从而解耦应用程序的核心业务逻辑。在Spring AOP中，关注点被模块化为独立的“切面”...

    spring AOP实例代码(带详细的讲解)

    在本实例代码中，我们将深入探讨Spring AOP的基本概念、核心组件以及如何在实际项目中应用。 首先，了解AOP的基本理念是理解其工作原理的关键。AOP是一种编程范式，旨在减少代码重复，提高可维护性和可读性。在传统...

    spring 2.0使用AOP实例（基于Annotation的配置方式）

    这篇博客文章将探讨如何在Spring 2.0中使用AOP实例，特别是通过注解来实现。 首先，我们需要了解AOP的基本概念。AOP的核心是切面（Aspect），它封装了横切关注点，即那些跨越多个对象的行为或责任。在Spring中，切...

    简单spring aop 例子

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

    SpringAop实例

    在这个"SpringAop实例"中，可能包含了演示如何创建和使用这两种配置方式的代码示例。文件列表中的"spring32"可能是指Spring 3.2版本的相关文件，这个版本的Spring对AOP的支持已经相当成熟。 通过学习这个实例，你...

    spring aop实例

    **Spring AOP 实例详解** 在Java开发领域，Spring框架以其强大的功能和灵活性深受开发者喜爱。其中，AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架的一个重要特性，它允许开发者将关注点从核心...

    spring1.x使用AOP实例

    Spring 1.x版本虽然已经较为古老，但理解其AOP（面向切面编程）的使用对于学习Spring框架的整体架构和设计理念至关重要。AOP是Spring解决横切关注点问题的重要手段，如日志记录、事务管理等。 首先，让我们来了解...

    springaop.zip

    在本示例中，"springaop.zip" 包含了一个使用XML配置的Spring AOP应用实例，可以直接运行，配合相关的博客文章学习效果更佳。 在Spring AOP中，我们首先需要了解几个核心概念： 1. **切面（Aspect）**：切面是关注...

    spring_aop.rar_spring_aop

    在"spring_aop.rar_spring_aop"这个实例工程中，可能包含了两个部分，"spring-aop-1"和"spring-aop-2"，它们可能分别展示了不同的AOP应用场景或者使用策略。例如： - "spring-aop-1"可能是一个基础的AOP示例，演示...

    spring_aop1.rar_java aop_spring mvc 例子

    本实例“spring_aop1.rar”是一个关于Spring AOP入门的教程，旨在帮助开发者更好地理解和运用Spring的AOP特性，同时也涉及到Spring MVC的相关知识。下面我们将深入探讨这两个关键概念。 首先，让我们了解一下Spring...

    SpringAOP.zip

    Spring AOP，全称为Aspect Oriented Programming，是Spring框架中的一个重要模块，主要负责处理系统中的...文件"5.SpringAOP_01"和"6.SpringAOP_02"很可能是课程的分阶段内容，涵盖了从基础概念到进阶实践的详细讲解。

    Spring Aop使用实例

    **Spring AOP 使用实例** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架的一个重要组成部分，它提供了一种在不修改原有代码的情况下，通过代理方式添加额外功能的技术。这种技术使得我们...

    spring 应用aop 实例

    本实例将深入探讨如何在Spring 4.0版本中实现AOP。 首先，AOP的核心概念包括切面（Aspect）、通知（Advice）、连接点（Join Point）、切入点（Pointcut）和织入（Weaving）。切面是AOP中的一个模块，包含了一组相关...

    Spring AOP完整例子

    Spring AOP（面向切面编程）是Spring框架的核心特性之一，它允许开发者在不修改源代码的情况下，通过插入切面来增强或改变程序的行为。在本教程中，我们将深入探讨Spring AOP的不同使用方法，包括定义切点、通知类型...

    spring-aop实例demo

    本实例将详细介绍如何在Spring 3.2.8版本中实现AOP。 首先，我们需要理解AOP的基本概念。AOP的核心是切面（Aspect），它包含了通知（Advice）和切点（Pointcut）。通知是在特定的连接点（Join Point）执行的代码，...

    spring aop实例annotation方法实现

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

Magicbox
Global site tag (gtag.js) - Google Analytics