Spring Aop Advise办法(增强办法) 中获取方针办法的参数ITeye - 乐橙lc8

Spring Aop Advise办法(增强办法) 中获取方针办法的参数ITeye

2019年02月23日12时34分29秒 | 作者: 星睿 | 标签: 办法,参数,方针 | 浏览: 416

   

   切面类: 一种特别bean,经过aop装备,其间的办法(增强办法),会对方针bean的方针办法做一些增强处理

   (比方在方针办法之前或之后调用等).

   

   切入点(pointcut): 一种规矩,一般bean中契合这种规矩的办法,将成为上面切面类中所说的方针办法,承受切面类办法

   的特别处理.

   

   增强办法(Advice),包括aop:befor,aop:after,aop:after-retuing,aop:around,aop:throwing等.

   

2. 装备片段:

     

 ! AOP测验的chinese  
 bean id="chinese_aop" / 
 ! 界说一个一般bean,作为切面bean  
 bean id="accessArgAspect" / 
 ! AOP装备  
 aop:config 
 ! 装备切面aspect  
 aop:aspect id="aspect" ref="accessArgAspect" 
 aop:after-returning 
 pointcut="execution(* test.aop.*.*(..))" 
 method="access"
 returning="retval"
 arg-names="time,food,retval" 
 /aop:aspect 
 /aop:config 

       

    上面的装备中:

    bean id="chinese_aop" /

    装备了一般的bean,该bean中的一些办法

    行将满意切入点装备规矩,承受切面类中增强办法(Advice)的增强处理.

    

    bean id="accessArgAspect" / 界说一个切面类,

    切面类可所以一个一般的bean.

    

    aop:config

      !装备切面aspect,经过ref相关到前面装备的作为切面类的bean

      aop:aspect id="aspect" ref="accessArgAspect"

        ! 装备一种aop:after-returning增强处理

        aop:after-returning

          ! 切入点 规矩,契合这个规矩的一般bean中的办法将承受增强处理

          pointcut="execution(*test.aop.*.*(..)) and args(food,time,..)"  

          ! 切面类中,作为增强处理的办法的称号

          method="access"

          ! 一般bean,承受增强处理办法的回来值,void的类型被视为null  

          returning="retval" 

          ! 切面类中增强办法的参数名,这个装备能够省掉

          arg-names="time,food,retval"

        /

        

      /aop:aspect

    /aop:config

    

3. 参数绑定

   切面类 办法(增强办法)获取 方针办法(一般bean中承受增强办法处理的办法) 参数的办法称为参数绑定.

   

   (1) 增强办法 不需求传递参数,则不需求参数绑定.

   

   (2) 增强办法中,只要一个JoinPoint类型的参数,运用这种参数,也不需求参数绑定.

       由于, JoinPoint类有一些办法能够获取方针办法的调用信息(包括参数信息),比方:

       Object[] getArgs(),回来在履行方针办法时传递的参数

       Signature getSignature(),获取 方针办法的签名

       Object getTarget():回来被植入 增强处理的方针方针

       Object getThis(): 回来AOP结构为方针方针生成的署理方针(Spring AOP经过动态署理完成)

       

       假如是aop:around类型的增强处理办法,能够运用ProceedingJoinPoint作为参数,

       ProceedingJoinPoint除了有上述的几个办法外,还有一个proceed()办法,代替方针办法履行.

       

   (3) 增强办法中,有一般类型的参数,

       比方public void access(Date time,String food, String retval)

       这种增强办法,有必要要在pointcut中经过装备args 和 returning,确保参数正确绑定.

       (returning只针对aop:after-returning类型的增强处理,其他的能够省掉)

       (即,增强办法中呈现的参数名有必要在pointcut装备中都得到清晰的装备,不然报反常)

       pointcut="execution(*test.aop.*.*(..)) and args(food,time,..)"

       中args(food,time,..)中的food和time是参数名,来自切面类的增强办法,不能乱写,

       有必要和切面类中增强办法的参数称号共同,在切面类的增强办法参数列表中有必要能找到.

       由于在增强办法public void access(Date time,String food, String retval)中,time是Date类型的,

       food是String类型的,所以pointcut(切入点)界说中and args(food,time,..)契合and前面的规矩的一起

       还要契合args(food,time,..)的规矩.

       args(food,time,..)表是一切 第一个参数是String类型,第二个参数是Date类型的办法才干称为方针办法.

       .. 表明能够有第三个,第四个, ... , 第n个参数,可是至少有两个参数(String,Date)

       所以需求留意的有:

       a. 切面类中的增强办法参数,有必要要在pointcut中有清晰指定,比方

          public void access(Date time,String food, String retval)

          这个办法中三个参数food,和time经过args指定了,retval表明aop:after-returning界说的方针函数的回来值.

       b. 清晰指定了参数后,AOP结构在运行时能正确绑定参数,由于:

          and args(food,time,..)表明 只对一类方针办法的调用做增强处理,这种方针办法是:在预备调用这种方针办法时,

          实践传递给它的参数为food和time所表明的类型(food和time有必要在增强办法的参数列表中找到,这样就依据增强办法断定了food和time的类型).

          而且,传递参数的次序也要是和args(food,time,..)中共同.这样在调用方针办法时,至少会按次序传递food,time两个参数,

          AOP结构能够将这两个参数传递给 增强办法.

   

   (4) 增强办法中 有 JoinPoint和一般类型参数,

       则有必要将JoinPoint类型的参数作为第一个参数,一般参数从第二个开端.

       其他的处理办法,依照上面(3)中仅含有一般参数的办法处理.

       

 首要代码;

package test.aop;
import java.util.Date;
 * 一般bean的接口
public interface Person
 String sayHello(String name);
 void eat(String food, Date time);
 void eat2(String food, Date time,String test);

 

package test.aop;
import java.util.Date;
 *一个一般bean,eat办法和sayHello办法,是需求被切入,动态影响的
public class Chinese implements Person
 @Override
 public void eat(String afood, Date atime)
 System.out.println("正在吃: " + afood + ", 时刻是: " + atime);
 @Override
 public String sayHello(String name)
 return name + " Hello, Spring AOP.";
 public void eat2(String afood, Date atime,String test)
 System.out.println("eat2 - 正在吃: " + afood + ", 时刻是: " + atime + ", eat2里边的test= " + test);

 

package test.aop.aspect;
import java.util.Arrays;
import java.util.Date;
import org.aspectj.lang.JoinPoint;
 * 界说切面类,处理test.aop.Chinese.eat()
public class AccessArgAspect
 //一般的 增强办法
 public void access(Date time,String food, String retval)
 System.out.println("");
 System.out.println("方针办法中 String 参数为: " + food);
 System.out.println("方针办法中 String 参数为: " + time);
 System.out.println("方针办法 回来值: " + retval);
 System.out.println("模仿记载日志...");
 * 第一个参数为JoinPoint类型的增强办法,JoinPoint有必要为第一个参数
 * @param jp
 * @param time
 * @param food
 * @param retval
 public void accessWithJoinPoint(JoinPoint jp,Date time,String food)
 System.out.println("");
 System.out.println("JoinPoint.getArgs()获取参数列表:" + Arrays.toString(jp.getArgs()));
 System.out.println("JoinPoint jp  方针办法中 String 参数为: " + food);
 System.out.println("JoinPoint jp  方针办法中 String 参数为: " + time);
 System.out.println("JoinPoint jp  模仿记载日志...");

 

package test.aop;
import java.util.Date;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 * AOP客户端测验类
public class TestClient
 public static void main(String[] args)
 ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
 System.out.println(ctx);
 Person person = ctx.getBean("chinese_aop",Person.class);
 person.sayHello("jack");
 person.eat("米饭",new Date());
 person.eat2("米饭",new Date(),"test");

 

 ?xml version="1.0" encoding="UTF-8"? 
 beans xmlns="http://www.springframework.org/schema/beans" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/aop 
 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
 http://www.springframework.org/schema/tx 
 http://www.springframework.org/schema/tx/spring-tx-3.0.xsd" 
 ! 小试牛刀 property运用 name,value 
 bean id="personService" 
 property name="name" value="wawa" /property 
 /bean 
 ! 
 设值注入
 property运用 name,ref ,
 ref也是一个bean的id,ref 能够在stoneAxe和steelAxe之间随意切换,而不必修正java代码 
 bean id="chinese" 
 property name="axe" ref="steelAxe" /property 
 /bean 
 bean id="stoneAxe" / 
 bean id="steelAxe" / 
 ! 
 结构注入
 constructor-arg标签,ref ,
 ref也是一个bean的id,ref 能够在stoneAxe和steelAxe之间随意切换,而不必修正java代码
 constructor-arg 也能够装备value,表明传递给结构函数的是一个 一般的值,而不是另一个bean 
 bean id="chinese1" 
 constructor-arg ref="steelAxe" / 
 /bean 
 ! 国际化  
 bean id="messageSource" 
 property name="basenames" 
 list 
 ! 这儿的value可带途径  
 value message /value 
 /list 
 /property 
 /bean 
 ! 
 ApplicationContext的事情机制 
 在Spring中装备了完成ApplicationListener接口的Bean,
 Spring容器就会把这个Bean当成容器事情的监听器
 bean / 
 ! bean中获取 ApplicationContext引证 
 bean name="beangetappcontext" / 
 ! AOP测验的chinese  
 bean id="chinese_aop" / 
 ! 界说一个一般bean,作为切面bean  
 bean id="accessArgAspect" / 
 ! AOP装备  
 aop:config 
 ! 装备切面aspect  
 aop:aspect id="aspect" ref="accessArgAspect" 
 aop:after-returning 
 pointcut="execution(* test.aop.*.*(..)) and args(food,time,..)" 
 method="access"
 returning="retval"
 arg-names="time,food,retval" 
 aop:before 
 pointcut="execution(* test.aop.*.*(..)) and args(food,time,..)" 
 method="accessWithJoinPoint"
 /aop:aspect 
 /aop:config 
 /beans 

 

工程文件注:

 

运用Spring 3.2.0的一切ja包,

3.2.0的srping包,做AOP需求依靠(Spring 3.2.0中去除了依靠包,需求自己找)

com.springsource.org.aopalliance-1.0.0.jar,下载地址http://ebr.springsource.com/repository/app/bundle/version/detail?name=org.springframework.aop version=3.2.0.RELEASE

还有,3.0.2的com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar包,

下载3.0.2版别的依靠包今后,找

spring-framework-3.0.2.RELEASE-dependencies (1)\org.aspectj\com.springsource.org.aspectj.weaver\1.6.8.RELEASE这个目录里边有      

          

附件中工程已包括一切需求的jar包

         

版权声明
本文来源于网络,版权归原作者所有,其内容与观点不代表乐橙lc8立场。转载文章仅为传播更有价值的信息,如采编人员采编有误或者版权原因,请与我们联系,我们核实后立即修改或删除。

猜您喜欢的文章