Spring AOP总结
Posted Ricky_Fung
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Spring AOP总结相关的知识,希望对你有一定的参考价值。
Spring IOC和AOP是Spring框架的两大核心基石,本文将对Spring AOP做一个系统的总结。
什么是AOP
AOP(Aspect-Oriented Programming,面向切面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候,OOP则显得无能为力。也就是说,OOP允许你定义从上到下的关系,但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中,而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码,如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切(cross-cutting)代码,在OOP设计中,它导致了大量代码的重复,而不利于各个模块的重用。
而AOP技术则恰恰相反,它利用一种称为“横切”的技术,剖解开封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其名为“Aspect”,即切面。所谓“切面”,简单地说,就是将那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系,如果说“对象”是一个空心的圆柱体,其中封装的是对象的属性和行为;那么面向方面编程的方法,就仿佛一把利刃,将这些空心圆柱体剖开,以获得其内部的消息。而剖开的切面,也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原,不留痕迹。
使用“横切”技术,AOP把软件系统分为两个部分:核心关注点和横切关注点。业务处理的主要流程是核心关注点,与之关系不大的部分是横切关注点。横切关注点的一个特点是,他们经常发生在核心关注点的多处,而各处都基本相似。比如权限认证、日志、事务处理。AOP的作用在于分离系统中的各种关注点,将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说,AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”
实现AOP的技术,主要分为两大类:一是采用动态代理技术,利用拦截方法的方式,对该方法进行装饰,以取代原有对象行为的执行;二是采用静态织入的方式,引入特定的语法创建“切面”,从而使得编译器可以在编译期间织入有关“切面”的代码。
AOP术语
为了理解AOP,我们必须先了解AOP的相关术语:
切面(Aspect)
横切关注点的模块化(跨越应用程序多个模块的功能,比如 日志功能),这个关注点实现可能另外横切多个对象。
通知(Advice)
在AOP中,描述切面要完成的工作被称为通知。
Spring AOP 可以应用5种类型的通知:
- 前置通知(Before):在目标方法被调用之前调用通知功能
- 后置通知(After):在目标方法完成之后调用通知,此时不会关心方法的输出是什么
- 返回通知(After-returning):在目标方法成功执行之后调用通知
- 异常通知(After-throwing):在目标方法抛出异常后调用通知
- 环绕通知(Around):通知包裹了被通知的方法,在被通知的方法调用之前和调用之后执行自定义的行为
目标(Target)
包含连接点的对象。也被称作被通知或被代理对象。
代理(Proxy)
向目标对象应用通知之后创建的对象。在Spring中,AOP代理可以是JDK动态代理或者CGLIB代理。
连接点(Join point)
连接点是在应用执行过程中能够插入切面的一个点。这个点可以是类的某个方法调用前、调用后、方法抛出异常后等。切面代码可以利用这些点插入到应用的正常流程之中,并添加行为。
切点(Pointcut)
指定一个通知将被引发的一系列连接点的集合。AOP 通过切点定位到特定的连接点。切点和连接点不是一对一的关系,一个切点匹配多个连接点,切点通过 org.springframework.aop.Pointcut 接口进行描述,它使用类和方法作为连接点的查询条件。每个类都拥有多个连接点,例如 ArithmethicCalculator类的所有方法实际上都是连接点。
引入(Introduction)
引入允许我们向现有的类添加新的方法和属性(Spring提供了一个方法注入的功能)。
织入(Weaving)
织入描述的是把切面应用到目标对象来创建新的代理对象的过程。
Spring AOP 的切面是在运行时被织入,原理是使用了动态代理技术。Spring支持两种方式生成代理对象:JDK动态代理和CGLib,默认的策略是如果目标类是接口,则使用JDK动态代理技术,否则使用Cglib来生成代理。
Spring AOP使用
在 Spring2.0 以上版本中, 可以使用基于AspectJ 注解或基于 XML 配置的 AOP。
基于注解的方式
1、在pom.xml中声明AOP依赖
<properties>
<org.springframework.version>4.2.4.RELEASE</org.springframework.version>
<aspectj.version>1.8.8</aspectj.version>
<java.version>1.8</java.version>
<maven.compiler.version>3.1</maven.compiler.version>
<junit.version>4.12</junit.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<!-- AOP dependency -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>${aspectj.version}</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>${aspectj.version}</version>
<scope>runtime</scope>
</dependency>
2、以用户注册、登录为例,UserService负责处理用户注册、登录等相关逻辑。
package com.ricky.codelab.spring.aop;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.ricky.codelab.spring.aop.service.UserService;
public class SpringAOPMain {
public static void main(String[] args) {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aop.xml");
UserService userService = (UserService) ctx.getBean("userService");
userService.login("ricky", "123");
userService.register("jack", "abc");
ctx.close();
}
}
UserService 接口如下:
package com.ricky.codelab.spring.aop.service;
public interface UserService {
public String login(String username, String passowrd);
public String register(String username, String passowrd);
}
UserService 实现类代码:
package com.ricky.codelab.spring.aop.service;
import org.springframework.stereotype.Service;
@Service("userService")
public class UserServiceImpl implements UserService {
@Override
public String login(String username, String passowrd) {
System.out.println("login username:"+username+",passowrd:"+passowrd);
return "OK";
}
@Override
public String register(String username, String passowrd) {
System.out.println("register username:"+username+",passowrd:"+passowrd);
return "OK";
}
}
3、假设我们需要在UserService 的login方法执行前后增加日志服务模块,接下来我们要定义个切面,也就是所谓的日志功能的类。
package com.ricky.codelab.spring.aop;
import java.util.Arrays;
import java.util.List;
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.springframework.stereotype.Component;
@Aspect
@Component
public class LogAspect {
/**
* 前置通知:在方法执行前执行的代码
* @param joinpoint
*/
@Before("execution(String com.ricky.codelab.spring.aop.service.UserService.login(String,String))")
public void beforeExecute(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method "+methodName+ " begin with "+args);
}
/**
* 后置通知:在方法执行后执行的代码(无论该方法是否发生异常),注意后置通知拿不到执行的结果
* @param joinpoint
*/
@After("execution(String com.ricky.codelab.spring.aop.service.UserService.login(String,String))")
public void afterExecute(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method "+methodName+" end!");
}
/**
* 返回通知:在方法正常执行后执行的代码,可以获取到方法的返回值
* @param joinpoint
*/
@AfterReturning(value="execution(String com.ricky.codelab.spring.aop.service.UserService.login(String,String))",
returning="result")
public void afterReturning(JoinPoint joinPoint, Object result){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method "+methodName+" end with result:"+result);
}
/**
* 异常通知:在方法抛出异常之后执行,可以访问到异常信息,且可以指定出现特定异常信息时执行代码
* @param joinpoint
*/
@AfterThrowing(value="execution(String com.ricky.codelab.spring.aop.service.UserService.login(String,String))",
throwing="exception")
public void afterThrowing(JoinPoint joinPoint, Exception /**NullPointerException*/ exception){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method "+methodName+" occurs exception:"+exception);
}
/**
* 环绕通知, 围绕着方法执行
*/
@Around("execution(String com.ricky.codelab.spring.aop.service.UserService.login(String,String))")
public Object aroundMethod(ProceedingJoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method "+methodName+" around");
Object result = null;
try {
result = joinPoint.proceed();
} catch (Throwable e) {
e.printStackTrace();
}
return result;
}
}
在LogAspect 类中,@Aspect注解标示该类为切面类;@Before注解标示前置通知, 在方法执行之前执行;@Afte注解标示后置通知, 在方法执行之后执行。
AspectJ 支持 5 种类型的通知注解:
- @Before: 前置通知, 在方法执行之前执行
- @After: 后置通知, 在方法执行之后执行(无论是否发生异常)
- @AfterRunning: 返回通知, 在方法返回结果之后执行
- @AfterThrowing: 异常通知, 在方法抛出异常之后
- @Around: 环绕通知, 围绕着方法执行
可以在通知方法中声明声明一个类型为JoinPoint的参数,这样我们就可以访问到连接细节信息,如方法名称、参数值等。
以@Before(“execution(String com.ricky.codelab.spring.aop.service.UserServiceImpl.login(String,String))”)表达式为例
AspectJ 切入点表达式
- execution:表示在方法执行时触发
- 修饰符及返回值类型:表示方法修饰符及返回值类型,* 代表任意修饰符及任意返回值类型
- 方法名:包括方法所属类名与方法名
- 参数:表示方法形参,.. 匹配任意数量的参数
4、在配置文件中启用AspectJ自动代理
<?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.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
<!-- 自动扫描的包 -->
<context:component-scan base-package="com.ricky.codelab.spring.aop"></context:component-scan>
<!-- 启用AspectJ自动代理 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
重用切入点表达式
为了重用切入点表达式,我们可以使用@Pointcut注解来声明切入点表达式,然后在其他地方进行使用,如下:
package com.ricky.codelab.spring.aop;
import java.util.Arrays;
import java.util.List;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LogDeclareAspect {
/**
* 使用@Pointcut来声明切入点表达式
* 定义一个方法用来声明切入点表达式,一般地,该方法中不需要填入其它代码
*/
@Pointcut("execution(String com.ricky.codelab.spring.aop.service.UserService.login(String,String))")
public void declareJoinPointExpression(){
}
/**
* 前置通知:在方法执行前执行的代码
* @param joinpoint
*/
@Before("declareJoinPointExpression()")
public void beforeExecute(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method "+methodName+ " begin with "+args);
}
}
切面优先级
在同一个连接点上应用不止一个切面时, 除非明确指定, 否则它们的优先级是不确定的。可以使用@Order注解指定切面的优先级,值越小优先级越高。
@Order(1)
@Aspect
@Component
public class LogAspect {
}
基于XML配置的方式
这里介绍使用XML配置的方式来实现,还是以上面的com.ricky.codelab.spring.aop.service.UserService类为例进行说明。
1、定义切面
package com.ricky.codelab.spring.aop.xml;
import java.util.Arrays;
import java.util.List;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
public class LoggingAspect {
/**
* 前置通知:在方法执行前执行的代码
* @param joinpoint
*/
public void beforeExecute(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method "+methodName+ " begin with "+args);
}
/**
* 后置通知:在方法执行后执行的代码(无论该方法是否发生异常),注意后置通知拿不到执行的结果
* @param joinpoint
*/
public void afterExecute(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method "+methodName+" end!");
}
/**
* 返回通知:在方法正常执行后执行的代码,可以获取到方法的返回值
* @param joinpoint
*/
public void afterReturning(JoinPoint joinPoint, Object result){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method "+methodName+" end with result:"+result);
}
/**
* 异常通知:在方法抛出异常之后执行,可以访问到异常信息,且可以指定出现特定异常信息时执行代码
* @param joinpoint
*/
public void afterThrowing(JoinPoint joinPoint, Exception /**NullPointerException*/ exception){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method "+methodName+" occurs exception:"+exception);
}
/**
* 环绕通知, 围绕着方法执行
*/
public Object aroundMethod(ProceedingJoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method "+methodName+" around");
Object result = null;
try {
result = joinPoint.proceed();
} catch (Throwable e) {
e.printStackTrace();
}
return result;
}
}
package com.ricky.codelab.spring.aop.xml;
import java.util.Arrays;
import java.util.List;
import org.aspectj.lang.JoinPoint;
public class VlidationAspect {
/**
* 前置通知:在方法执行前执行的代码
* @param joinpoint
*/
public void validateArgs(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("-->vlidation method "+methodName+ " begin with "+args);
}
}
因为是采用XML文件配置,所以此时切面就不需要注解了。
2、XML文件配置
spring-aop-xml.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
<!-- 配置 bean -->
<bean id="userService"
class="com.ricky.codelab.spring.aop.service.UserServiceImpl"></bean>
<!-- 配置切面的 bean. -->
<bean id="loggingAspect"
class="com.ricky.codelab.spring.aop.xml.LoggingAspect"></bean>
<bean id="vlidationAspect"
class="com.ricky.codelab.spring.aop.xml.VlidationAspect"></bean>
<!-- 配置 AOP -->
<aop:config>
<!-- 配置切点表达式 -->
<aop:pointcut expression="execution(* com.ricky.codelab.spring.aop.service.UserService.login(String,String))"
id="pointcut"/>
<!-- 配置切面及通知 -->
<aop:aspect ref="loggingAspect" order="2">
<aop:before method="beforeExecute" pointcut-ref="pointcut"/>
<aop:after method="afterExecute" pointcut-ref="pointcut"/>
<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="exception"/>
<aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>
<!--
<aop:around method="aroundMethod" pointcut-ref="pointcut"/>
-->
</aop:aspect>
<aop:aspect ref="vlidationAspect" order="1">
<aop:before method="validateArgs" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
</beans>
小结
到此,Spring AOP常见的两种配置方式已总结完啦。后面会抽时间结合Spring AOP源码去分析它内部的实现原理。
上述所有代码均已上传至GitHub。
以上是关于Spring AOP总结的主要内容,如果未能解决你的问题,请参考以下文章