spring配置文件aop|aop在spring中怎么配置-小MRY

㈠ spring aop怎么实现的

先了解AOP的相关术语:1.通知(Advice):通知定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。2.连接点(Joinpoint):程序能够应用通知的一个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。3.切入点(Pointcut)通知定义了切面要发生的“故事”和时间，那么切入点就定义了“故事”发生的地点，例如某个类或方法的名称，Spring中允许我们方便的用正则表达式来指定4.切面(Aspect)通知和切入点共同组成了切面：时间、地点和要发生的“故事”5.引入(Introction)引入允许我们向现有的类添加新的方法和属性(Spring提供了一个方法注入的功能）6.目标(Target)即被通知的对象，如果没有AOP,那么它的逻辑将要交叉别的事务逻辑，有了AOP之后它可以只关注自己要做的事（AOP让他做爱做的事）7.代理(proxy)应用通知的对象，详细内容参见设计模式里面的代理模式8.织入(Weaving)把切面应用到目标对象来创建新的代理对象的过程，织入一般发生在如下几个时机:(1)编译时：当一个类文件被编译时进行织入，这需要特殊的编译器才可以做的到，例如AspectJ的织入编译器(2)类加载时：使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码(3)运行时：切面在运行的某个时刻被织入,SpringAOP就是以这种方式织入切面的，原理应该是使用了JDK的动态代理技术Spring提供了4种实现AOP的方式：1.经典的基于代理的AOP[email protected]注解驱动的切面3.纯POJO切面4.注入式AspectJ切面首先看经典的基于代理的AOP:Spring支持五种类型的通知：Before(前) org.apringframework.aop.MethodBeforeAdviceAfter-returning(返回后) org.springframework.aop.AfterReturningAdviceAfter-throwing(抛出后) org.springframework.aop.ThrowsAdviceArround(周围) org.aopaliance.intercept.MethodInterceptorIntroction(引入) org.springframework.aop.IntroctionInterceptor值的说明的是周围通知，他是由AOP Alliance中的接口定义的而非Spring,周围通知相当于前通知、返回后通知、抛出后通知的结合（传说中的完全体？好吧，我看日和看多了）还有引入通知怎么玩我还没搞清楚，等心无杂念的时候玩玩这东西怎么玩？这么几个步骤：1.创建通知：实现这几个接口，把其中的方法实现了2.定义切点和通知者：在Spring配制文件中配置这些信息3.使用ProxyFactoryBean来生成代理具体做法。。。大晚上的就举个睡觉的例子吧:首先写一个接口叫Sleepable,这是一个牛X的接口,所有具有睡觉能力的东西都可以实现该接口（不光生物，包括关机选项里面的休眠）package test.spring.aop.beanpublic interface Sleepable{void sleep(); }然后写一个Human类，他实现了这个接口package test.spring.aop.beanpublic Human implements Sleepable{/*这人莫非跟寡人差不多？*除了睡觉睡的比较好之外其余的什么也不会做？*/public void sleep(){System.out.println("睡觉了！梦中自有颜如玉！");}}好了，这是主角，不过睡觉前后要做些辅助工作的，最基本的是脱穿衣服，失眠的人还要吃安眠药什么的,但是这些动作与纯粹的睡觉这一“业务逻辑”是不相干的，如果把这些代码全部加入到sleep方法中，是不是有违单一职责呢？，这时候我们就需要AOP了。编写一个SleepHelper类，它里面包含了睡觉的辅助工作,用AOP术语来说它就应该是通知了，我们需要实现上面的接口package test.spring.aop.bean;import java.lang.reflect.Method;import org.springframework.aop.AfterReturningAdvice;import org.springframework.aop.MethodBeforeAdvice;public class SleepHelper implements MethodBeforeAdvice,AfterReturningAdvice{public void before(Method mtd, Object[] arg1, Object arg2)throws Throwable {System.out.println("通常情况下睡觉之前要脱衣服！");}public void afterReturning(Object arg0, Method arg1, Object[] arg2,Object arg3) throws Throwable {System.out.println("起床后要先穿衣服！");}}然后在spring配置文件中进行配置:<bean id="sleepHelper" class="test.spring.aop.bean.SleepHelper"></bean>OK!现在创建通知的工作就完成了.第二步是进行配置，这是很令人蛋疼的操作，尤其是这么热的天，Spring又把东西的名字起的见鬼的长！它为啥不能像usr这种风格呢？首先要做的是配置一个切点,据说切点的表示方式在Spring中有好几种，但是常用的只有两种：1.使用正则表达式 2.使用AspectJ表达式 AspectJ我不是很熟悉(我也是熟悉党 or 精通党？),我还是习惯用正则表达式Spring使用org.springframework.aop.support.JdkRegexpMethodPointcut来定义正则表达式切点<bean id="spleepPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut"><property name="pattern" value=".*sleep"/></bean>pattern属性指定了正则表达式，它匹配所有的sleep方法切点仅仅是定义了故事发生的地点，还有故事发生的时间以及最重要的故事的内容,就是通知了，我们需要把通知跟切点结合起来，我们要使用的通知者是:org.springframework.aop.support.DefaultPointcutAdvisor<bean id="sleepHelperAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor"><property name="advice" ref="sleepHelper"/><property name="pointcut" ref="sleepPointcut"/></bean>切入点和通知都配置完成，接下来该调用ProxyFactoryBean产生代理对象了<bean id="humanProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><property name="target" ref="human"/><property name="interceptorNames" value="sleepHelperAdvisor" /><property name="proxyInterfaces" value="test.spring.aop.bean.Sleepable" /></bean>ProxyFactoryBean是一个代理，我们可以把它转换为proxyInterfaces中指定的实现该interface的代理对象:import org.springframework.aop.framework.ProxyFactoryBean;import org.springframework.context.ApplicationContext;import org.springframework.context.support.;import test.spring.aop.bean.Sleepable;public class Test {public static void main(String[] args){ApplicationContext appCtx = new ("applicationContext.xml");Sleepable sleeper = (Sleepable)appCtx.getBean("humanProxy");sleeper.sleep();}}程序运行产生结果：通常情况下睡觉之前要脱衣服！睡觉啦~梦中自有颜如玉!起床后要先穿衣服！OK!这是我们想要的结果，但是上面这个过程貌似有点复杂，尤其是配置切点跟通知,Spring提供了一种自动代理的功能，能让切点跟通知自动进行匹配，修改配置文件如下:<bean id="sleepHelper" class="test.spring.aop.bean.SleepHelper"></bean><bean id="sleepAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"><property name="advice" ref="sleepHelper"/><property name="pattern" value=".*sleep"/></bean><bean id="human" class="test.spring.aop.bean.Human"></bean><bean class="org.springframework.aop.framework.autoproxy."/>执行程序：public class Test {public static void main(String[] args){ApplicationContext appCtx = new ("applicationContext.xml");Sleepable sleeper = (Sleepable)appCtx.getBean("human");sleeper.sleep();}}成功输出结果跟前面一样!只要我们声明了org.springframework.aop.framework.autoproxy.(我勒个去的，名太长了)就能为方法匹配的bean自动创建代理！但是这样还是要有很多工作要做,有更简单的方式吗?有！一种方式是使用AspectJ提供的注解:package test.mine.spring.bean;import org.aspectj.lang.annotation.AfterReturning;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.aspectj.lang.annotation.Pointcut;@Aspectpublic class SleepHelper {public SleepHelper(){}@Pointcut("execution(* *.sleep())")public void sleeppoint(){}@Before("sleeppoint()")public void beforeSleep(){System.out.println("睡觉前要脱衣服!");}@AfterReturning("sleeppoint()")public void afterSleep(){System.out.println("睡醒了要穿衣服！");}}用@Aspect的注解来标识切面,注意不要把它漏了，否则Spring创建代理的时候会找不到它,@Pointcut注解指定了切点，@Before和@AfterReturning指定了运行时的通知，注意的是要在注解中传入切点的名称然后我们在Spring配置文件上下点功夫,首先是增加AOP的XML命名空间和声明相关schema命名空间:xmlns:aop="http://www.springframework.org/schema/aop"schema声明:http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.0.xsd然后加上这个标签:<aop:aspectj-autoproxy/> 有了这个Spring就能够自动扫描被@Aspect标注的切面了最后是运行，很简单方便了：public class Test {public static void main(String[] args){ApplicationContext appCtx = new ("applicationContext.xml");Sleepable human = (Sleepable)appCtx.getBean("human");human.sleep();}}下面我们来看最后一种常用的实现AOP的方式:使用Spring来定义纯粹的POJO切面前面我们用到了<aop:aspectj-autoproxy/>标签,Spring在aop的命名空间里面还提供了其他的配置元素:<aop:advisor> 定义一个AOP通知者<aop:after> 后通知<aop:after-returning> 返回后通知<aop:after-throwing> 抛出后通知<aop:around> 周围通知<aop:aspect>定义一个切面<aop:before>前通知<aop:config>顶级配置元素，类似于<beans>这种东西<aop:pointcut>定义一个切点我们用AOP标签来实现睡觉这个过程:代码不变，只是修改配置文件,加入AOP配置即可:<aop:config><aop:aspect ref="sleepHelper"><aop:before method="beforeSleep" pointcut="execution(* *.sleep(..))"/><aop:after method="afterSleep" pointcut="execution(* *.sleep(..))"/></aop:aspect></aop:config>完！

㈡ spring中aop全注解时配置类怎么写

先说注解，使用注解配置Spring AOP总体分为两步，第一步是在xml文件中声明激活自动扫描组件功能，同时激活自动代理功能（同时在xml中添加一个UserService的普通服务层组件，来测试AOP的注解功能）：

第二步是为Aspect切面类添加注解：

package cn.ysh.studio.spring.aop.aspect;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.After;import org.aspectj.lang.annotation.AfterReturning;import org.aspectj.lang.annotation.AfterThrowing;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.aspectj.lang.annotation.Pointcut;import org.springframework.stereotype.Component;/*** 系统服务组件Aspect切面Bean* @author Shenghany* @date 2013-5-28*///声明这是一个组件@Component//声明这是一个切面Bean@Aspectpublic class ServiceAspect {private final static Log log = LogFactory.getLog(ServiceAspect.class);//配置切入点,该方法无方法体,主要为方便同类中其他方法使用此处配置的切入点@Pointcut("execution(* cn.ysh.studio.spring.aop.service..*(..))")public void aspect(){ }/** 配置前置通知,使用在方法aspect()上注册的切入点* 同时接受JoinPoint切入点对象,可以没有该参数*/@Before("aspect()")public void before(JoinPoint joinPoint){if(log.isInfoEnabled()){log.info("before " + joinPoint);}}//配置后置通知,使用在方法aspect()上注册的切入点@After("aspect()")public void after(JoinPoint joinPoint){if(log.isInfoEnabled()){log.info("after " + joinPoint);}}//配置环绕通知,使用在方法aspect()上注册的切入点@Around("aspect()")public void around(JoinPoint joinPoint){long start = System.currentTimeMillis();try {((ProceedingJoinPoint) joinPoint).proceed();long end = System.currentTimeMillis();if(log.isInfoEnabled()){log.info("around " + joinPoint + " Use time : " + (end – start) + " ms!");}} catch (Throwable e) {long end = System.currentTimeMillis();if(log.isInfoEnabled()){log.info("around " + joinPoint + " Use time : " + (end – start) + " ms with exception : " + e.getMessage());}}}//配置后置返回通知,使用在方法aspect()上注册的切入点@AfterReturning("aspect()")public void afterReturn(JoinPoint joinPoint){if(log.isInfoEnabled()){log.info("afterReturn " + joinPoint);}}//配置抛出异常后通知,使用在方法aspect()上注册的切入点@AfterThrowing(pointcut="aspect()", throwing="ex")public void afterThrow(JoinPoint joinPoint, Exception ex){if(log.isInfoEnabled()){log.info("afterThrow " + joinPoint + " " + ex.getMessage());}}}

测试代码：

package cn.ysh.studio.spring.aop;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.springframework.context.ApplicationContext;import org.springframework.context.support.;import cn.ysh.studio.spring.aop.service.UserService;import cn.ysh.studio.spring.mvc.bean.User;/*** Spring AOP测试* @author Shenghany* @date 2013-5-28*/public class Tester {private final static Log log = LogFactory.getLog(Tester.class);public static void main(String[] args) {//启动Spring容器ApplicationContext context = new ("applicationContext.xml");//获取service组件UserService service = (UserService) context.getBean("userService");//以普通的方式调用UserService对象的三个方法User user = service.get(1L);service.save(user);try {service.delete(1L);} catch (Exception e) {if(log.isWarnEnabled()){log.warn("Delete user : " + e.getMessage());}}}}

控制台输出如下：

INFO [spring.aop.aspect.ServiceAspect:40] before execution(User cn.ysh.studio.spring.aop.service.UserService.get(long))INFO [spring.aop.service.UserService:19] getUser method . . .INFO [spring.aop.aspect.ServiceAspect:60] around execution(User cn.ysh.studio.spring.aop.service.UserService.get(long)) Use time : 42 ms!INFO [spring.aop.aspect.ServiceAspect:48] after execution(User cn.ysh.studio.spring.aop.service.UserService.get(long))INFO [spring.aop.aspect.ServiceAspect:74] afterReturn execution(User cn.ysh.studio.spring.aop.service.UserService.get(long))INFO [spring.aop.aspect.ServiceAspect:40] before execution(void cn.ysh.studio.spring.aop.service.UserService.save(User))INFO [spring.aop.service.UserService:26] saveUser method . . .INFO [spring.aop.aspect.ServiceAspect:60] around execution(void cn.ysh.studio.spring.aop.service.UserService.save(User)) Use time : 2 ms!INFO [spring.aop.aspect.ServiceAspect:48] after execution(void cn.ysh.studio.spring.aop.service.UserService.save(User))INFO [spring.aop.aspect.ServiceAspect:74] afterReturn execution(void cn.ysh.studio.spring.aop.service.UserService.save(User))INFO [spring.aop.aspect.ServiceAspect:40] before execution(boolean cn.ysh.studio.spring.aop.service.UserService.delete(long))INFO [spring.aop.service.UserService:32] delete method . . .INFO [spring.aop.aspect.ServiceAspect:65] around execution(boolean cn.ysh.studio.spring.aop.service.UserService.delete(long)) Use time : 5 ms with exception : spring aop ThrowAdvice演示INFO [spring.aop.aspect.ServiceAspect:48] after execution(boolean cn.ysh.studio.spring.aop.service.UserService.delete(long))INFO [spring.aop.aspect.ServiceAspect:74] afterReturn execution(boolean cn.ysh.studio.spring.aop.service.UserService.delete(long))WARN [studio.spring.aop.Tester:32] Delete user : Null return value from advice does not match primitive return type for: public boolean cn.ysh.studio.spring.aop.service.UserService.delete(long) throws java.lang.Exception

可以看到，正如我们预期的那样，虽然我们并没有对UserSerivce类包括其调用方式做任何改变，但是Spring仍然拦截到了其中方法的调用，或许这正是AOP的魔力所在。

再简单说一下xml配置方式，其实也一样简单：

<?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:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsdhttp://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"><!– 系统服务组件的切面Bean –><bean id="serviceAspect" class="cn.ysh.studio.spring.aop.aspect.ServiceAspect"/><!– AOP配置 –><aop:config><!– 声明一个切面,并注入切面Bean,相当于@Aspect –><aop:aspect id="simpleAspect" ref="serviceAspect"><!– 配置一个切入点,相当于@Pointcut –><aop:pointcut expression="execution(* cn.ysh.studio.spring.aop.service..*(..))" id="simplePointcut"/><!– 配置通知,相当于@Before、@After、@AfterReturn、@Around、@AfterThrowing –><aop:before pointcut-ref="simplePointcut" method="before"/><aop:after pointcut-ref="simplePointcut" method="after"/><aop:after-returning pointcut-ref="simplePointcut" method="afterReturn"/><aop:after-throwing pointcut-ref="simplePointcut" method="afterThrow" throwing="ex"/></aop:aspect></aop:config></beans>

个人觉得不如注解灵活和强大，你可以不同意这个观点，但是不知道如下的代码会不会让你的想法有所改善：

//配置前置通知,拦截返回值为cn.ysh.studio.spring.mvc.bean.User的方法@Before("execution(cn.ysh.studio.spring.mvc.bean.User cn.ysh.studio.spring.aop.service..*(..))")public void beforeReturnUser(JoinPoint joinPoint){if(log.isInfoEnabled()){log.info("beforeReturnUser " + joinPoint);}}//配置前置通知,拦截参数为cn.ysh.studio.spring.mvc.bean.User的方法@Before("execution(* cn.ysh.studio.spring.aop.service..*(cn.ysh.studio.spring.mvc.bean.User))")public void beforeArgUser(JoinPoint joinPoint){if(log.isInfoEnabled()){log.info("beforeArgUser " + joinPoint);}}//配置前置通知,拦截含有long类型参数的方法,并将参数值注入到当前方法的形参id中@Before("aspect()&&args(id)")public void beforeArgId(JoinPoint joinPoint, long id){if(log.isInfoEnabled()){log.info("beforeArgId " + joinPoint + " ID:" + id);}}

附上UserService的代码(其实很简单)：

package cn.ysh.studio.spring.aop.service;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import cn.ysh.studio.spring.mvc.bean.User;/*** 用户服务模型* @author Shenghany* @date 2013-5-28*/public class UserService {private final static Log log = LogFactory.getLog(UserService.class);public User get(long id){if(log.isInfoEnabled()){log.info("getUser method . . .");}return new User();}public void save(User user){if(log.isInfoEnabled()){log.info("saveUser method . . .");}}public boolean delete(long id) throws Exception{if(log.isInfoEnabled()){log.info("delete method . . .");throw new Exception("spring aop ThrowAdvice演示");}return false;}}

应该说学习Spring AOP有两个难点，第一点在于理解AOP的理念和相关概念，第二点在于灵活掌握和使用切入点表达式。概念的理解通常不在一朝一夕，慢慢浸泡的时间长了，自然就明白了，下面我们简单地介绍一下切入点表达式的配置规则吧。

通常情况下，表达式中使用”execution“就可以满足大部分的要求。表达式格式如下：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

modifiers-pattern：方法的操作权限

ret-type-pattern：返回值

declaring-type-pattern：方法所在的包

name-pattern：方法名

parm-pattern：参数名

throws-pattern：异常

其中，除ret-type-pattern和name-pattern之外，其他都是可选的。上例中，execution(* com.spring.service.*.*(..))表示com.spring.service包下，返回值为任意类型；方法名任意；参数不作限制的所有方法。

最后说一下通知参数

可以通过args来绑定参数，这样就可以在通知（Advice）中访问具体参数了。例如，<aop:aspect>配置如下：

<aop:config><aop:aspect id="TestAspect" ref="aspectBean"><aop:pointcut id="businessService"expression="execution(* com.spring.service.*.*(String,..)) and args(msg,..)" /><aop:after pointcut-ref="businessService" method="doAfter"/></aop:aspect></aop:config>上面的代码args(msg,..)是指将切入点方法上的第一个String类型参数添加到参数名为msg的通知的入参上，这样就可以直接使用该参数啦。

㈢ spring配置aop的方式有哪些

1. 基于xml配置文件的代理配置方式这种方式在2.0以后很少用了，原因是配置项过多，过于繁琐。但对于理解Spring AOP还是很有帮助的1.1 定义通知<bean id="advice" class="yourAdviceImpl" />1.2 定义切点要定义一个切点，可以选择使用正则表达式方式声明的切点或者AspectJ方式声明的切点。对正则表达式切点，使用Perl5RegexpMethodPointcut或JdkRegexpMethodPointcut(Java 1.4以上版本，不需要Jakarta ORO的支持了)；对AspectJ切点，使用AspectJExpressPointcut<bean id="pointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut"> <property name="pattern" value="yourRegularExpression" /></bean><bean id="pointcut" class="org.springframework.aop.aspectj.AspectJExpressionPointcut"> <property name="expression" value="yourAspectJExpression" /></bean>1.3 定义通知者DefaultPointcutAdvisor是Spring提供的默认通知者，它需要提供通知和切点的引用。Spring也提供了RegexpMethodPointcutAdvisor和来对应两种声明切点的方式，不用再单独定义切点。<bean id="advisor" class="org.springframework.aop.support.DefaultPointcutAdvisor"> <property name="advice" ref="advice" /> <property name="pointcut" ref="pointcut" /></bean><bean id="advisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <property name="advice" ref="advice" /> <property name="pattern" value="yourRegularExpression" /></bean><bean id="advisor" class="org.springframework.aop.aspectj.AspectJExpressionPointcut"> <property name="advice" ref="advice" /> <property name="expression" value="yourAspectjExpression" /></bean>1.4 定义ProxyFactoryBean<bean id="yourBean" class="org.springframework.aop.framework.ProxyFactoryBean> <property name="target" ref="yourTargetBean" /> <property name="interceptorNames" value="advisor" /> <property name="proxyInterfaces" value="interfaceClass" /></bean>interceptorNames和proxyInterfaces都是数组属性，所以可以声明要使用的一个list，也可以让Spring自动把单个值转化为数组上面明确定义了要对那个targetBean应用代理生成切面实例。如果不想限制targetBean，可以让Spring为所有匹配切点声明的bean生成切面实例，这样就不用一个个定义ProxyFactoryBean了，只需要定义<bean class="org.springframework.aop.framework.autoproxy." />这是一个BeanPostProcessor，所以Spring会自动识别并在bean的声明周期使用2 利用2.0以后使用aop标签<aop:config> <aop:aspect ref=""> <aop:pointcut id="performance" expression="execution(* *.perform(..))" /> <aop:before method="" pointcut-ref="performance" /> <aop:before method="" pointcut="execution(* *.perform(..))" /> <aop:after-returning method="" pointcut="execution(* *.perform(..))" /> <aop:after-throwing method="" pointcut="execution(* *.perform(..))" /> </aop:aspect></aop:config>3 利用Annotation3.1 利用@Aspect将一个POJO类声明为一个切面。3.2 定义切点@Pointcut("execution(* *.perform(..))")public void performance(){}通过@Pointcut定义的切点的名字就是它所注解的方法的名字，因此例子中的切点名字是performance()。这里声明的performance()方法实际圣只是一个标记，为@Pointcut提供附加的点，并不要求有实际意义。3.3 定义通知对要执行切面的方法，通过@Before("performance()"),@AfterReturning("performance()")来定义通知。注意这里提供的切点名称，是performance(),而不是performance如果对上面的两点不是很理解，也可以省略@Pointcut，而将AspectJ表达式直接定义在@Before等通知中，将上面的两步合为一步，如@Before("execution(* *.perform(..))")3.4 通知Spring创建代理<aop:aspectj-autoproxy>这实际上相当于声明了一个，从而根据@Pointcut声明的切点来自动代理匹配的bean实例4 在Spring中结合进AspectJ对于超出Spring AOP支持范围的，可以采用这种方式。只需要在Spring中配置AspectJ的Class实例时让Spring能够获得AspectJ类的实例就可以了，比如<bean class="a_aspectj_class" factory-method="aspectOf"> <preperty …. /></bean>

㈣ aop在spring中怎么配置

aop在spring有两种配置方式1、通过bean配置（在xml文件配置）说明该示例配置起日志记录功能 <aop:config> <aop:aspect id="XX" ref="beanid指向具体配置的bean"> <aop:pointcut expression="切入点表达式" id="XX1"/> <aop:after method="记录方法" pointcut-ref="XX1" /> </aop:aspect> </aop:config> 2、使用AspectJ织入在spring.xml配置文件中启用AspectJ :<aop:aspectj-autoproxy />在你要用之为aop功能的类的头部加上@Aspect注解

㈤如何利用Spring编写一个aop的例子

打开Eclipse，新建Demo工程供编写测试程序使用。

spring配置文件aop|aop在spring中怎么配置

相关推荐

随便看看

热门标签

最新文章