Spring框架-----AOP编程
文章目录
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
🔥1 、AOP简介
AOP 的全称是 Aspect Oriented Programming，即面向切面编程，它将业务逻辑的各个部
分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。
AOP 采取横向抽取机制，取代了传统纵向继承体系的重复性代码，其应用主要体现在
事务处理、日志管理、权限控制、异常处理等方面。
目前最流行的 AOP 技术有两个，分别为 Spring 框架的 AOP 和 AspectJ 框架。
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
🔥2 、什么是面向切面编程
把一个个的横切关注点放到某个模块中去，称之为切面。每个切面影响业务的一种功能，
切面的目的就是为了功能增强，将需要增强的方法做成切面，实现对业务的增强，就是面向 切面编程。
面向切面编程的目的：将与业务本身无关，却被业务模块所共同调用的功能代码封装成 切面，以减少系统的重复代码，降低耦合，提高可扩展性。
面向切面编程的优势：把多个方法前/后的共同代码抽离出来，使用动态代理机制来控 制，先执行抽离出来的代码，再执行每一个真实方法。
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
🔥3 、AOP术语
为了更好地理解 AOP，就需要对 AOP 的相关术语有一些了解，这些专业术语主要包含
Joinpoint、Pointcut、Advice、Target、Weaving、Proxy 和 Aspect，它们的含义如下表所示
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
🔥4 、Spring AOP 模块
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
🔥5 、Spring AOP 模块的使用
在使用Spring框架的AOP模块开发AOP时,需要添加核心容器的jar包以及aop的jar包
下载链接>>>>
注意:ThrowsAdvice接口是一个标识接口没有任何抽象对象.如果通知类型定义为异常通知,那么除了要实现ThrowsAdvice以外,还需要在切面中添加下面4个方法中的一个,并在该方法中实现具体的增强处理。
public void afterThrowing(Exception ex)
public void afterThrowing(RemoteException)
public void afterThrowing(Method method, Object[] args, Object target, Exception ex)
public void afterThrowing(Method method, Object[] args, Object target, ServletExcep
🌙5.1、基础使用
定义切面类
package wr.oyc.aop.aspect;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.ThrowsAdvice;
import java.lang.reflect.Method;
public class MyAspect implements MethodBeforeAdvice,
AfterReturningAdvice, MethodInterceptor, ThrowsAdvice {
@Override
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println("Before...."+method.getName());
}
@Override
public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
System.out.println("After...."+method.getName());
}
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
System.out.println("Around....Before" + methodInvocation.getMethod().getName());
Object obj = methodInvocation.proceed();
System.out.println("Around....After" + methodInvocation.getMethod().getName());
return obj;
}
public void afterThrowing(Exception ex){
System.out.println(ex.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--配置目标对象-->
<bean id="usersService"
class="wr.oyc.aop.aspect.service.imp.UserServiceImpl"/>
<!--配置切面对象-->
<bean id="myAspect" class="wr.oyc.aop.aspect.MyAspect"/>
<!--配置切面-->
<bean id="usersServiceProxy"
class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 配置目标对象所实现的接口-->
<property name="proxyInterfaces"
value="wr.oyc.aop.aspect.service.UserService"/><!-- 配置目标对象-->
<property name="target" ref="usersService"/>
<!--配置切面对象-->
<property name="interceptorNames">
<list>
<value>myAspect</value>
</list>
</property>
<!--如何生成代理对象 true:使用 CGLIB，false 使用 JDK 的 Proxy-->
<property name="proxyTargetClass" value="true"/>
</bean>
</beans>
测试类
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
🌙5.1、Spring AOP 模块的使用案例(理解后默写)
业务层
创建切面
配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--配置目标对象-->
<bean id="usersService"
class="wr.oyc.aop.service.imp.UserServiceImpl"/>
<!--配置切面对象-->
<bean id="myAspect" class="wr.oyc.aop.aspect.MyAspect"/>
<bean id="toUppercaseAspect" class="wr.oyc.aop.aspect.ToUppercaseAspect"/>
<!--配置切面-->
<bean id="usersServiceProxy"
class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 配置目标对象所实现的接口-->
<property name="proxyInterfaces"
value="wr.oyc.aop.service.UserService"/><!-- 配置目标对象-->
<property name="target" ref="usersService"/>
<!--配置切面对象-->
<property name="interceptorNames">
<list>
<value>myAspect</value>
<value>toUppercaseAspect</value>
</list>
</property>
<!--如何生成代理对象 true:使用 CGLIB，false 使用 JDK 的 Proxy-->
<property name="proxyTargetClass" value="true"/>
</bean>
</beans>
测试类
package wr.oyc.aop.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import wr.oyc.aop.service.UserService;
public class Test {
public static void main(String[] args) {
ApplicationContext applicationContext=
new ClassPathXmlApplicationContext("ApplicationContext_aop.xml");
UserService userService = (UserService) applicationContext.getBean("usersServiceProxy");
userService.addUsers("abc");
}
}
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
🔥6 、AspectJ 框架
🌙6.1、AspectJ 框架简介
AspectJ 是一个基于 Java 语言的 AOP 框架。在 Spring 2.0 以后，新增了对 AspectJ 框 架的支持。在
Spring 框架中建议使用 AspectJ 框架开发 AOP。
🌙6.2、AspectJ 框架中的通知类型
🌙6.3、Spring 整合 AspectJ 框架所依赖的 Jar 包
🌙6.4、AspectJ 框架配置 AOP 方式
🌺6.4.1、AspectJ 配置方式
AspectJ 配置方式是指使用 AspectJ 框架的配置方式来配置切面。在使用 AspectJ 配置切
面时，切面不需要实现一些特定的接口。
创建切面
package wr.oyc.aop.aspectj;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
public class MyAspect {
public void myBefore(JoinPoint joinPoint) {
//joinPoint.getTarget(); 获取目标对象
//joinPoint.getSignature().getName(); 获取目标方法名
//joinPoint.getArgs(); 获取目标方法参数列表
//joinPoint.getThis(); 获取代理对象
System.out.println("Before" + joinPoint.getSignature().getName());
}
public void myAfterReturning(JoinPoint joinPoint) {
System.out.println("After " + joinPoint.getSignature().getName());
}
public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("Around Before " + proceedingJoinPoint.getSignature().getName());
Object obj = proceedingJoinPoint.proceed();
System.out.println("Around After " + proceedingJoinPoint.getSignature().getName());
return obj;
}
public void myAfterThrowing(Exception e) {
System.out.println("Exception " + e);
}
public void myAfter() {
System.out.println("最终通知");
}
}
🌺6.4.2、Execution 表达式
🌺6.4.3、 使用 AspectJ 方式配置切面
🌺6.4.4、 多切面以及切面执行顺序的配置
在 AspectJ 配置方式中，可以添加多个aop:aspect标签实现多切面配置。在aop:aspect
标签中包含 order 属性用于配置执行切面的执行顺序
🌺6.4.5、 Schema_based 配置方式
Schema_based(基础模式)配置方式是指使用 Spring AOP 模块来定义切面并在 AspectJ 框架中对该切面进行配置。要求切面在定义通知类型时，需要实现特定接口。
🌺6.4.5、 使用 Schema_based 配置方式配置切面
🌺6.4.6、多切面以及切面执行顺序的配置
在 Schema_based 配置方式中，可以添加多个aop:advisor标签实现多切面配置。在
aop:advisor标签中包含 order 属性用于配置执行切面的执行顺序
🌙6.5、注解配置方式
AspectJ 框架允许使用注解定义切面、切入点和增强处理，而 Spring 框架则可以识别并
根据这些注解生成 AOP 代理。
🌺6.5.1、配置注解切面
🌺6.5.2、多切面以及切面执行顺序的配置
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
1122
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
