Spring学习（21）--- AOP之Advice应用（上）

前置通知（Before advice）	在某个连接点（join point）之前执行的通知，但不能阻止连接点前的执行（除非它抛出异常）
返回后通知（After returning advice）	在某个连接点（join point）正常完成后执行的通知
抛出异常后通知（After throwing advice）	在方法抛出异常退出时执行的通知
后通知（After(finally) advice）	当某个连接点退出的时候执行的通知（无论是正常返回还是异常退出）
环绕通知（Around advice）	包围一个连接点（join point）的通知

（一）Before Advice

例子：

新建两个类：

package com.aop.schema;
/**
*
* 切面类
*
*/
public class MyAspect {

	public void before(){
		System.out.println("MyAspect.before");
	}
}

package com.aop.schema;
/**
*
* 业务类
*
*/
public class ApsectBiz {

	public void biz(){
		System.out.println("ApsectBiz.biz");
	}
}

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:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.1.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">

     <bean id="myAspect" class="com.aop.schema.MyAspect"></bean>

     <bean id="apsectBiz" class="com.aop.schema.ApsectBiz"></bean>

     <aop:config>
          <aop:aspect id="myAspectAOP" ref="myAspect">
            <aop:pointcut id="myPointcut" expression="execution(* com.aop.schema.ApsectBiz.*(..))" />
            <aop:before method="before" pointcut-ref="myPointcut"/>
          </aop:aspect>
     </aop:config>

</beans>

单元测试：

package com.aop.schema;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UnitTest {

	@Test
	public void test(){
		ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring-aop.xml");
		ApsectBiz biz = (ApsectBiz)context.getBean("apsectBiz");
		biz.biz();
	}
}

结果：

七月 09, 2015 10:30:24 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org[email protected]31b3c607: startup date [Thu Jul 09 22:30:24 CST 2015]; root of context hierarchy
七月 09, 2015 10:30:24 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring-aop.xml]
MyAspect.before
ApsectBiz.biz

PS：ApsectBiz.biz是业务方法，在它之前，执行了前置通知MyAspect.before，符合想要的结果

（二）After returning advice

例子：

修改一下切面类MyAspect（添加afterreturning方法）：

package com.aop.schema;
/**
*
* 切面类
*
*/
public class MyAspect {

	public void before(){
		System.out.println("MyAspect.before");
	}

	public void afterreturning(){
		System.out.println("MyAspect.afterreturning");
	}
}

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:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.1.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">

     <bean id="myAspect" class="com.aop.schema.MyAspect"></bean>

     <bean id="apsectBiz" class="com.aop.schema.ApsectBiz"></bean>

     <aop:config>
          <aop:aspect id="myAspectAOP" ref="myAspect">
            <aop:pointcut id="myPointcut" expression="execution(* com.aop.schema.ApsectBiz.*(..))" />
            <aop:before method="before" pointcut-ref="myPointcut"/>
            <aop:after-returning method="afterreturning" pointcut-ref="myPointcut"/>
          </aop:aspect>
     </aop:config>

</beans>

单元测试同上：

结果：

七月 09, 2015 10:38:41 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org[email protected]31b3c607: startup date [Thu Jul 09 22:38:41 CST 2015]; root of context hierarchy
七月 09, 2015 10:38:41 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring-aop.xml]
MyAspect.before
ApsectBiz.biz
MyAspect.afterreturning

（三）After throwing advice

说明：使用throwing属性来指定可被传递的异常的参数名称

例子：

修改一下切面类MyAspect（添加afterthrowing方法）：

package com.aop.schema;
/**
*
* 切面类
*
*/
public class MyAspect {

	public void before(){
		System.out.println("MyAspect.before");
	}

	public void afterreturning(){
		System.out.println("MyAspect.afterreturning");
	}

	public void afterthrowing(){
		System.out.println("MyAspect.afterthrowing");
	}
}

修改业务类ApsectBiz（抛出一个异常）：

package com.aop.schema;

/**
*
* 业务类
*
*/
public class ApsectBiz {

	public void biz(){
		System.out.println("ApsectBiz.biz");
		throw new RuntimeException();  //故意抛出异常
	}
}

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:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.1.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">

     <bean id="myAspect" class="com.aop.schema.MyAspect"></bean>

     <bean id="apsectBiz" class="com.aop.schema.ApsectBiz"></bean>

     <aop:config>
          <aop:aspect id="myAspectAOP" ref="myAspect">
            <aop:pointcut id="myPointcut" expression="execution(* com.aop.schema.ApsectBiz.*(..))" />
            <aop:before method="before" pointcut-ref="myPointcut"/>
            <aop:after-returning method="afterreturning" pointcut-ref="myPointcut"/>
            <aop:after-throwing method="afterthrowing" pointcut-ref="myPointcut"/>
          </aop:aspect>
     </aop:config>

</beans>

单元测试同上：

测试结果：

七月 09, 2015 10:47:46 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org[email protected]31b3c607: startup date [Thu Jul 09 22:47:46 CST 2015]; root of context hierarchy
七月 09, 2015 10:47:46 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring-aop.xml]
MyAspect.before
ApsectBiz.biz
MyAspect.afterthrowing

PS：有没有发现有什么问题？ MyAspect.afterreturning没有了，biz()中抛出异常，biz()方法没有正常返回，所以MyAspect.afterreturning没有了。

（四）After（finally） advice

修改一下切面类MyAspect（添加after方法）：

package com.aop.schema;
/**
*
* 切面类
*
*/
public class MyAspect {

	public void before(){
		System.out.println("MyAspect.before");
	}

	public void afterreturning(){
		System.out.println("MyAspect.afterreturning");
	}

	public void afterthrowing(){
		System.out.println("MyAspect.afterthrowing");
	}

	public void after(){
		System.out.println("MyAspect.after");
	}
}

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:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.1.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">

     <bean id="myAspect" class="com.aop.schema.MyAspect"></bean>

     <bean id="apsectBiz" class="com.aop.schema.ApsectBiz"></bean>

     <aop:config>
          <aop:aspect id="myAspectAOP" ref="myAspect">
            <aop:pointcut id="myPointcut" expression="execution(* com.aop.schema.ApsectBiz.*(..))" />
            <aop:before method="before" pointcut-ref="myPointcut"/>
            <aop:after-returning method="afterreturning" pointcut-ref="myPointcut"/>
            <aop:after-throwing method="afterthrowing" pointcut-ref="myPointcut"/>
            <aop:after method="after" pointcut-ref="myPointcut"/>
          </aop:aspect>
     </aop:config>

</beans>

单元测试同上：

结果：

七月 09, 2015 10:56:10 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org[email protected]31b3c607: startup date [Thu Jul 09 22:56:10 CST 2015]; root of context hierarchy
七月 09, 2015 10:56:10 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring-aop.xml]
MyAspect.before
ApsectBiz.biz
MyAspect.afterthrowing
MyAspect.after

（五）Around advice

注意：通知方法的第一个参数必ProceedingJoinPoint类型

例子：

修改一下切面类MyAspect（添加around方法）：

package com.aop.schema;

import org.aspectj.lang.ProceedingJoinPoint;

/**
*
* 切面类
*
*/
public class MyAspect {

	public void before(){
		System.out.println("MyAspect.before");
	}

	public void afterreturning(){
		System.out.println("MyAspect.afterreturning");
	}

	public void afterthrowing(){
		System.out.println("MyAspect.afterthrowing");
	}

	public void after(){
		System.out.println("MyAspect.after");
	}

	public void around(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("MyAspect.around_1");
		Object obj=pjp.proceed();
		System.out.println("MyAspect.around_2");
	}
}

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:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.1.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">

     <bean id="myAspect" class="com.aop.schema.MyAspect"></bean>

     <bean id="apsectBiz" class="com.aop.schema.ApsectBiz"></bean>

     <aop:config>
          <aop:aspect id="myAspectAOP" ref="myAspect">
            <aop:pointcut id="myPointcut" expression="execution(* com.aop.schema.ApsectBiz.*(..))" />
            <aop:before method="before" pointcut-ref="myPointcut"/>
            <aop:after-returning method="afterreturning" pointcut-ref="myPointcut"/>
            <aop:after-throwing method="afterthrowing" pointcut-ref="myPointcut"/>
            <aop:after method="after" pointcut-ref="myPointcut"/>
            <aop:around method="around" pointcut-ref="myPointcut"/>
          </aop:aspect>
     </aop:config>

</beans>

单元测试同上：

结果：

七月 09, 2015 11:15:20 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org[email protected]31b3c607: startup date [Thu Jul 09 23:15:20 CST 2015]; root of context hierarchy
七月 09, 2015 11:15:20 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring-aop.xml]
MyAspect.before
MyAspect.around_1
ApsectBiz.biz
java.lang.RuntimeException
    at com.aop.schema.ApsectBiz.biz(ApsectBiz.java:11)
    at com.aop.schema.ApsectBiz$$FastClassBySpringCGLIB$$ae10254d.invoke(<generated>)
    at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
    at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
    at org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint.proceed(MethodInvocationProceedingJoinPoint.java:85)
    at com.aop.schema.MyAspect.around(MyAspect.java:31)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    at java.lang.reflect.Method.invoke(Unknown Source)
    at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs(AbstractAspectJAdvice.java:621)
    at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod(AbstractAspectJAdvice.java:610)
    at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke(AspectJAroundAdvice.java:68)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
    at org.springframework.aop.aspectj.AspectJAfterAdvice.invoke(AspectJAfterAdvice.java:43)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
    at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:58)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
    at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:52)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
    at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:52)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
    at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
    at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653)
    at com.aop.schema.ApsectBiz$$EnhancerBySpringCGLIB$$1fbf7bae.biz(<generated>)
    at com.aop.schema.UnitTest.test(UnitTest.java:13)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    at java.lang.reflect.Method.invoke(Unknown Source)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:47)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:44)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:271)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:70)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:50)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:238)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:63)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:236)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:53)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:229)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:309)
    at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
    at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)
MyAspect.after
MyAspect.afterreturning

PS：有异常，仔细看，原来是around(ProceedingJoinPoint pjp)的try catch捕捉到了biz（）抛出的异常，现在把异常注释掉（try catch里面怎么处理异常？这里要看具体的业务需要，这里先注释掉）

package com.aop.schema;
/**
*
* 业务类
*
*/
public class ApsectBiz {

	public void biz(){
		System.out.println("ApsectBiz.biz");
		//throw new RuntimeException();  //故意抛出异常
	}
}

测试结果：

七月 09, 2015 11:18:17 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org[email protected]31b3c607: startup date [Thu Jul 09 23:18:17 CST 2015]; root of context hierarchy
七月 09, 2015 11:18:17 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring-aop.xml]
MyAspect.before
MyAspect.around_1
ApsectBiz.biz
MyAspect.around_2
MyAspect.after
MyAspect.afterreturning

时间： 2024-10-16 16:37:55

Spring学习（21）--- AOP之Advice应用（上）的相关文章

spring学习(二) ———— AOP之AspectJ框架的使用

前面讲解了spring的特性之一,IOC(控制反转),因为有了IOC,所以我们都不需要自己new对象了,想要什么,spring就给什么.而今天要学习spring的第二个重点,AOP.一篇讲解不完,所以这篇文章主要介绍一下什么是AOP,如何去理解AOP.理解完之后,在spring中如何使用AspectJ AOP框架的.看得懂,写的出spring配置的那么就学的差不多了.加油.建议都自己手动实现一遍,这样才能更好的理解. --WH 一.什么是AOP? AOP:面向切面编程,采用横向抽取机制,取代了传

Spring学习之Aop的各种增强方法

AspectJ允许使用注解用于定义切面.切入点和增强处理,而Spring框架则可以识别并根据这些注解来生成AOP代理.Spring只是使用了和AspectJ 5一样的注解,但并没有使用AspectJ的编译器或者织入器,底层依然使用SpringAOP来实现,依然是在运行时动态生成AOP代理,因此不需要增加额外的编译,也不需要AspectJ的织入器支持.而AspectJ采用编译时增强,所以AspectJ需要使用自己的编译器来编译Java文件,还需要织入器. 为了启用Spring对@AspectJ切面

Spring中的AOP——在Advice方法中获取目标方法的参数（转）

获取目标方法的信息访问目标方法最简单的做法是定义增强处理方法时,将第一个参数定义为JoinPoint类型,当该增强处理方法被调用时,该JoinPoint参数就代表了织入增强处理的连接点.JoinPoint里包含了如下几个常用的方法: Object[] getArgs:返回目标方法的参数 Signature getSignature:返回目标方法的签名 Object getTarget:返回被织入增强处理的目标对象 Object getThis:返回AOP框架为目标对象生成的代理对象注意:当使

spring学习之aop(面向切面编程)

AOP术语学习: Aspect:切面,封装用于横向插入系统功能(事务,日志)的类 Joinpoint:连接点,在程序执行过程中的某个阶段点 Pointcut:切入点,切面与程序流程的交叉点,即那些需要处理的连接点. Advice:在定义好的切入点所要执行的程序代码,可以理解为切面类中的方法. Target Object:通知的对象,如果aop采用的是动态aop实现,该对象就是一个被代理对象. Proxy:代理,将通知应用到目标对象之后,被动态创建的对象. Weaving:织入,将切面代码插入到目

Spring学习笔记-AOP前传之动态代理

假设有如下需求: 写一个计算器类,里面包含加减乘除四个方法.在每个方法开始前打印出该方法开始的消息,在每个方法结束前打印出该方法结束的消息和计算的结果. 普通方法,先写一个借口,然后在接口里实现四个方法.在每个方法里加上要打印的语句.实现代码如下. ArithmeticCalculator接口 package com.spring.aop.helloworld; public interface ArithmeticCalculator { int add(int i, int j); int

Spring学习之Aop的基本概念

转自:http://my.oschina.net/itblog/blog/209067 AOP的基本概念 AOP从运行的角度考虑程序的流程,提取业务处理过程的切面.AOP面向的是程序运行中的各个步骤,希望以更好的方式来组合业务逻辑的各个步骤.AOP框架并不与特定的代码耦合,AOP框架能处理程序执行中特定切入点,而不与具体某个类耦合(即在不污染某个类的情况下,处理这个类相关的切点).下面是一些AOP的一些术语: 切面(Aspect):业务流程运行的某个特定步骤,也就是应用运行过程的关注点,关注点通

spring学习注解AOP 通知传递参数

我们在对切点进行增强时,不建议对切点进行任何修改,因此不加以使用@PointCut注解打在切点上,尽量只在Advice上打注解(Before,After等),如果要在通知中接受切点的参数,可以使用JoinPoint或者ProceedingJoinPoint 在Spring AOP中可以通过两种方式传递参数给Advice(通知) (1)通过接受JoinPoint(非环绕通知)或ProceedingJoinPoint(环绕通知)参数,其实ProceedingJoinPoint是JointPoint的

Spring学习笔记AOP（四）

鲁春利的工作笔记,好记性不如烂笔头基于XML配置方式声明切面 Spring使用org.springframework.aop.Advisor接口表示切面的概念,Advisor表示只有一个通知(org.aopalliance.aop.Advice)和一个切入点(org.springframework.aop.Pointcut)的切面.Advisor可以使用<aop:config>标签下的<aop:advisor>标签定义. <aop:advisor id="标识&q

Spring学习之AOP

一.概述在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型.利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率. 简而言之,aop的作用就是在不修改源码的情况下对程序进行增强,如权限校验,日志记录,性

Spring学习笔记AOP（二）

鲁春利的工作笔记,好记性不如烂笔头要进行AOP编程,首先我们要在spring的配置文件中引入aop命名空间: 引入后AOP命名空间并启动对@AspectJ注解的支持(spring-context-aop-annotation.xml): <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance&q