spring的aop的例子

一个简单的Spring的AOP例子

2009-06-23 11:33:29|  分类： Spring |  标签： |举报 |字号大中小 订阅

  1. package aop;
  2. /**
  3. * 目标对象的接口
  4. */
  5. public interface Student {
  6. public void addStudent(String name);
  7. }
package aop;  /**     * 目标对象的接口    */   public interface Student {   public void addStudent(String name);  }
  1. package aop;
  2. /**
  3. * 目标对象
  4. */
  5. public class StudentImpl implements Student {
  6. public void addStudent(String name) {
  7. System.out.println(" 欢迎  " + name + "  你加入);
  8. }
  9. }
package Spring家庭! ");   }  }
  1. package aop;
  2. import java.lang.reflect.Method;
  3. import org.springframework.aop.MethodBeforeAdvice;
  4. /**
  5. * 前置通知
  6. */
  7. public class BeforeAdvice implements MethodBeforeAdvice {
  8. public void before(Method method, Object[] args, Object target)
  9. throws Throwable {
  10. System.out.println(" 这是BeforeAdvice类的before方法. ");
  11. }
  12. }
package aop.MethodBeforeAdvice;    /**   * 前置通知   */  public class BeforeAdvice implements MethodBeforeAdvice {     public void before(Method method, Object[] args, Object target)     throws Throwable {      System.out.println(" 这是BeforeAdvice类的before方法. ");     }  }
  1. package aop;
  2. import java.lang.reflect.Method;
  3. import org.springframework.aop.AfterReturningAdvice;
  4. /**
  5. * 后置通知
  6. */
  7. public class AfterAdvice implements AfterReturningAdvice {
  8. public void afterReturning(Object returnValue, Method method,
  9. Object[] args, Object target) throws Throwable {
  10. System.out.println("这是AfterAdvice类的afterReturning方法.");
  11. }
  12. }
package aop.AfterReturningAdvice;    /**   * 后置通知   */  public class AfterAdvice implements AfterReturningAdvice {     public void afterReturning(Object returnValue, Method method,     Object[] args, Object target) throws Throwable {    System.out.println("这是AfterAdvice类的afterReturning方法.");   }    }
  1. package aop;
  2. import org.aopalliance.intercept.MethodInterceptor;
  3. import org.aopalliance.intercept.MethodInvocation;
  4. /**
  5. * 环绕通知
  6. */
  7. public class CompareInterceptor implements MethodInterceptor {
  8. public Object invoke(MethodInvocation invocation) throws Throwable {
  9. Object result = null;
  10. String stu_name = invocation.getArguments()[0].toString();
  11. if (stu_name.equals("dragon")) {
  12. // 如果学生是dragon时,执行目标方法,
  13. result = invocation.proceed();
  14. } else {
  15. System.out.println("此学生是" + stu_name + "而不是dragon,不批准其加入.");
  16. }
  17. return result;
  18. }
  19. }
package
    1. version="1.0" encoding="UTF-8"?>
    2. <!DOCTYPE beans PUBLIC "-//spring-beans.dtd">
    3. id="beforeAdvice"
    4.  class="id
    5. ="afterAdvice" class="id="compareInterceptor" class="id

    ="studenttarget" class="id="student"

  • class="org.springframework.aop.framework.ProxyFactoryBean">
    1. name="proxyInterfaces">
      1. aop.Student
      2. name="interceptorNames"
      3. >  
  • name="target"
  • >  
  • bean="studenttarget"
  •  />  
  • <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//

    1. package

    aop;

  • import org.springframework.context.ApplicationContext;
  • import org.springframework.context.support.FileSystemXmlApplicationContext;
  • /**
  • * 测试代码
  • */
  • public class Test {
  • public static void main(String[] args) {
  • ApplicationContext ctx = new FileSystemXmlApplicationContext("/src/applicationContext.xml");
  • Student s = (Student)ctx.getBean("student");
  • s.addStudent("aaa");
  • }
  • }

  • *****************************************************************************************************

    Spring AOP实例二

    最近在研究aop，看了点资料，总结如下：
    所谓AOP就是将分散在各个方法处的公共代码提取到一处，并通过类似拦截器的机制实现代码的动态整合。可以简单地想象成，在某个方法的调用前、执行中、调用后和抛出异常时，动态插入自己的代码。

    网上碰到个例子还不错，整理了一下：

    首先看一个简单的spring IOC例子：

    用户买书接口：

    1. package aop;
    2. public interface BuyBook {
    3. public void buyBook(String customer,String book)throws NoBookException;
    4. }
    package aop;  public interface BuyBook {    public void buyBook(String customer,String book)throws NoBookException;  }

    用户买书的接口实现：

    1. package aop;
    2. public class BuyBookImpl implements BuyBook{
    3. public void buyBook(String customer,String book) {
    4. System.out.println(customer+"你好！你成功购了一本"+book+"!");
    5. }
    6. }
    package aop;  public class BuyBookImpl implements BuyBook{   public void buyBook(String customer,String book) {      System.out.println(customer+"你好！你成功购了一本"+book+"!");   }  }

    测试用户买书类：

    1. package aop;
    2. import org.springframework.context.ApplicationContext;
    3. import org.springframework.context.support.FileSystemXmlApplicationContext;
    4. public class TestAop {
    5. public static void main(String args[]) throws Exception{
    6. ApplicationContext ctx = new FileSystemXmlApplicationContext("aop.xml");
    7. BuyBook b = (BuyBook)ctx.getBean("newBuyBook");
    8. b.buyBook("小东", "《楚留香》");
    9. }
    10. }
    package aop;  import org.springframework.context.ApplicationContext;  import org.springframework.context.support.FileSystemXmlApplicationContext;    public class TestAop {   public static void main(String args[]) throws Exception{            ApplicationContext ctx = new FileSystemXmlApplicationContext("aop.xml");             BuyBook b = (BuyBook)ctx.getBean("newBuyBook");          b.buyBook("小东", "《楚留香》");      }  }

    配置文件aop.xml

      1. version="1.0" encoding="UTF-8"?>
      2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
      3. id="newBuyBook"
      4.  class="aop.BuyBookImpl"/>    
    1. <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <bean id="newBuyBook" class="aop.BuyBookImpl"/> </beans>

      此时运行程序仅出现：
      小东你好！你成功购了一本《楚留香》！

      ===================================================================================
      AOP ----切面编程
      所谓切面编程：在不改变原方法(令为methodA)的定义与使用、也不改变原程序的流程的情况下，变更该methodA的功能。在变更时,最激动人心的时能获得methodA的类的对象,meahtoidA的参数,也可获得mehodA执行的结果,还能得到调用meahtoidA的对象。
          简单理解：允许用户在指定地方，插入新的函数，
      包括：
      1 methodA运行前,执行用户指定的其它方法methodOther,然后返回
      2 methodA运行完毕,执行用户指的其它方法methodOther,然后返回
      3 在执行methodA的地方,变成执行在用户指定的其它方法methodOther,
      在methodOther方法中, methodA运不运行,何时运行,随用户自行安排,然后返回
      4  methodA执行出现异常时,执行用户指定的其它方法methodOther,然后返回。

      产生动机：
      在一个程序中，当我们要 使用一个方法（令为methodA）；由于不同的用户对methodA的功能要 求不一样，因此在这个methodA的地方就出现了变化点。所以要在这个变化点上进行封装，留下一个可扩展的接口，便于日后修改维护。

      本质：
      1  Aop核心是一个适配器，把变动前的方法，与变动后的方法联接在一起。
      2  这个适配器实现的核心是动态代理 Proxy机制
      3  四个核心子接口：
      a  MethodBeforeAdvice ----methodA函数调用前执行用户定义的方法
      b  AfterReturningAdvice ----- methodA函数调后执行用户定义的方法
      c  MethodInterceptor -------彻底变更MethodA函数为用户定义的方法
      d  ThrowsAdvice------methodA函数调用出现异常执行用户定义的方法

      ===================================================================================
      下面加入aop的内容：
      一、在买书前加入新功能（欢迎光临！小东）

      增加类MyBeforeAdvice ：

      1. package

      aop;

    2. import org.springframework.aop.MethodBeforeAdvice;
    3. import java.lang.reflect.Method;
    4. public class MyBeforeAdvice implements MethodBeforeAdvice{
    5. public void before(Method arg0, Object[] arg1, Object target) throws Throwable {
    6. String customer = (String)arg1[0];
    7. System.out.println("欢迎光临!"+customer+"!");
    8. }
    9. }
package aop;  import org.springframework.aop.MethodBeforeAdvice;  import java.lang.reflect.Method;    public class MyBeforeAdvice implements MethodBeforeAdvice{   public void before(Method arg0, Object[] arg1, Object target) throws Throwable {   String customer = (String)arg1[0];            System.out.println("欢迎光临!"+customer+"!");         }   }

修改配置文件aop.xml：

      1. version="1.0" encoding="UTF-8"?>
      2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
      3. id="buyBook"
      4.  class="aop.BuyBookImpl"/>    
    1. id="myBeforeAdvice" class="aop.MyBeforeAdvice"/>
      1. id="newBuyBook" class="org.springframework.aop.framework.ProxyFactoryBean">
        1. name="proxyInterfaces" value="aop.BuyBook"/>
          1. name="interceptorNames">
      3. name="target"
      4.  ref="buyBook"/>  
  • <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <bean id="buyBook" class="aop.BuyBookImpl"/> <bean id="myBeforeAdvice" class="aop.MyBeforeAdvice"/> <bean id="newBuyBook" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="proxyInterfaces" value="aop.BuyBook"/> <property name="interceptorNames"> <list> <value>myBeforeAdvice</value> </list> </property> <property name="target" ref="buyBook"/> </bean> </beans>

    运行后输出结果：
    欢迎光临！
    小东你好！你成功购了一本《楚留香》！


    二、在买书后加入新功能（Good Bye！小东）
    增加MyAfterAdvice类：

    1. package

    aop;

  • import java.lang.reflect.Method;
  • import org.springframework.aop.AfterReturningAdvice;
  • public class MyAfterAdvice implements AfterReturningAdvice{
  • public void afterReturning(Object o1, Method m, Object[] objects, Object o2){
  • System.out.println("Good Bye！" + objects[0]);
  • }
  • }
package aop;  import java.lang.reflect.Method;  import org.springframework.aop.AfterReturningAdvice;  public class MyAfterAdvice implements AfterReturningAdvice{    public void afterReturning(Object o1, Method m, Object[] objects, Object o2){     System.out.println("Good Bye！" + objects[0]);     }  }

修改配置文件aop.xml：

      1. version="1.0" encoding="UTF-8"?>
      2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
      3. id="buyBook"
      4.  class="aop.BuyBookImpl"/>    
    1. id="myBeforeAdvice" class="aop.MyBeforeAdvice"/>
      1. id="myAfterAdvice" class="aop.MyAfterAdvice"/>
        1. id="newBuyBook" class="org.springframework.aop.framework.ProxyFactoryBean">
          1. name="proxyInterfaces" value="aop.BuyBook"/>
            1. name="interceptorNames">
      3. name="target"
      4.  ref="buyBook"/>  
  • <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <bean id="buyBook" class="aop.BuyBookImpl"/> <bean id="myBeforeAdvice" class="aop.MyBeforeAdvice"/> <bean id="myAfterAdvice" class="aop.MyAfterAdvice"/> <bean id="newBuyBook" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="proxyInterfaces" value="aop.BuyBook"/> <property name="interceptorNames"> <list> <value>myBeforeAdvice</value> <value>myAfterAdvice</value> </list> </property> <property name="target" ref="buyBook"/> </bean> </beans>

    运行后输出结果：
    欢迎光临！
    小东你好！你成功购了一本《楚留香》！
    Good Bye！小东

    三、修改原来方法的内容，比如加入相关业务判断，一个人只能买一本书：
    修改用户买书类：

    package

    aop;

  • import org.springframework.context.ApplicationContext;
  • import org.springframework.context.support.FileSystemXmlApplicationContext;
  • public class TestAop {
  • public static void main(String args[]) throws Exception{
  • ApplicationContext ctx = new FileSystemXmlApplicationContext("aop.xml");
  • BuyBook b = (BuyBook)ctx.getBean("newBuyBook");
  • b.buyBook("小东", "《楚留香》");
  • b.buyBook("小东", "《楚留香2》");
  • }
  • }
package aop;  import org.springframework.context.ApplicationContext;  import org.springframework.context.support.FileSystemXmlApplicationContext;    public class TestAop {   public static void main(String args[]) throws Exception{            ApplicationContext ctx = new FileSystemXmlApplicationContext("aop.xml");             BuyBook b = (BuyBook)ctx.getBean("newBuyBook");          b.buyBook("小东", "《楚留香》");          b.buyBook("小东", "《楚留香2》");      }  }

增加拦截器类MyMethodInterceptor：

package aop;

  1. import java.util.HashSet;
  2. import java.util.Set;
  3. import org.aopalliance.intercept.MethodInterceptor;
  4. import org.aopalliance.intercept.MethodInvocation;
  5. public class MyMethodInterceptor implements MethodInterceptor{
  6. private Set customers = new HashSet();
  7. @Override
  8. public Object invoke(MethodInvocation invocation) throws Throwable {
  9. String customer = (String)invocation.getArguments()[0];
  10. Object result = null;
  11. if(customers.contains(customer)){
  12. System.out.println("注意，一名顾客只能买一本打折书！");
  13. } else{
  14. result = invocation.proceed();
  15. }
  16. customers.add(customer);
  17. return result;
  18. }
  19. }
package aop;  import java.util.HashSet;  import java.util.Set;  import org.aopalliance.intercept.MethodInterceptor;  import org.aopalliance.intercept.MethodInvocation;  public class MyMethodInterceptor implements MethodInterceptor{   private Set customers = new HashSet();    @Override   public Object invoke(MethodInvocation invocation) throws Throwable {    String customer = (String)invocation.getArguments()[0];       Object result = null;       if(customers.contains(customer)){            System.out.println("注意，一名顾客只能买一本打折书！");       } else{            result = invocation.proceed();       }       customers.add(customer);       return result;   }  }

修改配置文件aop.xml：

      1. version="1.0" encoding="UTF-8"?>
      2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
      3. id="buyBook"
      4.  class="aop.BuyBookImpl"/>    
    1. id="myMethodInterceptor" class="aop.MyMethodInterceptor"/>
      1. id="newBuyBook" class="org.springframework.aop.framework.ProxyFactoryBean">
        1. name="proxyInterfaces" value="aop.BuyBook"/>
          1. name="interceptorNames">
      3. name="target"
      4.  ref="buyBook"/>  
  • <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <bean id="buyBook" class="aop.BuyBookImpl"/> <bean id="myMethodInterceptor" class="aop.MyMethodInterceptor"/> <bean id="newBuyBook" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="proxyInterfaces" value="aop.BuyBook"/> <property name="interceptorNames"> <list> <value>myMethodInterceptor</value> </list> </property> <property name="target" ref="buyBook"/> </bean> </beans>

    运行结果：
    小东你好！你成功购了一本《楚留香》!
    注意，一名顾客只能买一本打折书！

时间： 2024-11-04 00:45:41

spring的aop的例子的相关文章

Spring @AspectJ 实现AOP 入门例子(转)

AOP的作用这里就不再作说明了,下面开始讲解一个很简单的入门级例子. 引用一个猴子偷桃,守护者守护果园抓住猴子的小情节. 1.猴子偷桃类(普通类): Java代码   package com.samter.common; /** * 猴子 * @author Administrator * */ public class Monkey { public void stealPeaches(String name){ System.out.println("[猴子]"+name+&quo

Spring AOP 学习例子

http://outofmemory.cn/code-snippet/3762/Spring-AOP-learn-example 工作忙,时间紧,不过事情再多,学习是必须的.记得以前的部门老大说过:“开发人员不可能一天到晚只有工作,肯定是需要自我学习.第一:为了更充实自己,保持进步状态.第二:为了提升技术,提高开发能力.第三:保持程序员对技术和学习的热情,工作的激情.程序员还是需要把基础打扎实,修炼自己的内功.” 所以赶紧把学习的东西总结一下,加深印象.之前有说了下AOP的原理 (http://

Spring实现AOP的4种方式(转)

转自:http://blog.csdn.net/udbnny/article/details/5870076 Spring实现AOP的4种方式 先了解AOP的相关术语:1.通知(Advice):通知定义了切面是什么以及何时使用.描述了切面要完成的工作和何时需要执行这个工作.2.连接点(Joinpoint):程序能够应用通知的一个“时机”,这些“时机”就是连接点,例如方法被调用时.异常被抛出时等等.3.切入点(Pointcut)通知定义了切面要发生的“故事”和时间,那么切入点就定义了“故事”发生的

Spring实现AOP的4种方式

来自:http://blog.csdn.net/udbnny/article/details/5870076 先了解AOP的相关术语: 1.通知(Advice):通知定义了切面是什么以及何时使用.描述了切面要完成的工作和何时需要执行这个工作.2.连接点(Joinpoint):程序能够应用通知的一个“时机”,这些“时机”就是连接点,例如方法被调用时.异常被抛出时等等.3.切入点(Pointcut)通知定义了切面要发生的“故事”和时间,那么切入点就定义了“故事”发生的地点,例如某个类或方法的名称,S

Spring之AOP原理_动态代理

面向方面编程(Aspect Oriented Programming,简称AOP)是一种声明式编程(Declarative Programming).声明式编程是和命令式编程(Imperative Programming)相对的概念.我们平时使用的编程语言,比如C++.Java.Ruby.Python等,都属命令式编程.命令式编程的意思是,程序员需要一步步写清楚程序需要如何做什么(How to do What).声明式编程的意思是,程序员不需要一步步告诉程序如何做,只需要告诉程序在哪些地方做什么

Spring简单的小例子SpringDemo，用于初略理解什么是Spring以及JavaBean的一些概念

一.开发前的准备 两个开发包spring-framework-3.1.1.RELEASE-with-docs.zip和commons-logging-1.2-bin.zip,将它们解压,然后把Spring开发包下dist目录的所有包和commons-logging包下的commons-logging-1.1.1.jar复制到名为Spring3.1.1的文件夹下.那么Spring开发所需要的包就组织好了. 二.建立项目,导入包 在项目节点上右键,Build Path/ADD Libraries/U

Spring中AOP简介与使用

Spring中AOP简介与使用 什么是AOP? Aspect Oriented Programming(AOP),多译作 "面向切面编程",也就是说,对一段程序,从侧面插入,进行操做.即通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术. 为什么要用AOP? 日志记录,性能统计,安全控制,事务处理,异常处理等等.例如日志记录,在程序运行的某些节点上添加记录执行操作状态的一些代码,获取执行情况.而通过切面编程,我们将这些插入的内容分离出来,将它们独立

基于spring的aop实现多数据源动态切换

https://lanjingling.github.io/2016/02/15/spring-aop-dynamicdatasource/ 基于spring的aop实现多数据源动态切换 发表于 2016-02-15   |   分类于 spring  | 一.多数据源动态切换原理 项目中我们经常会遇到多数据源的问题,尤其是数据同步或定时任务等项目更是如此:又例如:读写分离数据库配置的系统. 1.多数据源设置: 1)静态数据源切换:一般情况下,我们可以配置多个数据源,然后为每个数据源写一套对应的

【Spring】AOP之基于XML配置总结与案例

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 一.AOP的一些概念 AOP(Aspect-Oriented Programming,面向切面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善.OOP引入封装.继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合.当我们需要为分散的对象引入公共行为的时候,OOP则显得无能为力.也就是说,OOP允许你定义从上到下的关系,但