实例讲解Java的Spring框架中的AOP实现(精华)

http://www.jb51.net/article/83173.htm
这篇文章主要介绍了Java的Spring框架中的AOP实现实例,AOP面向切面编程其实也可以被看作是一个设计模式去规范项目的结构,需要的朋友可以参考下

简介
面向切面编程(AOP)提供另外一种角度来思考程序结构,通过这种方式弥补了面向对象编程(OOP)的不足。 除了类(classes)以外,AOP提供了 切面。切面对关注点进行模块化,例如横切多个类型和对象的事务管理。 (这些关注点术语通常称作 横切(crosscutting) 关注点。)

Spring的一个关键的组件就是 AOP框架。 尽管如此,Spring IoC容器并不依赖于AOP,这意味着你可以自由选择是否使用AOP,AOP提供强大的中间件解决方案,这使得Spring IoC容器更加完善。

Spring 2.0 AOP:

Spring 2.0 引入了一种更加简单并且更强大的方式来自定义切面,用户可以选择使用基于模式(schema-based)的方式或者使用@AspectJ注解。 对于新的应用程序,如果用户使用Java 5开发,我们推荐用户使用@AspectJ风格,否则可以使用基于模式的风格。 这两种风格都完全支持通知(Advice)类型和AspectJ的切入点语言,虽然实际上仍然使用Spring AOP进行织入(Weaving)。

本章主要讨论Spring 2.0对基于模式和基于@AspectJ的AOP支持。 Spring 2.0完全保留了对Spring 1.2的向下兼容性,下一章 将讨论Spring 1.2 API所提供的底层的AOP支持。

Spring中所使用的AOP:

提供声明式企业服务,特别是为了替代EJB声明式服务。 最重要的服务是 声明性事务管理(declarative transaction management) , 这个服务建立在Spring的抽象事务管理(transaction abstraction)之上。

允许用户实现自定义的切面,用AOP来完善OOP的使用。

实例
我们经常会用到的有如下几种
1、基于代理的AOP
2、纯简单java对象切面
3、@Aspect注解形式的
4、注入形式的Aspcet切面
下面我们就一个一个来应用吧.
下面先写一下几个基本的类。
接口类:
 

?
1
2
3
4
5
6
7
8
9
10
/**
  * 定义一个接口
  */
public interface Sleepable {
  
   /**
    * 睡觉方法
    */
   void sleep();
}

实现类:
 

?
1
2
3
4
5
6
7
8
9
10
11
/**
  * 本人实现睡觉接口
  */
public class ChenLliNa implements Sleepable {
  
   @Override
   public void sleep() {
     // TODO Auto-generated method stub
     System.out.println( "乖,该睡觉了!" );
   }
}

增强类: 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
  * 定义一个睡眠的增强 同时实现前置 和后置
  */
public class SleepHelper implements MethodBeforeAdvice, AfterReturningAdvice {
  
   @Override
   public void afterReturning(Object returnValue, Method method,
       Object[] args, Object target) throws Throwable {
      System.out.println( "睡觉前要敷面膜" );
   }
  
   @Override
   public void before(Method method, Object[] args, Object target)
       throws Throwable {
     System.out.println( "睡觉后要做美梦" );
   }
  
}

一、基于代理的AOP

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<!-- 创建一个增强 advice -->
   < bean id = "sleepHelper" class = "com.tgb.springaop.aspect.SleepHelper" />
  
   < bean id = "lina" class = "com.tgb.springaop.service.impl.ChenLliNa" />
   <!-- 定义切点  匹配所有的sleep方法-->
   < bean id = "sleepPointcut" class = "org.springframework.aop.support.JdkRegexpMethodPointcut" >
       < property name = "pattern" value = ".*sleep" ></ property >
   </ bean >
    
   <!-- 切面  增强+切点结合 -->
   < bean id = "sleepHelperAdvisor" class = "org.springframework.aop.support.DefaultPointcutAdvisor" >
      < property name = "advice" ref = "sleepHelper" />
      < property name = "pointcut" ref = "sleepPointcut" />
   </ bean >
    
   <!-- 定义代理对象 -->
   < bean id = "linaProxy" class = "org.springframework.aop.framework.ProxyFactoryBean" >
       < property name = "target" ref = "lina" />
       < property name = "interceptorNames" value = "sleepHelperAdvisor" />
       <!-- <property name="proxyInterfaces" value="com.tgb.springaop.service.Sleepable"/> -->
   </ bean >

如配置文件中:
pattern属性指定了正则表达式,他匹配所有的sleep方法
使用org.springframework.aop.support.DefaultPointcutAdvisor的目的是为了使切点和增强结合起来形成一个完整的切面
最后配置完后通过org.springframework.aop.framework.ProxyFactoryBean产生一个最终的代理对象。
 
二、纯简单java对象切面
纯简单java对象切面这话怎么说呢,在我看来就是相对于第一种配置,不需要使用代理,,而是通过spring的内部机制去自动扫描,这时候我们的配置文件就该如下修改:
 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
<!-- 创建一个增强 advice -->
< bean id = "sleepHelper" class = "com.tgb.springaop.aspect.SleepHelper" />
<!-- 目标类 -->
< bean id = "lina" class = "com.tgb.springaop.service.impl.ChenLliNa" />
  
<!-- 配置切点和通知-->
< bean id = "sleepAdvisor" class = "org.springframework.aop.support.RegexpMethodPointcutAdvisor" >
    < property name = "advice" ref = "sleepHelper" ></ property >
    < property name = "pattern" value = ".*sleep" />
</ bean >
  
<!-- 自动代理配置 -->
< bean class = "org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />

是不是相对于第一种简单了许多,不用再去配置代理了。
 
三、@Aspect注解形式
根据我们的经验也知道,注解的形式相对于配置文件是简单一些的,这时候需要在已有的方法或类上家注解:
 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
  * 通过注解的方式 添加增强
  */
@Aspect
@Component
public class SleepHelper03 {  
    
   /*@Pointcut("execution(* com.tgb.springaop.service.impl..*(..))")*/
   @Pointcut ( "execution(* *.sleep(..))" )
   public void sleeppoint(){}
    
   @Before ( "sleeppoint()" )
   public void beforeSleep(){
     System.out.println( "睡觉前要敷面膜" );
   }
    
   @AfterReturning ( "sleeppoint()" )
   public void afterSleep(){
     System.out.println( "睡觉后要做美梦" );
   }


配置文件中只需写:
 

?
1
2
3
4
5
6
7
<!--扫描包 -->
    < context:component-scan base-package = "com.tgb" annotation-config = "true" /> 
    <!-- ASPECTJ注解 -->
    < aop:aspectj-autoproxy proxy-target-class = "true" /> 
     
    <!-- 目标类 -->
    < bean id = "lina" class = "com.tgb.springaop.service.impl.ChenLliNa" /> 


四、注入形式的Aspcet切面
个人感觉这个是最简单的也是最常用的,也是最灵活的。配置文件如下:
 

?
1
2
3
4
5
6
7
8
9
10
<!-- 目标类 -->
   < bean id = "lina" class = "com.tgb.springaop.service.impl.ChenLliNa" />
   < bean id = "sleepHelper" class = "com.tgb.springaop.aspect.SleepHelper02" />
    
   < aop:config >
     < aop:aspect ref = "sleepHelper" >
        < aop:before method = "beforeSleep" pointcut = "execution(* *.sleep(..))" />
        < aop:after method = "afterSleep" pointcut = "execution(* *.sleep(..))" />
     </ aop:aspect >
   </ aop:config >


配置文件中提到的SleepHelper02类如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
/**
  * 通过注解的方式 添加增强
  */
  
public class SleepHelper02 {
   public void beforeSleep(){
     System.out.println( "睡觉前要敷面膜" );
   }
   public void afterSleep(){
     System.out.println( "睡觉后要做美梦" );
   }
}

 
是不是看上去都很简单呀,这样是不是大家都会使用spring aop了?!
 
关于如何调用,这里写了几个测试类,可以看一下,基本都一样:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
/**
  * 配置文件 spring_aop.xml 通过代理
  */
@Test
public void test(){
   ApplicationContext ct = new ClassPathXmlApplicationContext( "spring_aop.xml" );
    
   Sleepable sleeper =(Sleepable) ct.getBean( "linaProxy" );
    
   sleeper.sleep();
}
  
/**
  * 配置文件 spring_aop_01.xml  简答的java对象
  */
@Test
public void test01(){
   ApplicationContext ct = new ClassPathXmlApplicationContext( "spring_aop_01.xml" );
    
   Sleepable sleeper = (Sleepable)ct.getBean( "lina" );
    
   sleeper.sleep();
}
  
/**
  * 配置文件 spring_aop_03.xml 通过aspect注解
  */
@Test
public void test03(){
   ApplicationContext ct = new ClassPathXmlApplicationContext( "spring_aop_03.xml" );
    
     Sleepable sleeper = (Sleepable)ct.getBean( "lina" );
    
   sleeper.sleep();
}
/**
  * 配置文件 spring_aop_02.xml 通过apsect配置文件
  * @author 陈丽娜
  * @version 2015年5月31日上午10:09:37
  */
@Test
public void test02(){
   ApplicationContext ct = new ClassPathXmlApplicationContext( "spring_aop_02.xml" );
    
   Sleepable sleeper = (Sleepable)ct.getBean( "lina" );
    
   sleeper.sleep();
}

 
通过测试类可以看出,不管以什么样的方式来实现aop他们的使用都是没有差别的,这几个测试类的结果都是一样的:

2016427174658925.png (273×282)

评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值