1 AOP
AOP(Aspect Oriented Programming),即面向切面编程.
OOP(Object Oriented Programming ),即面向对象编程.
AOP面向切面编程,利用 一种称为"横切"
的技术,剖开封装的对象内部,并将那些影响了 多个类的公共行为
抽取出封装到一个可重用模块,并将其命名 为"Aspect",即切面。所谓"切面",简单说就是那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块之间的耦合度,并有利于未来的可操作性和可维护性
面向切面编程的作用:就是将项目中与核心逻辑无关的代码横向抽取成切面类,通过织入作用到目标方法,以使目标方法执行前后达到增强的效果.
好处:减少系统的重复代码,降低模块之间的耦合度,便于维护,可以只关注核心业务
1.2 AOP术语
连接点(Joinpoint):连接点是程序类中客观存在的方法,可被Spring拦截并切入内容。即每个方法在切入之前,都是连接点
切入点
(Pointcut):被Spring切入连接点。即真正会增强的目标方法
通知、增强
(Advice):可以为切入点添加额外功能,分为:前置通知、后置通知、异常通知、环绕通知等。
目标对象
(Target):被代理的目标对象
织入(Weaving):把通知应用到具体的类,进而创建新的代理类的过程。
代理
(Proxy):被AOP织入通知后,产生的结代理类。
切面
(Aspect):由切点和通知组成,将横切逻辑织入切面所指 定的连接点中
1.3 应用场景
- 事务管理
- 后续spring管理事务用的AOP原理
- 权限校验
- 后期使用Spring Security注解开发时,其实利用了AOP思想
- 日志记录
- 性能检测
- 等等
1.4 AOP入门编程【重点】
需求: UserService以及UserServiceImpl,在其中方法执行前,后执行增强的方法
编程的过程:
- 创建项目
- 导入依赖
- 核心依赖
- 切面依赖
- 目标类
- 切面类
- 织入(配置文件设置)
- 测试
1.4.1导入依赖
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.1.6.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.1</version>
<scope>test</scope>
</dependency>
</dependencies>
1.4.2 目标类
public interface UserService {
void findUserById();
void deleteUserById();
}
public class UserServiceImpl implements UserService {
@Override
public void findUserById() {
System.out.println("核心业务---> 查询用户" );
}
@Override
public void deleteUserById() {
System.out.println("核心业务---> 删除用户" );
}
}
1.4.3 切面类
演示的环绕通知
public class MyAspect {
/**
* 定义增强的方法:如果前后都要增强的方法
* 那么就还使用环绕通知/增强
*/
/**
* 自定义环绕通知
* @param joinPoint 连接点/切入点,即目标方法
* @return 目标方法的返回值
*/
public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
// 目标方法前:
System.out.println("开启事务/权限校验" );
// 目标方法执行
Object ret = joinPoint.proceed( );
System.out.println("目标方法返回值---> " + ret );
// 目标方法后:
System.out.println("提交事务/日志记录" );
return ret;
}
}
1.4.4 配置(织入)
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 目标类,UserService -->
<bean id="userService" class="com.qf.service.impl.UserServiceImpl"/>
<!-- 切面类 -->
<bean id="myAspect" class="com.qf.aspect.MyAspect"/>
<!-- 织入 -->
<aop:config>
<!-- 确定切面-->
<aop:aspect ref="myAspect">
<!-- 1确定通知/增强类型 -->
<!-- 2确定切面中增强的方法 -->
<!-- 3确定目标类以及目标方法
execution(返回值类型 包路径.类名.方法名(参数))
返回值类型任意,写 *
包路径,写com.qf
类名,UserServiceImpl,如果是所有类,写 *
方法名,findUserById,如果是所有方法,写 *
() 参数列表
(..) 代表任意参数
-->
<aop:around method="myAround"
pointcut="execution(* com.qf.service.impl.*.*(..))"/>
</aop:aspect>
</aop:config>
</beans>
1.4.5 测试
@Test
public void testAspect() {
String path = "applicationContext.xml";
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(path);
UserService userService = context.getBean("userService", UserService.class);
userService.findUserById();
System.out.println("-----------------" );
userService.deleteUserById();
}
开启事务/权限校验
核心业务---> 查询用户
目标方法返回值---> null
提交事务/日志记录
-----------------
开启事务/权限校验
核心业务---> 删除用户
目标方法返回值---> null
提交事务/日志记录
1.5 其他增强【重点】
package com.qf.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
public class MyAspect {
/**
* 定义增强的方法:如果前后都要增强的方法
* 那么就还使用环绕通知/增强
*/
/**
* 自定义环绕通知
* @param joinPoint 连接点/切入点,即目标方法
* @return 目标方法的返回值
*/
public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
// 目标方法前:
System.out.println("开启事务/权限校验" );
// 目标方法执行
Object ret = joinPoint.proceed( );
System.out.println("目标方法返回值---> " + ret );
// 目标方法后:
System.out.println("提交事务/日志记录" );
return ret;
}
/**
* 自定义前置通知
* @param joinPoint,目标对象
*/
public void myBefore(JoinPoint joinPoint) {
// 目标对象
Object target = joinPoint.getTarget( );
System.out.println("target = " + target);
// 获得目标方法签名(方法名)
Signature signature = joinPoint.getSignature( );
System.out.println("signature = " + signature);
System.out.println("前置通知--->权限校验--->OK" );
// 假设权限校验没有通过,通过抛出异常让代码停下,不再执行目标方法
// System.out.println("前置通知--->权限校验--->ERROR" );
// throw new RuntimeException("权限校验--->ERROR");
}
/**
* 自定义后置通知
*/
public void myAfter() {
System.out.println("后置通知--->记录日志,释放资源" );
}
/**
* 自定义后置返回通知
* @param ret 用于接收目标方法返回的数据
* @return
*/
public Object myAfterRet(Object ret) {
System.out.println("后置返回通知,接收到目标方法返回值--->" + ret);
// 可以对返回的数据进行处理
if (ret instanceof Integer) {
Integer value = (Integer) ret;
value *= 3;
// 【BUG,返回值没有返回给目标方法】
return value;
}
return ret;
}
public void myException(Exception e) {
System.out.println("目标方法报的错---> " + e.getMessage());
}
}
1.5.2 配置
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 目标类,UserService -->
<bean id="userService" class="com.qf.service.impl.UserServiceImpl"/>
<bean id="houseService" class="com.qf.service.impl.HouseServiceImpl"/>
<!-- 切面类 -->
<bean id="myAspect" class="com.qf.aspect.MyAspect"/>
<!-- 织入 -->
<aop:config>
<!-- 确定切面-->
<aop:aspect ref="myAspect">
<!-- 1确定通知/增强类型 -->
<!-- 2确定切面中增强的方法 -->
<!-- 3确定目标类以及目标方法
execution(返回值类型 包路径.类名.方法名(参数))
返回值类型任意,写 *
包路径,写com.qf
类名,UserServiceImpl,如果是所有类,写 *
方法名,findUserById,如果是所有方法,写 *
() 参数列表
(..) 代表任意参数
-->
<!--<aop:around method="myAround"
pointcut="execution(* com.qf.service.impl.*.*(..))"/>
-->
<!--<aop:before method="myBefore"
pointcut="execution(* com.qf.service.impl.*.*(..))"/>
-->
<!--<aop:after method="myAfter" pointcut="execution(* com.qf.service.impl.*.*(..))"/>-->
<!--
returning用来绑定目标方法执行后返回值,ret是myAfterRet方法的参数名
-->
<!--<aop:after-returning returning="ret" method="myAfterRet"
pointcut="execution(* com.qf.service.impl.*.*(..))"/>-->
<!-- throwing绑定目标方法抛出的异常,要传入给增强方法myException的参数 -->
<aop:after-throwing throwing="e" method="myException" pointcut="execution(* com.qf.service.impl.*.*(..))"/>
</aop:aspect>
</aop:config>
</beans>
1.6 总结
- 通过AOP提供的编码流程,更便利的定制切面,更方便的定制了动态代理。
- 进而彻底解决了辅助功能(事务管理,日志记录,权限校验)冗余的问题;
- 业务类中职责单一性得到更好保障;
- 辅助功能也有很好的复用性。
1.7 AOP底层动态代理【面试】
AOP的底层使用 的就是动态代理,使用的技术
jdk+cglib都用了
- 当目标类有接口的时候使用JDK动态代理
- 当目标类没有实现接口时,使用CGLIB动态代理
2 注解开发AOP【重点】
IOC,DI,AOP全部使用注解开发
注解 | 解释 |
---|---|
@Aspect | 声明类为切面类 |
@Around | 环绕通知 |
@Before | 前置通知 |
@After | 后置通知 |
@AfterReturning | 后置返回通知 |
@AfterThrowing | 异常通知 |
@Pointcut | 抽取切入点表达式 |
业务层类加注解@Service,@Autowired
重点是给切面类加注解
package com.qf.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
/**
*
*
*
* @desc 切面
*/
@Component // 该注解,spring创建该类对象
@Aspect // 该注解,该类是切面类
public class MyAspectAnno {
/**
* 定义一个切入点表达式公共方法
*/
@Pointcut("execution(* com.qf.service.impl.*.*(..))")
public void myPointcut(){}
@Around("myPointcut()")
public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
// 目标方法前:
System.out.println("开启事务/权限校验" );
// 目标方法执行
Object ret = joinPoint.proceed( );
System.out.println("目标方法返回值---> " + ret );
// 目标方法后:
System.out.println("提交事务/日志记录" );
return ret;
}
@Before("myPointcut()")
public void myBefore(JoinPoint joinPoint) {
// 目标对象
Object target = joinPoint.getTarget( );
System.out.println("target = " + target);
// 获得目标方法签名(方法名)
Signature signature = joinPoint.getSignature( );
System.out.println("signature = " + signature);
System.out.println("前置通知--->权限校验--->OK" );
// 假设权限校验没有通过,通过抛出异常让代码停下,不再执行目标方法
// System.out.println("前置通知--->权限校验--->ERROR" );
// throw new RuntimeException("权限校验--->ERROR");
}
@After("myPointcut()")
public void myAfter() {
System.out.println("后置通知--->记录日志,释放资源" );
}
@AfterReturning(value = "myPointcut()",returning = "ret")
public Object myAfterRet(Object ret) {
System.out.println("后置返回通知,接收到目标方法返回值--->" + ret);
// 可以对返回的数据进行处理
if (ret instanceof Integer) {
Integer value = (Integer) ret;
value *= 3;
// 【BUG,返回值没有返回给目标方法】
return value;
}
return ret;
}
@AfterThrowing(value = "myPointcut()",throwing = "e")
public void myException(Exception e) {
System.out.println("目标方法报的错---> " + e.getMessage());
}
}
配置文件扫描注解,让注解生效
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 扫描IOC,DI注解 -->
<context:component-scan base-package="com.qf"/>
<!-- AOP开启自动代理,注解生效 -->
<aop:aspectj-autoproxy/>
</beans>
测试即可
@Test
public void testAspectByAnno() {
String path = "applicationContextAnno.xml";
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(path);
// 使用注解,对象名,默认是类名首字母小写
UserService userService = context.getBean("userServiceImpl", UserService.class);
userService.findUserById();
System.out.println("-----------------" );
userService.deleteUserById();
System.out.println("-----------------" );
HouseService houseService = context.getBean("houseServiceImpl", HouseService.class);
int i = houseService.deleteHouse( );
System.out.println("i = " + i);
}