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

Spring基于@AspectJ AOP例子

 
阅读更多

1.使用前准备

 

      Spring在修理@Aspect注解表达式时,需要将Spring的asm模块加到类路径中。asm是轻量级的字节码处理框架,因为java的反射机制无法获取入参名,Spring就利用asm处理@AspectJ中所描述的方法入参名。

      此外还需要加入aspectj.weaver和aspectj.tools类包。

 

2.配置使用@AspectJ切面

自动代理的配置

<aop:aspectj-autoproxy proxy-target-class="true"/> 或<aop:aspectj-autoproxy/>

 

<?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:aspectj-autoproxy proxy-target-class="true"/>
</beans>

 3.通过注解对类的进行设置

 @Before

@After

@AfterReturning

@Around

@AfterThrowing

 

package com.baobaotao.aspectj.advanced;

import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class TestAspect {
	//-------------复合运算----------
//	@Before("!target(com.baobaotao.NaiveWaiter) "+
//			"&& execution(* serveTo(..)))")
//	public void notServeInNaiveWaiter() {
//		System.out.println("--notServeInNaiveWaiter() executed!--");
//	}
//	@After("within(com.baobaotao.*) "
//			+ " && execution(* greetTo(..)))")
//	public void greeToFun() {
//		System.out.println("--greeToFun() executed!--");
//	}
//	
//	@AfterReturning("target(com.baobaotao.Waiter) || "+
//			        " target(com.baobaotao.Seller)")
//	public void waiterOrSeller(){
//		System.out.println("--waiterOrSeller() executed!--");
//	}
	
//	//------------引用命名切点----------//
//	@Before("TestNamePointcut.inPkgGreetTo()")
//	public void pkgGreetTo(){
//		System.out.println("--pkgGreetTo() executed!--");
//	}
//
//	@Before("!target(com.baobaotao.NaiveWaiter) && "
//			+"TestNamePointcut.inPkgGreetTo()")
//	public void pkgGreetToNotNaiveWaiter(){
//		System.out.println("--pkgGreetToNotNaiveWaiter() executed!--");
//	}
//
    //------------访问连接点对象----------//
//	@Around("execution(* greetTo(..)) && target(com.baobaotao.NaiveWaiter)")
//	public void joinPointAccess(ProceedingJoinPoint pjp) throws Throwable{
//		System.out.println("------joinPointAccess-------");
//		System.out.println("args[0]:"+pjp.getArgs()[0]);		
//		System.out.println("signature:"+pjp.getTarget().getClass());
//		pjp.proceed();
//		System.out.println("-------joinPointAccess-------");
//	}
	
  //------------绑定连接点参数----------//
//	@Before("target(com.baobaotao.NaiveWaiter) && args(name,num,..)")
//	public void bindJoinPointParams(int num,String name){
//	   System.out.println("----bindJoinPointParams()----");
//	   System.out.println("name:"+name);
//	   System.out.println("num:"+num);
//	   System.out.println("----bindJoinPointParams()----");
//	}

  //------------绑定代理对象----------//
//	@Before("execution(* greetTo(..)) && this(waiter)")
//	@Before("this(waiter)")
//	public void bindProxyObj(Waiter waiter){
//	   System.out.println("----bindProxyObj()----");
//	   System.out.println(waiter.getClass().getName());
//	   System.out.println("----bindProxyObj()----");
//	}
	
	  //------------绑定类标注对象----------//
//	@Before("@within(m)")
//	public void bindTypeAnnoObject(Monitorable m){
//	   System.out.println("----bindTypeAnnoObject()----");
//	   System.out.println(m.getClass().getName());
//	   System.out.println("----bindTypeAnnoObject()----");
//	}
    //------------绑定抛出的异常----------//
//	@AfterReturning(value="target(com.baobaotao.SmartSeller)",returning="retVal")
//	public void bingReturnValue(int retVal){
//	   System.out.println("----bingReturnValue()----");
//	   System.out.println("returnValue:"+retVal);
//	   System.out.println("----bingReturnValue()----");
//	}
	
//    //------------绑定抛出的异常----------//
	@AfterThrowing(value="target(com.baobaotao.SmartSeller)",throwing="iae")
	public void bindException(IllegalArgumentException iae){
	   System.out.println("----bindException()----");
	   System.out.println("exception:"+iae.getMessage());
	   System.out.println("----bindException()----");
	}	

}

 

 

其中相关的类

 

 

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


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

}



@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+"...");
	}
}


public interface Seller {
  int sell(String goods,String clientName);
}
public class SmartSeller implements Seller {

	public int sell(String goods,String clientName) {
		System.out.println("SmartSeller: sell "+goods +" to "+clientName+"...");
		return 100;
	}
	
	public void checkBill(int billId){
		if(billId == 1) throw new IllegalArgumentException("iae Exception");
		else throw new RuntimeException("re Exception");
	}
}



public class TestNamePointcut {
	@Pointcut("within(com.baobaotao.*)")
	private void inPackage(){}
	
	@Pointcut("execution(* greetTo(..)))")
    protected void greetTo(){}

    @Pointcut("inPackage() and greetTo()")
    public void inPkgGreetTo(){}
}

 

 

3.测试例子

 

package com.baobaotao.aspectj.advanced;

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

import com.baobaotao.SmartSeller;
import com.baobaotao.Waiter;

public class AdvancedTest {
	public static void main(String[] args) {
		String configPath = "com/baobaotao/aspectj/advanced/beans.xml";
		ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
		Waiter naiveWaiter = (Waiter) ctx.getBean("naiveWaiter");
		//NaiveWaiter naiveWaiter1 = (NaiveWaiter) ctx.getBean("naiveWaiter");
		Waiter naughtyWaiter = (Waiter) ctx.getBean("naughtyWaiter");
//		naiveWaiter.greetTo("John");
//		naiveWaiter.serveTo("John");
//		naughtyWaiter.greetTo("Tom");
//		naughtyWaiter.serveTo("Tom");
		
        //--通过joinPoint接口访问连接点上下文信息
//		naiveWaiter.greetTo("John");
		
		//--绑定连接点参数
		//((NaiveWaiter)naiveWaiter).smile("John",2);
		//naiveWaiter1.smile("John",2);
		
		//--绑定代理对象
//		naiveWaiter.greetTo("John");
		
		//--绑定类注解
//		((NaiveWaiter)naiveWaiter).greetTo("John");

		//绑定返回值
//		SmartSeller seller = (SmartSeller) ctx.getBean("seller");
//		seller.sell("Beer","John");	
		
		//绑定异常
		SmartSeller seller = (SmartSeller) ctx.getBean("seller");
		seller.checkBill(2);
		//seller.checkBill(1);
	}
}

 

 

 

分享到:
评论

相关推荐

    Spring @AspectJ 实现AOP 入门例子

    本篇文章将深入探讨如何利用Spring的@AspectJ注解来实现AOP,这是一个入门级别的例子,旨在帮助开发者理解并掌握这一关键特性。 首先,我们要明白什么是AOP。面向切面编程是一种编程范式,它允许程序员定义“切面”...

    征服Spring AOP—— @AspectJ

    @AspectJ是Spring AOP的一种注解驱动方式,它极大地简化了AOP的使用。本篇文章将深入探讨@AspectJ的使用方法和背后的原理。 首先,我们需要理解面向切面编程(AOP)的基本概念。AOP是一种编程范式,它允许开发者将...

    @AspectJ配置Spring AOP,demo

    `基于@AspectJ配置Spring AOP之一 - 飞扬部落编程仓库-专注编程,网站,专业技术.htm`和其关联的`_files`目录可能包含了一个详细的教程或演示如何配置和运行@AspectJ的Spring AOP应用程序。 通过以上内容,我们可以...

    Spring AOP 概念理解及@AspectJ支持

    Spring AOP的实现基于动态代理,对于接口实现类,它使用Java的`java.lang.reflect.Proxy`类来创建代理对象;对于没有接口的类,Spring使用CGLIB库生成子类。在运行时,Spring AOP会根据切面定义生成代理对象,然后...

    Spring的AOP实例(XML+@AspectJ双版本解析+源码+类库)

    在Java世界中,Spring框架以其强大的功能和灵活性深受开发者喜爱,尤其在面向切面编程(AOP)方面,Spring提供了两种主要的实现方式:XML配置和@AspectJ注解。本篇文章将深入探讨这两个版本的AOP实现,并结合源码...

    Spring 使用AspectJ 实现 AOP之前置通知小例子

    标题提到的"Spring 使用AspectJ 实现 AOP之前置通知小例子",指的是利用AspectJ在Spring中实现AOP的一种特定类型的通知——前置通知(Before advice)。前置通知在目标方法执行之前运行,但不会阻止方法的执行。这种...

    spring对AOP的支持(使用AspectJ进行AOP演示)

    Spring 提供了两种主要的 AOP 实现方式:基于代理的和基于 AspectJ 的。基于代理的方式是 Spring 默认的实现,它通过 JdkDynamicProxy 或 CGLIB 创建代理对象来实现切面。而基于 AspectJ 的方式则更为强大,它允许...

    简单spring aop 例子

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

    基于框架的Web开发-基于AspectJ的AOP.doc

    创建一个简单的@AspectJ AOP例子,我们可以从定义切面开始。假设有一个`Performance`接口,代表各种表演,只有一个`perform()`方法。然后创建`Ballet`类作为`Performance`接口的实现,它在`perform()`方法中输出...

    spring AspectJ aop学习

    当我们谈论"spring AspectJ aop学习"时,我们将深入探讨Spring AOP如何结合AspectJ来实现更灵活的模块化和解耦。 首先,让我们理解AOP的概念。面向切面编程(Aspect Oriented Programming)是一种编程范式,旨在将...

    Spring AOP + AspectJ annotation example

    AspectJ是Spring AOP支持的一种强大的、独立的AOP语言,它提供了注解来简化切面的定义。本篇将深入探讨如何结合Spring AOP和AspectJ注解进行实践。 首先,我们需要理解AOP的基本概念。面向切面编程是一种编程范式,...

    spring mvc框架下的aop例子

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

    Spring基于注解实现AOP

    &lt;aop:aspectj-autoproxy /&gt; ``` 或者在Java配置类中添加: ```java @Configuration @EnableAspectJAutoProxy public class AppConfig { // ... } ``` 这会让Spring扫描并自动代理符合切点定义的bean,从而执行...

    Spring2.5使用AOP需要的aspectJ

    AspectJ是一个成熟的AOP框架,Spring在其AOP实现中整合了AspectJ,提供了更强大的面向切面编程能力。本篇文章将详细探讨在Spring 2.5中使用AspectJ进行AOP开发所需的知识点。 首先,我们需要理解AOP的核心概念: 1....

    SpringAOP+AspectJ

    在这个例子中,我们将重点讨论Spring AOP以及如何结合AspectJ进行更深入的切面编程。 **一、Spring AOP基础** Spring AOP是Spring框架的一部分,它提供了一种在运行时动态地将行为加入到对象中的方法。AOP的核心...

    Spring AOP + AspectJ in XML 配置示例

    这篇博客“Spring AOP + AspectJ in XML配置示例”旨在指导开发者如何在XML配置中实现Spring AOP和AspectJ的结合。 首先,我们需要理解AOP的基本概念。AOP通过将关注点(如日志、事务管理)与业务逻辑分离,提高了...

    spring-boot aop

    默认情况下,Spring使用基于Java的代理,但对于需要在静态方法或非Spring管理对象上应用AOP的情况,可能需要使用CGLIB或AspectJ字节码代理。 5. **理解代理行为**:理解Spring AOP代理的工作方式很重要,因为这可能...

    spring4 AOP 面向切面编程@Aspect

    除了注解式AOP,Spring还支持基于XML的配置,但注解方式更简洁且易于理解和维护。在实际应用中,通常会结合使用`@Aspect`和其他Spring注解如`@Service`、`@Repository`和`@Controller`,以实现全面的依赖注入和AOP...

Global site tag (gtag.js) - Google Analytics