`
cfeers
  • 浏览: 141471 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

Spring AOP 2.0 研究

AOPSpringBeanXML 
阅读更多

我们用Hello的例子来诠释Spring AOP 2.0 的特性。
Hello

Java代码 复制代码
  1. public interface Hello {   
  2.     void sayHelloBefore();   
  3.   
  4.     void sayHelloAfter();   
  5.   
  6.     void sayHelloAround();   
  7. }  
public interface Hello {
	void sayHelloBefore();

	void sayHelloAfter();

	void sayHelloAround();
}


SayHello

Java代码 复制代码
  1. public class SayHello implements Hello{   
  2.     /**  
  3.      *   
  4.      */  
  5.     public void sayHelloBefore() {   
  6.         System.out.println("say Hello before!");   
  7.     }   
  8.   
  9.     /**  
  10.      *   
  11.      */  
  12.     public void sayHelloAfter() {   
  13.         System.out.println("say Hello after!");   
  14.     }   
  15.   
  16.     /**  
  17.      *   
  18.      */  
  19.     public void sayHelloAround() {   
  20.         System.out.println("say Hello around!");   
  21.     }   
  22. }  
public class SayHello implements Hello{
	/**
	 * 
	 */
	public void sayHelloBefore() {
		System.out.println("say Hello before!");
	}

	/**
	 * 
	 */
	public void sayHelloAfter() {
		System.out.println("say Hello after!");
	}

	/**
	 * 
	 */
	public void sayHelloAround() {
		System.out.println("say Hello around!");
	}
}


Before

Java代码 复制代码
  1. public class Before {   
  2.     public void invoke(JoinPoint joinPoint) {   
  3.         System.out.println("Before:" + joinPoint.getSignature().getName());   
  4.     }   
  5. }  
public class Before {
	public void invoke(JoinPoint joinPoint) {
		System.out.println("Before:" + joinPoint.getSignature().getName());
	}
}


After

Java代码 复制代码
  1. public class After {   
  2.     public void invoke(JoinPoint joinPoint) {   
  3.     System.out.println("After:" + joinPoint.getSignature().getName());   
  4.     }   
  5. }  
public class After {
	public void invoke(JoinPoint joinPoint) {
	System.out.println("After:" + joinPoint.getSignature().getName());
	}
}


Around

Java代码 复制代码
  1. public class Around {   
  2.     public Object invoke(ProceedingJoinPoint joinPoint) throws Throwable {   
  3.         System.out.println("Around:" + joinPoint.getSignature().getName());   
  4.         return joinPoint.proceed();   
  5.     }   
  6. }  
public class Around {
	public Object invoke(ProceedingJoinPoint joinPoint) throws Throwable {
		System.out.println("Around:" + joinPoint.getSignature().getName());
		return joinPoint.proceed();
	}
}


Introduction

Java代码 复制代码
  1. public class Introduction {   
  2.     public Object invoke(ProceedingJoinPoint joinPoint) throws Throwable {   
  3.         System.out   
  4.                 .println("Introduction:" + joinPoint.getSignature().getName());   
  5.         return joinPoint.proceed();   
  6.     }   
  7. }  
public class Introduction {
	public Object invoke(ProceedingJoinPoint joinPoint) throws Throwable {
		System.out
				.println("Introduction:" + joinPoint.getSignature().getName());
		return joinPoint.proceed();
	}
}


Introduction 引入的作用在于是一个类在不做任何代码修改的前提下，拥有另一套方法，或者说具备另一套本领，比如我们现在就想让这个实现了Hello接口的SayHello类拥有Ok接口的方法

Java代码 复制代码
  1. public interface Ok {   
  2.     void sayOk();   
  3. }  
public interface Ok {
	void sayOk();
}


IntroductionOk  首先要解决上述接口Ok的实现

Java代码 复制代码
  1. public class IntroductionOk implements Ok {   
  2.     
  3.     @Override  
  4.     public void sayOk() {   
  5.         System.out.println("Ok!");   
  6.     }   
  7. }  
public class IntroductionOk implements Ok {
 
	@Override
	public void sayOk() {
		System.out.println("Ok!");
	}
}


AllTest

Java代码 复制代码
  1. public class AllTest {   
  2.     private ApplicationContext app;   
  3.   
  4.     /**  
  5.      * @throws java.lang.Exception  
  6.      */  
  7.     @Before  
  8.     public void setUp() throws Exception {   
  9.         app = new ClassPathXmlApplicationContext("applicationContext.xml");   
  10.     }   
  11.   
  12.     @Test  
  13.     public final void testHello() {   
  14.         Hello hello = (Hello) app.getBean("hello");   
  15.         hello.sayHelloBefore();   
  16.         hello.sayHelloAfter();   
  17.         hello.sayHelloAround();   
  18.   
  19.         // 由于对Hello接口进行了引入，   
  20.         // 使得实现了Hello接口的类可以具备Ok接口的功能。   
  21.         // 同时，我们可以拦截这个方法让他执行其他我们需要执行的操作   
  22.         hello.sayHelloIntroduction();   
  23.         ((Ok) hello).sayOk();   
  24.     }   
  25.   
  26. }  
public class AllTest {
	private ApplicationContext app;

	/**
	 * @throws java.lang.Exception
	 */
	@Before
	public void setUp() throws Exception {
		app = new ClassPathXmlApplicationContext("applicationContext.xml");
	}

	@Test
	public final void testHello() {
		Hello hello = (Hello) app.getBean("hello");
		hello.sayHelloBefore();
		hello.sayHelloAfter();
		hello.sayHelloAround();

		// 由于对Hello接口进行了引入，
		// 使得实现了Hello接口的类可以具备Ok接口的功能。
		// 同时，我们可以拦截这个方法让他执行其他我们需要执行的操作
		hello.sayHelloIntroduction();
		((Ok) hello).sayOk();
	}

}


关于表达式符号
.*+定义目标为包下的所有类
+定义目标为该接口的所有实现类

Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans  
  3.     xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xmlns:aop="http://www.springframework.org/schema/aop"  
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd   
  7.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">  
  8.     <bean  
  9.         id="hello"  
  10.         class="org.zlex.aop.SayHello" />  
  11.     <!-- after -->  
  12.     <bean  
  13.         id="after"  
  14.         class="org.zlex.aop.After" />  
  15.     <aop:config>  
  16.         <aop:pointcut  
  17.             id="afterPoint"  
  18.             expression="execution(* org.zlex.aop.Hello.sayHelloAfter(..))" />  
  19.         <aop:aspect  
  20.             id="afterAspect"  
  21.             ref="after">  
  22.             <aop:after  
  23.                 method="invoke"  
  24.                 pointcut-ref="afterPoint" />  
  25.         </aop:aspect>  
  26.     </aop:config>  
  27.     <!-- before -->  
  28.     <bean  
  29.         id="before"  
  30.         class="org.zlex.aop.Before" />  
  31.     <aop:config>  
  32.         <aop:pointcut  
  33.             id="beforePoint"  
  34.             expression="execution(* org.zlex.aop.Hello.sayHelloBefore(..))" />  
  35.         <aop:aspect  
  36.             id="beforeAspect"  
  37.             ref="before">  
  38.             <aop:before  
  39.                 method="invoke"  
  40.                 pointcut-ref="beforePoint" />  
  41.         </aop:aspect>  
  42.     </aop:config>  
  43.     <!-- around -->  
  44.     <bean  
  45.         id="around"  
  46.         class="org.zlex.aop.Around" />  
  47.     <aop:config>  
  48.         <aop:pointcut  
  49.             id="aroundPoint"  
  50.             expression="execution(* org.zlex.aop.Hello.sayHelloAround(..))" />  
  51.         <aop:aspect  
  52.             id="aroundAspect"  
  53.             ref="around">  
  54.             <aop:around  
  55.                 method="invoke"  
  56.                 pointcut-ref="aroundPoint" />  
  57.         </aop:aspect>  
  58.     </aop:config>  
  59.     <!-- introduction -->  
  60.     <!--    
  61.     .*+是用于包下的，不是用于接口   
  62.     +定义目标为该接口的所有实现类   
  63.      -->  
  64.     <bean  
  65.         id="introduction"  
  66.         class="org.zlex.aop.Introduction" />  
  67.     <bean  
  68.         id="introductionOk"  
  69.         class="org.zlex.aop.IntroductionOk" />  
  70.     <aop:config>  
  71.         <aop:aspect  
  72.             ref="introduction">  
  73.             <aop:pointcut  
  74.                 id="introductionPoint"  
  75.                 expression="execution(* org.zlex.aop.Hello.sayHelloIntroduction(..))" />  
  76.             <aop:declare-parents  
  77.                 implement-interface="org.zlex.aop.Ok"  
  78.                 types-matching="org.zlex.aop.Hello+"  
  79.                 delegate-ref="introductionOk" />  
  80.             <aop:around  
  81.                 method="invoke"  
  82.                 pointcut-ref="introductionPoint" />  
  83.         </aop:aspect>  
  84.     </aop:config>  
  85. </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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
	<bean
		id="hello"
		class="org.zlex.aop.SayHello" />
	<!-- after -->
	<bean
		id="after"
		class="org.zlex.aop.After" />
	<aop:config>
		<aop:pointcut
			id="afterPoint"
			expression="execution(* org.zlex.aop.Hello.sayHelloAfter(..))" />
		<aop:aspect
			id="afterAspect"
			ref="after">
			<aop:after
				method="invoke"
				pointcut-ref="afterPoint" />
		</aop:aspect>
	</aop:config>
	<!-- before -->
	<bean
		id="before"
		class="org.zlex.aop.Before" />
	<aop:config>
		<aop:pointcut
			id="beforePoint"
			expression="execution(* org.zlex.aop.Hello.sayHelloBefore(..))" />
		<aop:aspect
			id="beforeAspect"
			ref="before">
			<aop:before
				method="invoke"
				pointcut-ref="beforePoint" />
		</aop:aspect>
	</aop:config>
	<!-- around -->
	<bean
		id="around"
		class="org.zlex.aop.Around" />
	<aop:config>
		<aop:pointcut
			id="aroundPoint"
			expression="execution(* org.zlex.aop.Hello.sayHelloAround(..))" />
		<aop:aspect
			id="aroundAspect"
			ref="around">
			<aop:around
				method="invoke"
				pointcut-ref="aroundPoint" />
		</aop:aspect>
	</aop:config>
	<!-- introduction -->
	<!-- 
	.*+是用于包下的，不是用于接口
	+定义目标为该接口的所有实现类
	 -->
	<bean
		id="introduction"
		class="org.zlex.aop.Introduction" />
	<bean
		id="introductionOk"
		class="org.zlex.aop.IntroductionOk" />
	<aop:config>
		<aop:aspect
			ref="introduction">
			<aop:pointcut
				id="introductionPoint"
				expression="execution(* org.zlex.aop.Hello.sayHelloIntroduction(..))" />
			<aop:declare-parents
				implement-interface="org.zlex.aop.Ok"
				types-matching="org.zlex.aop.Hello+"
				delegate-ref="introductionOk" />
			<aop:around
				method="invoke"
				pointcut-ref="introductionPoint" />
		</aop:aspect>
	</aop:config>
</beans>


执行查看日志：

引用

Before:sayHelloBefore
say SayHello before!
say Hello after!
After:sayHelloAfter
Around:sayHelloAround
say Hello around!
Introduction:sayHelloIntroduction
say Hello introduction!
Ok!


仔细观察

引用

Before:sayHelloBefore
say Hello before!


在输出say Hello before!前输出Before:sayHelloBefore

引用

say Hello after!
After:sayHelloAfter


在输出say Hello after!后输出After:sayHelloAfter
Around比较特殊，可以用ProceedingJoinPoint调用proceed()方法

引用

Around:sayHelloAround
say Hello around!

 

引用

Introduction:sayHelloIntroduction
say Hello introduction!
Ok!


同样是Hello接口，在执行了sayHelloIntroduction方法时被拦截，同时输出say Hello introduction!，此时还可以执行Ok的方法输出

引用
Ok!

。显然，Hello的实现类多了Ok接口的本领。
Spring Beans 结构图如下：

如此这样，就可以控制AOP了，当前资料少，实例也少，继续研究！希望能做出来点实际的东西。

  • aop.zip (18.5 KB)
  • 下载次数: 0
  • 大小: 164.9 KB
分享到：
| 关于Spring中Commons Validator的使用说明
评论
发表评论

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

相关推荐

    spring-aop.jar各个版本

    spring-aop-2.0.jar spring-aop-2.5.1.jar spring-aop-2.5.2.jar spring-aop-2.5.4.jar spring-aop-2.5.5.jar spring-aop-2.5.6.jar spring-aop-3.0.0.RELEASE.jar spring-aop-3.0.2.RELEASE.jar spring-aop-sources...

    spring framework 2.0 中文参考手册

    2. **AOP**：Spring 2.0加强了AOP的支持，开发者可以通过定义切面来实现横切关注点，如事务管理、日志记录等，使得代码结构更清晰，提高了代码复用性。 3. **数据访问集成**：Spring提供了对多种数据库访问技术的...

    spring framework 2.0 dist 资源文件

    另外，Spring 2.0引入了AOP（面向切面编程）概念，允许开发者定义横切关注点，如日志、事务管理等，将其与业务逻辑分离，提高了代码的可读性和可维护性。Spring AOP支持基于注解的切面定义，以及自定义通知类型，...

    Spring_2.0.rar

    2. **AOP**：Spring 2.0在AOP方面做了重大改进，提供了更强大的切面定义和通知类型，如前置通知、后置通知、环绕通知等。这使得我们可以更好地实现日志记录、事务管理、安全控制等功能，而不必侵入业务逻辑。 3. **...

    Spring Framework 2.0开发参考手册(中文版chm)

    6. 研究Spring的其他模块，如批处理、企业集成和消息队列，以提升应用的灵活性和可扩展性。 通过深入研读这份手册，开发者不仅可以提升Spring框架的使用技能，还能对软件架构设计有更深刻的理解，为构建高效、稳定...

    springframework2.0

    Spring 2.0增强了对AOP的支持，添加了注解驱动的AOP，使得无需XML配置即可创建切面。 3. **Bean工厂与ApplicationContext**：Spring 2.0引入了ApplicationContext，它是Bean工厂的高级形式，提供了更多企业级服务，...

    spring-framework-2.0

    2. **AOP（Aspect-Oriented Programming, 面向切面编程）**：Spring 2.0提供了增强的AOP支持，包括自定义注解，可以创建可重用的横切关注点，如事务管理、日志记录等，使代码更清晰，职责划分更明确。 3. **数据...

    Spring-Security2.0 和 3.0中文文档

    在Spring Security 2.0 和 3.0 版本中，有一些重要的变化和新特性： 1. **模块化架构**： Spring Security 2.0 提供了基础的认证和授权功能，而3.0进一步强化了模块化设计。这使得开发者可以根据项目需求选择合适...

    spring2.0 核心jar包

    Spring2.0的核心jar包通常包括`spring-core.jar`、`spring-beans.jar`、`spring-context.jar`、`spring-aop.jar`、`spring-web.jar`等，这些jar包分别包含了Spring框架的基础组件、bean管理、上下文、AOP和Web相关...

    spring-framework-2.0 Java源代码，spring2源代码

    2. **AOP（面向切面编程）**：Spring 2.0提供了基于代理的AOP实现，允许开发者定义切面，实现跨切面的关注点，如日志、事务管理等。AOP使得这些通用功能的实现变得更加简洁，降低了代码的重复性。 3. **Bean工厂与...

    Spring2.0中文教程

    Spring 2.0提供了两种AOP代理：JDK动态代理和CGLIB代理。JDK代理用于接口实现类，而CGLIB代理则用于没有接口或不希望修改接口的类，以实现AOP增强功能。 11. **Spring Batch** Spring Batch是Spring 2.0中的...

    Spring2.0宝典源代码

    1. **AOP（面向切面编程）增强**：Spring 2.0加强了对AOP的支持，允许开发者定义更复杂的切面，如注解驱动的切面，提供了更多的通知类型，如around、before、after等，使得代码更加模块化和可维护。 2. **注解驱动...

    Spring Security 2.0.x完全中文参考文档

    ### Spring Security 2.0.x完全中文参考文档 #### 序言 本文档旨在为用户提供一份详尽且全面的Spring Security 2.0.x版本的中文指南，它不仅覆盖了核心概念、配置方法以及实际应用案例，还深入探讨了安全框架的...

    Spring2.0整合Struts2.0

    **Spring 2.0** 是Spring框架的一个重要版本，引入了许多新特性，如支持JSR-250规范、改进的AOP支持、数据源管理以及对Java Persistence API (JPA)的支持。这一版本加强了Spring作为企业级应用基础架构容器的能力，...

    SPRING2.0中文文档

    Spring 2.0的AOP增强了切入点表达式，使得定位切点更加灵活，并引入了基于注解的切面定义，让切面编写更加直观。 四、数据访问集成 Spring 2.0在数据访问层提供了对各种持久化技术的集成，包括JDBC、ORM（Hibernate...

    spring2.0中文手册及使用指南 chm

    Spring 2.0 是一个非常重要的Java框架，它在企业级应用开发中占据了核心地位，尤其是在基于Java的轻量级应用程序上下文（IoC）和面向切面编程（AOP）方面。本手册和使用指南提供了全面的Spring 2.0相关知识，包括其...

    spring2.0_jar

    Spring 2.0 是一个重要的Java应用程序框架，主要用于构建企业级的Java应用。这个压缩包包含了一系列Spring框架的核心组件和其他相关库，使得开发者能够轻松地实现依赖注入、面向切面编程（AOP）以及数据库操作等功能...

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