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

  • Z时代
  • 2024-01-10
  • 分类：IT

简介

面向切面编程（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切面

下面我们就一个一个来应用吧.

下面先写一下几个基本的类。

接口类：

  

/** 
 * 定义一个接口 
 */ 
public interface Sleepable { 
  /** 
   * 睡觉方法 
   */ 
  void sleep(); 
}

实现类：

  

/** 
 * 本人实现睡觉接口 
 */ 
public class ChenLliNa implements Sleepable { 
  @Override 
  public void sleep() { 
    // TODO Auto-generated method stub 
    System.out.println("乖,该睡觉了！"); 
  } 
}

增强类： 

/** 
 * 定义一个睡眠的增强 同时实现前置 和后置 
 */ 
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

<!-- 创建一个增强 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的内部机制去自动扫描，这时候我们的配置文件就该如下修改：

 

<!-- 创建一个增强 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注解形式

根据我们的经验也知道，注解的形式相对于配置文件是简单一些的，这时候需要在已有的方法或类上家注解：

  

/** 
 * 通过注解的方式 添加增强 
 */ 
@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("睡觉后要做美梦"); 
  }

配置文件中只需写：

  

<!--扫描包 --> 
   <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切面

个人感觉这个是最简单的也是最常用的，也是最灵活的。配置文件如下：

  

<!-- 目标类 --> 
  <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类如下：

/** 
 * 通过注解的方式 添加增强 
 */ 
public class SleepHelper02 { 
  public void beforeSleep(){ 
    System.out.println("睡觉前要敷面膜"); 
  } 
  public void afterSleep(){ 
    System.out.println("睡觉后要做美梦"); 
  } 
}

 

是不是看上去都很简单呀，这样是不是大家都会使用spring aop了？！

 

关于如何调用，这里写了几个测试类，可以看一下，基本都一样：

/** 
 * 配置文件 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实现 的全部内容， 来源链接： utcz.com/p/209926.html

回到顶部