Spring的注解方式实现AOP

Spring对AOP的实现提供了很好的支持。下面我们就使用Spring的注解来完成AOP做一个例子。

首先,为了使用Spring的AOP注解功能,必须导入如下几个包。aspectjrt.jar,aspectjweaver.jar,cglib-nodep.jar.

然后我们写一个接口

[java] view plain copy

print?

  1. package com.bird.service;
  2. public interface PersonServer {
  3. public void save(String name);
  4. public void update(String name, Integer id);
  5. public String getPersonName(Integer id);
  6. }

和一个接口实现类

[java] view plain copy

print?

  1. package com.bird.service.impl;
  2. import com.bird.service.PersonServer;
  3. public class PersonServiceBean implements PersonServer{
  4. @Override
  5. public void save(String name) {
  6. System.out.println("我是save方法");
  7. //  throw new RuntimeException();
  8. }
  9. @Override
  10. public void update(String name, Integer id) {
  11. System.out.println("我是update()方法");
  12. }
  13. @Override
  14. public String getPersonName(Integer id) {
  15. System.out.println("我是getPersonName()方法");
  16. return "xxx";
  17. }
  18. }

下面使用Spring注解方式对这个Bean进行方法拦截

[java] view plain copy

print?

  1. package com.bird.service;
  2. import org.aspectj.lang.ProceedingJoinPoint;
  3. import org.aspectj.lang.annotation.After;
  4. import org.aspectj.lang.annotation.AfterReturning;
  5. import org.aspectj.lang.annotation.AfterThrowing;
  6. import org.aspectj.lang.annotation.Around;
  7. import org.aspectj.lang.annotation.Aspect;
  8. import org.aspectj.lang.annotation.Before;
  9. import org.aspectj.lang.annotation.Pointcut;
  10. /**
  11. * 切面
  12. * @author Bird
  13. *
  14. */
  15. @Aspect
  16. public class MyInterceptor {
  17. @Pointcut("execution(* com.bird.service.impl.PersonServiceBean.*(..))")
  18. private void anyMethod(){}//定义一个切入点
  19. @Before("anyMethod() && args(name)")
  20. public void doAccessCheck(String name){
  21. System.out.println(name);
  22. System.out.println("前置通知");
  23. }
  24. @AfterReturning("anyMethod()")
  25. public void doAfter(){
  26. System.out.println("后置通知");
  27. }
  28. @After("anyMethod()")
  29. public void after(){
  30. System.out.println("最终通知");
  31. }
  32. @AfterThrowing("anyMethod()")
  33. public void doAfterThrow(){
  34. System.out.println("例外通知");
  35. }
  36. @Around("anyMethod()")
  37. public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{
  38. System.out.println("进入环绕通知");
  39. Object object = pjp.proceed();//执行该方法
  40. System.out.println("退出方法");
  41. return object;
  42. }
  43. }

[java] view plain copy

print?

  1. @Pointcut("execution(* com.bird.service.impl.PersonServiceBean.*(..))")

这句话是方法切入点,execution为执行的意思,*代表任意返回值,然后是包名,.*意思是包下面的所有子包。(..)代

表各种方法.

然后下面的注解就比较简单了,就是在使用方法前和中,还有环绕拦截/

然后在Spring的配置文件中继续配置Bean,需要打开AOP命名空间

[java] view plain copy

print?

  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. xsi:schemaLocation="
  6. http://www.springframework.org/schema/beans
  7. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  8. http://www.springframework.org/schema/aop
  9. http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
  10. <aop:aspectj-autoproxy/>
  11. <bean id="personServiceBean" class="com.bird.service.impl.PersonServiceBean"/>
  12. <bean id="myInterceptor" class="com.bird.service.MyInterceptor"/>
  13. </beans>

然后建立一个Junit测试

[java] view plain copy

print?

  1. package junit.test;
  2. import org.junit.Test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5. import com.bird.service.PersonServer;
  6. public class SpringAOPTest {
  7. @Test
  8. public void inteceptorTest(){
  9. ApplicationContext ctx = new ClassPathXmlApplicationContext("beanAop.xml");
  10. PersonServer bean = (PersonServer)ctx.getBean("personServiceBean");
  11. bean.save(null);
  12. }
  13. }

测试结果为

[java] view plain copy

print?

    1. 2012-3-12 18:08:39 org.springframework.context.support.AbstractApplicationContext prepareRefresh
    2. 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@dd20f6: display name [org.springframework.context.support.ClassPathXmlApplicationContext@dd20f6]; startup date [Mon Mar 12 18:08:39 CST 2012]; root of context hierarchy
    3. 2012-3-12 18:08:40 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
    4. 信息: Loading XML bean definitions from class path resource [beanAop.xml]
    5. 2012-3-12 18:08:40 org.springframework.context.support.AbstractApplicationContext obtainFreshBeanFactory
    6. 信息: Bean factory for application context [org.springframework.context.support.ClassPathXmlApplicationContext@dd20f6]: org.springframework.beans.factory.support.DefaultListableBeanFactory@b0bad7
    7. 2012-3-12 18:08:40 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
    8. 信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@b0bad7: defining beans [org.springframework.aop.config.internalAutoProxyCreator,personServiceBean,myInterceptor]; root of factory hierarchy
    9. null
    10. 前置通知
    11. 进入环绕通知
    12. 我是save方法
    13. 后置通知
    14. 退出方法
    15. 最终通知
时间: 2024-10-12 10:10:53

Spring的注解方式实现AOP的相关文章

使用Spring的注解方式实现AOP的细节

前面我们已经入门使用Spring的注解方式实现AOP了,现在我们再来学习使用Spring的注解方式实现AOP的一些细节.本文是建立在使用Spring的注解方式实现AOP入门的案例的基础之上的. 本文是来讲解使用Spring的注解方式实现AOP的一些细节,其实说白了就是学习如何使用各种通知而已,例如前置通知.后置通知.异常通知.最终通知.环绕通知等,之前我们已经学习了前置通知,现在就来学习剩余的通知. 我们先来看后置通知,此时须将MyInterceptor类的代码修改为: /** * 切面 * @

使用Spring的注解方式实现AOP入门

首先在Eclipse中新建一个普通的Java Project,名称为springAOP.为了使用Spring的注解方式进行面向切面编程,需要在springAOP项目中加入与AOP相关的jar包,spring aop需要额外的jar包有: com.springsource.org.aopalliance-1.0.0.jar com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar spring-aop-4.2.5.RELEASE.jar sprin

使用spring的注解方式实现aop

首先是导入一些的jar包 切面的代码 @Component @Aspect public class Advice { @Before("init()") public void log(){ System.out.println("before do..."); } @Pointcut("execution(* service.*.*(..))")//方法切入点,execution为执行的意思,*代表任意返回值,然后是包名,.*意思是包下面的所

使用注解方式实现 AOP和IoC

使用注解方式实现AOP和IoC IOC和DI的注解 IOC: @Component:实现Bean组件的定义 @Repository:用于标注DAO类,功能与@Component作用相当 @Service:用于标注业务类 @Controller:用于标注控制器 DI: @Resource(name="userService") 默认ByName方式,如果name确实默认按照ByType方式注入 @Autowired 默认ByType方式,如果出现同名类,则不能按照Type进行注入 需要使

BlazeDS+Spring+SpringMVC 注解方式

BlazeDS是Flex与java通信的众多方式中的一种,其优点在于开源使用起来方便且性能能够满足中小型应用的常规要求,所以是很多中小型java应用与flex通信的首选方式. 而使用BlazeDS手动配置的配置文件比较多,若是借用spring的注解方式就能方便地进行配置了.以下为配置的步骤: 第一步当然是下载BlazeDS的相关jar包了,下载地址:http://sourceforge.net/adobe/blazeds/wiki/Downloads/; 还需要下载spring的相关包,这里不再

Spring 使用注解方式进行事务管理

使用步骤: 步骤一.在spring配置文件中引入<tx:>命名空间<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation

【转】Spring 使用注解方式进行事务管理

Spring 使用注解方式进行事务管理 原文链接 http://www.cnblogs.com/younggun/archive/2013/07/16/3193800.html#top 使用步骤: 步骤一.在spring配置文件中引入<tx:>命名空间 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-i

Spring之AOP基本概念及通过注解方式配置AOP

为什么使用AOP 传统方法 AOP前前奏 首先考虑一个问题,假设我们要设计一个计算器,有如下两个需求: - 在程序运行期间追踪正在放生的活动 - 希望计算器只能处理正数的运算 通常我们会用如下代码进行实现: 定义一个接口: public interface ArithmeticCalculator { int add(int i, int j); int sub(int i, int j); int mul(int i, int j); int div(int i, int j); } 实现类(

Spring(十一)使用Spring的注解方式实现面向切面技术AOP

AOP涉及到的一些概念: Aspect(切面):横切性关注点的抽象即为切面,与类相似,只是两者的关注度不一样,类是对物体特征的抽象,而切面是横切性关注点的抽象. Joinpoint(连接点):所谓连接点指那些被拦截的点.在Spring中,这些点指的是方法,因为Spring只支持方法类型的连接点(实际上Joinpoint还可以是field或类构造器). Pointcut(切入点):所谓切入点是指我们要对那些Joinpoint进行拦截的定义. Advice(通知):所谓通知是指拦截到Joinpoin