Spring5 中的 AOP
一,AOP 概念
1,什么是 AOP
(1)面向切面编程(面向方面编程),对业务逻辑层的各个部分进行隔离,从而使的业务层各个部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
(2)不修改源代码,而是在主干功能里面添加新功能
(3)只能在判断模块添加新的功能
二,底层原理
1,AOP 底层使用动态代理
(1)有两种情况动态代理
- 第一种,有接口情况,使用 JDK 动态代理
创建接口实现类代理对象,增强类的方法 - 第二种,没有接口情况,使用 CGLIB 动态代理
创建当前类子类的代理对象,增强类的方法
三,JDK动态代理
1,使用JDK动态代理,使用Proxy类里面的方法创建代理对象
(1)调用newProxyInstance方法
有三个参数: - 第一个:类加载器;
- 第二个:增强方法所在的类,这个类实现的接口,支持多个接口;
- 第三个:实现这个接口InvocationHandler,创建代理对象,写增强的方法
2,编写JDK动态代理代码
(1)创建接口,定义方法
public interface UserDao {
public int add(int a, int b);
public String updata(String id);
}
(2)创建接口实现类,实现方法
public class UserDaoImpl implements UserDao {
@Override
public int add(int a, int b) {
System.out.println("add方法执行了....");
return a + b;
}
@Override
public String updata(String id) {
System.out.println("updata方法执行了....");
return id;
}
}
(3)使用Proxy类创建接口代理对象
public class JDKProxy {
public static void main(String[] args) {
//创建接口实现类代理对象
Class[] interfaces = {UserDao.class};
// 方法1:匿名内部类
// Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
// //new InvocationHandler()匿名内部类
// @Override
// public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// return null;
// }
// });
//方法2:
UserDaoImpl userDao = new UserDaoImpl();
//下面这一行类似于UserDao dao = new UserDaoImpl();
UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
int result = dao.add(1, 2);
System.out.println("result:" + result);
}
}
//创建代理对象代码
class UserDaoProxy implements InvocationHandler {
//1,把创建的是谁的代理对象,把谁传递过来
//有参数构造传递
private Object obj;
//也可以传UserDaoImpl
public UserDaoProxy(Object obj) {
this.obj = obj;
}
//增强的逻辑
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方法之前
System.out.println("方法之前执行...." + method.getName() + ":传递的参数...." + Arrays.toString(args));
//被增强的方法执行
Object res = method.invoke(obj, args);
//方法之后
System.out.println("方法之后执行...." + obj);
return res;
}
}
4,打印结果
方法之前执行…add:传递的参数…[1, 2]
add方法执行了…
方法之后执行…com.at.spring5.UserDaoImpl@78308db1
result:3
四,AOP术语
1,连接点
类中哪些方法 可以被增强 ,这些可以被增强的方法称为连接点。
2,切入点
实际被增强 的方法,被称为切入点
3,通知(增强)
(1)实践增强的逻辑部分,称之为通知(增强);
(2)通知有多种类型:
- 前置通知
- 后置通知
- 环绕通知
- 异常通知
- 最终通知 (类似于finally)
4,切面
是动作:
- 把通知应用到切入点的过程
五,AOP操作 准备
1,Spring 框架一般基于 AspectJ 实现 AOP操作
(1)什么是 AspectJ
- AspectJ 不是 Spring 组成部分,独立 AOP 框架,一般把 AspectJ 和 Spring 框架一起使用,进行 AOP 操作
2,基于 AspectJ 实现 AOP 操作
(1)基于 xml 配置文件实现
(2)基于注解方式实现(使用)
3,在项目工程里面引入 AOP 相关依赖
4,切入点表达式
(1)切入点表达式作用:知道对哪个类里面的哪个方法进行增强
(2)语法结构:
execution(【仅限修饰符】【返回类型】【安全路径】【方法名称】(【参数列表】))
举例1:对com.dao.Book类的add进行增强:
execution(*com.dao.Book.add(…))
举例2:对com.dao.Book类的所有方法进行增强:
execution(*com.dao.Book.*(…))
举例3:对com.dao包中的所有类的所有方法进行增强:
execution(*com.dao.*.*(…))
六,AspectJ 注解实现
1,创建类,在类里面定义方法
//被增强的类
public class User {
public void add() {
System.out.println("add...");
}
}
2,创建增强类(编写增强逻辑)
(1)在增强类里面,创建方法,让不同的方法代表不同的通知类型
//增强的类
public class UserProxy {
//前置通知
public void before(){
System.out.println("before...");
}
}
3,进行通知的配置
(1)在 spring 配置文件中,开启注释扫描(可以用:配置类或者配置文件)
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--开启注解扫描-->
<context:component-scan base-package="com.at.spring5.aopanno"></context:component-scan>
</beans>
(2)使用注解创建 User 和 UserProxy 对象
//被增强的类
@Component
public class User {
public void add() {
System.out.println("add...");
}
}
//增强的类
@Component
public class UserProxy {
//前置通知
public void before(){
System.out.println("before...");
}
}
(3)在增强类上面添加注释 @Aspect
//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
//前置通知
public void before(){
System.out.println("before...");
}
}
(4)在 spring 配置文件中开启生成代理对象
<!--开启Aspect生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
4,配置不同类型的通知
(1)在增强类的里面,在作为通知方法上面添加通知类型注解,使用切入点表达式配置
//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
//前置通知
@Before(value = "execution(* com.at.spring5.aopanno.User.add(..))")
public void before(){
System.out.println("before...");
}
}
5,测试
(1)测试类
public class TestAop {
@Test
public void textAopAnno(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
User user = context.getBean("user",User.class);
user.add();
}
}
(2)结果
before…
add…
6,更多方法
(1)增强的类
//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
//前置通知
@Before(value = "execution(* com.at.spring5.aopanno.User.add(..))")
public void before(){
System.out.println("before...");
}
//方法之后必执行,最终通知
@After(value = "execution(* com.at.spring5.aopanno.User.add(..))")
public void after(){
System.out.println("after...");
}
//方法返回结果之后执行,返回通知
@AfterReturning(value = "execution(* com.at.spring5.aopanno.User.add(..))")
public void afterReturning(){
System.out.println("afterReturning...");
}
//异常通知
@AfterThrowing(value = "execution(* com.at.spring5.aopanno.User.add(..))")
public void afterThrowing(){
System.out.println("afterThrowing...");
}
//环绕通知
@Around(value = "execution(* com.at.spring5.aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前...");
//被增强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后...");
}
}
(2)正常输出结果
环绕之前…
before…
add…
环绕之后…
after…
afterReturning…
(2)异常时输出结果
环绕之前…
before…
after…
afterThrowing…
7,公共(相同的)切入点抽取
public class UserProxy {
//相同切入点抽取
@Pointcut(value = "execution(* com.at.spring5.aopanno.User.add(..))")
public void pointcut() {}
//前置通知
@Before(value = "pointcut()")
public void before() {
System.out.println("before...");
}
}
8,若是有多个增强类同时对一个方法进行增强,设置增强类优先级
(1)在增强类上面添加注释@Oeder(数字类型值),数字值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy {
//前置通知
@Before(value = "execution(* com.at.spring5.aopanno.User.add(..))")
public void before() {
System.out.println("Person before...");
}
}
(2)在原先的UserProxy中添加@Order(3)
//增强的类
@Component
@Aspect //生成代理对象
@Order(3)
public class UserProxy {
(3)结果:
Person before…
环绕之前…
before…
after…
afterThrowing…
8,完全使用注解开发
(1)创建配置类,不需要创建xml配置文件
@Configuration
@ComponentScan(basePackages = {"com.at"})
@EnableAspectJAutoProxy(proxyTargetClass = true) //等同于配置文件中的"开启Aspect生成代理对象"
public class ConfigAop {
}
七,AspectJ 配置文件实现(不常用,了解即可)
1,创建两个类,增强类和被增强类,创建方法
//被增强的方法
public class Book {
public void buy() {
System.out.println("buy...");
}
}
//增强的方法
public class BookProxy {
public void before() {
System.out.println("before...");
}
}
2,在 spring 配置文件中创建两个类对象
<!--创建对象-->
<bean id="book" class="com.at.spring5.aopxml.Book"></bean>
<bean id="book" class="com.at.spring5.aopxml.BookProxy"></bean>
3,在 spring 配置文件中配置切入点
<!--配置aop增强-->
<aop:config>
<!--切入点-->
<aop:pointcut id="p" expression="execution(* com.at.spring5.aopxml.Book.buy(..))"/>
<!--配置切面-->
<aop:aspect ref="bookProxy">
<!--增强作用在具体的方法上-->
<aop:before method="before" pointcut-ref="p"/>
</aop:aspect>
</aop:config>