实例讲解Java的Spring框架中的AOP实现

时间:2022-03-19 04:42:41

简介
面向切面编程(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他们的使用都是没有差别的,这几个测试类的结果都是一样的:

实例讲解Java的Spring框架中的AOP实现