`
szlxh002
  • 浏览: 34488 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

Spring基于Schema配置切面的例子

 
阅读更多

       如果项目不能使用JDK1.5以上,无法使用@AspectJ进行注解,Spring提供了基于Schema配置的方法,代替基于@AspectJ注解要面的方式。

 

1.XML配置

 

使用<aop:advisor>或<aop:aspect>进行配置

<?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-3.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
	<aop:config proxy-target-class="true">
	<!--  
	    <aop:advisor advice-ref="testAdvice"  pointcut="execution(* com..*.Waiter.greetTo(..))"/>  
	    -->
		<aop:aspect ref="adviceMethods">
			<aop:before method="preGreeting"
				pointcut="target(com.baobaotao.NaiveWaiter) and args(name)"
				arg-names="name" />
			<aop:after-returning method="afterReturning"
				pointcut="target(com.baobaotao.SmartSeller)" returning="retVal" />
			<aop:around method="aroundMethod"
				pointcut="execution(* serveTo(..)) and within(com.baobaotao.Waiter)" />
			<aop:after-throwing method="afterThrowingMethod"
				pointcut="target(com.baobaotao.SmartSeller) and execution(* checkBill(..))"
				throwing="iae" />
						<!--
			<aop:after method="afterMethod"
				pointcut="execution(* com..*.Waiter.greetTo(..))" />
		
			<aop:declare-parents
				implement-interface="com.baobaotao.Seller"
				default-impl="com.baobaotao.SmartSeller"
				types-matching="com.baobaotao.Waiter+" />
				-->
            <aop:before method="bindParams" 
                   pointcut="target(com.baobaotao.NaiveWaiter) and args(name,num,..)"/>
		</aop:aspect>
	</aop:config>
    <bean id="testAdvice" class="com.baobaotao.schema.TestBeforeAdvice"/>
	<bean id="adviceMethods" class="com.baobaotao.schema.AdviceMethods" />
	<bean id="naiveWaiter" class="com.baobaotao.NaiveWaiter" />
	<bean id="naughtyWaiter" class="com.baobaotao.NaughtyWaiter" />
	<bean id="seller" class="com.baobaotao.SmartSeller" />
</beans>

 

 

 

2.相关的类和接口

package com.baobaotao.schema;

import org.aspectj.lang.ProceedingJoinPoint;


public class AdviceMethods {
	public void preGreeting(String name) {
		System.out.println("--how are you!--");
		System.out.println(name);
	}

    //后置增强对应方法
	public void afterReturning(int retVal){
	   System.out.println("----afterReturning()----");
	   System.out.println("returnValue:"+retVal);
	   System.out.println("----afterReturning()----");
	}

    //环绕增强对应方法
	public void aroundMethod(ProceedingJoinPoint pjp){
	   System.out.println("----aroundMethod()----");
	   System.out.println("args[0]:"+pjp.getArgs()[0]);
	   System.out.println("----aroundMethod()----");
	}

    //抛出异常增强
	public void afterThrowingMethod(IllegalArgumentException iae){
	   System.out.println("----afterThrowingMethod()----");
	   System.out.println("exception msg:"+iae.getMessage());
	   System.out.println("----afterThrowingMethod()----");
	}

    //final增强
	public void afterMethod(){
	   System.out.println("----afterMethod()----");
	}
	

	
      //------------绑定连接点参数----------//
	public void bindParams(int num,String name){
	   System.out.println("----bindParams()----");
	   System.out.println("name:"+name);
	   System.out.println("num:"+num);
	   System.out.println("----bindParams()----");
	}
}


public class TestBeforeAdvice implements MethodBeforeAdvice {

	public void before(Method method, Object[] args, Object target)
			throws Throwable {
        System.out.println("------TestBeforeAdvice------");
        System.out.println("clientName:"+args[0]);
        System.out.println("------TestBeforeAdvice------");
	}
}

public interface Waiter {
	@NeedTest
	public void greetTo(String clientName);	
	public void serveTo(String clientName);
}


@Monitorable
public class NaiveWaiter implements Waiter {
	@NeedTest
	public void greetTo(String clientName) {
		System.out.println("NaiveWaiter:greet to "+clientName+"...");
	}	
	@NeedTest
	public void serveTo(String clientName){
		System.out.println("NaiveWaiter:serving "+clientName+"...");
	}
	public void smile(String clientName,int times){
		System.out.println("NaiveWaiter:smile to  "+clientName+ times+"times...");
	}	
}


public class NaughtyWaiter implements Waiter {
	public void greetTo(String clientName) {
		System.out.println("NaughtyWaiter:greet to "+clientName+"...");
	}	
	public void serveTo(String clientName){
		System.out.println("NaughtyWaiter:serving "+clientName+"...");
	}
	public void joke(String clientName,int times){
        	System.out.println("NaughtyWaiter:play "+times+" jokes to "+clientName+"...");
	}
}


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Monitorable {

}

 

 

3.测试

 

package com.baobaotao.schema;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.baobaotao.NaiveWaiter;
import com.baobaotao.Seller;
import com.baobaotao.SmartSeller;
import com.baobaotao.Waiter;

public class SchemaAspectTest {
	public static void main(String[] args) {
		String configPath = "com/baobaotao/schema/beans.xml";
		ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
		Waiter naiveWaiter = (Waiter) ctx.getBean("naiveWaiter");
		Waiter naughtyWaiter = (Waiter) ctx.getBean("naughtyWaiter");	
		Seller seller = (Seller) ctx.getBean("seller");
		naiveWaiter.greetTo("John");
		naughtyWaiter.greetTo("Tom");
		
		//后置增强
		((SmartSeller)seller).sell("Beer","John");
		
		//环境增强
//		naiveWaiter.serveTo("John");
		
		//抛出异常增强
//		((SmartSeller)seller).checkBill(1);
		
		//final增强
//		naiveWaiter.greetTo("John");
		
		//引入增强
//		((Seller)naiveWaiter).sell("Beer","John");
//		((NaiveWaiter)naiveWaiter).smile("John", 2);
		
		//advisor
		//naiveWaiter.greetTo("John");
		
	}
}

 

 

 

分享到:
评论

相关推荐

    利用SPring AOP配置切面的一个例子

    本文将通过一个具体的例子来介绍如何在Spring框架中使用面向切面编程(Aspect Oriented Programming, AOP)。我们将关注如何定义一个切面(Aspect),以及如何在目标方法(即被通知的方法)执行前后添加特定的行为。...

    Spring AOP之基于Schema配置总结与案例

    下面是一个简单的基于Schema配置的Spring AOP例子: ```xml (* com.example.service.*.*(..))"/&gt; (* com.example.service.*.*(..))"/&gt; ``` 在这个例子中,我们创建了一个名为`loggingAspect`的切面,...

    Spring Aop Schema实现

    总结,Spring AOP Schema实现提供了灵活的XML配置方式来定义和管理切面,通过切点表达式选择合适的连接点,配合不同的通知类型,可以方便地实现面向切面编程,从而降低代码的耦合度,提高代码的可维护性。...

    Spring aop 基于schema的AOP支持及JoinPoint的使用、如何使用CGLIB代理

    Spring AOP提供了基于XML配置的元数据方式来实现切面,这被称为基于Schema的AOP支持。 1. **创建切面(Aspect)** - 切面通常是一个包含切点(Pointcut)和通知(Advice)的类。在XML配置中,我们需要定义一个`...

    征服Spring AOP—— Schema

    本文将深入探讨“Spring AOP——Schema”,这是Spring AOP的一种配置方式,通过XML schema定义切面和通知。 首先,我们需要理解AOP的基本概念。面向切面编程是一种编程范式,旨在提高软件的模块化程度,将关注点...

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

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

    spring mvc框架下的aop例子

    这会告诉Spring容器,我们要启用基于注解的AOP,并代理所有带有切面注解的bean。配置如下: ```xml &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=...

    java入门级spring加maven的小例子

    总结,这个入门级的Spring加Maven的小例子旨在帮助初学者理解如何使用Maven构建Spring项目,以及Spring的核心特性——依赖注入和面向切面编程。通过实践这个例子,你可以更好地掌握这些基础概念,为进一步深入学习...

    Spring—下载与配置

    Spring框架是Java开发中不可或缺的一部分,它以其强大的依赖注入(DI)和面向切面编程(AOP)功能,以及丰富的生态系统,成为了企业级应用开发的标准选择。本篇将详细介绍Spring框架的下载、安装以及基本配置过程。 ...

    spring配置文件详解

    4. `xmlns:aop` 引入了Spring的面向切面编程(AOP)支持,允许声明式地定义切面。 5. `xmlns:tx` 引入了事务管理的支持,方便声明式事务处理。 接下来是`xsi:schemaLocation`,它指定了每个命名空间对应的Schema...

    spring IOC容器依赖注入XML配置

    Spring框架是Java开发中不可或缺的一部分,它以IoC(Inversion of Control,控制反转)和DI(Dependency ...同时,随着对Spring框架的深入了解,你还可以探索更多高级特性,如AOP(面向切面编程)、事务管理等。

    spring配置文件

    Spring框架是Java开发中广泛应用的一个开源框架,以其依赖注入(Dependency Injection,DI)和面向切面编程(Aspect-Oriented Programming,AOP)的核心特性,极大地简化了企业级应用的开发工作。本压缩包文件围绕...

    使用Spring3.0框架开发Hello World例子

    Spring是一个极其流行的企业级Java应用框架,它提供了一种模块化、可扩展的方式来构建应用,强调依赖注入(Dependency Injection,DI)和面向切面编程(Aspect-Oriented Programming,AOP)。 首先,我们需要理解...

    spring第一个例子

    Spring框架是Java开发中广泛应用的一个开源框架,以其依赖注入(Dependency Injection, DI)和面向切面编程(Aspect-Oriented Programming, AOP)的核心特性,极大地简化了企业级应用的开发工作。本教程将带你逐步...

    spring aop的两种配置方式.docx

    在传统的Spring AOP配置中,我们通常会在`applicationContext.xml`或类似的配置文件中定义切面、通知(advice)、切入点(pointcut)等元素。以下是一个简单的示例: ```xml &lt;beans xmlns="http://www.spring...

    spring 配置文件详解.txt

    此外,Spring还提供了面向切面编程(Aspect Oriented Programming,AOP)的支持,用于处理诸如事务管理、日志记录等横切关注点。 在Spring框架中,配置文件扮演着极其重要的角色。通过配置文件,开发人员可以定义...

    spring helloworld 例子

    Spring框架的核心是依赖注入(Dependency Injection,简称DI)和面向切面编程(Aspect-Oriented Programming,简称AOP)。依赖注入使得对象之间的关系得以解耦,提高了代码的可测试性和可维护性;面向切面编程则允许...

    Spring AOP + AspectJ in XML 配置示例

    其中,AOP(Aspect-Oriented Programming,面向切面编程)是Spring框架的一个重要特性,它允许开发者定义“切面”,这些切面可以封装跨越多个对象的行为或责任。而AspectJ是一个独立的AOP框架,提供了更强大的静态织...

    spring-aop实例demo

    在Spring框架中,AOP(面向切面编程)是一种强大的工具,它允许程序员定义“切面”,这些切面封装了应用程序中的交叉关注点,如日志、事务管理、权限检查等。Spring AOP是基于代理的,它可以为普通Java对象(POJOs)...

    Spring--2.Spring 中的 Bean 配置-1

    本文将深入探讨Spring中的Bean配置,主要基于标题"Spring--2.Spring 中的 Bean 配置-1"及其相关的上下文。 首先,我们要理解什么是Bean。在Spring中,Bean指的是由Spring容器管理的对象,这些对象可以通过XML、注解...

Global site tag (gtag.js) - Google Analytics