Spring学习笔记 第八章 AOP
AOP: Aspect Oriented Programming 面向切面编程
AOP的优点:
- 降低模块之间的耦合度
- 使系统更容易扩展
- 更好的代码复用
- 非业务代码更加集中,不分散,便于统一管理
- 业务代码更加简洁纯粹,没有其他代码的影响
AOP是对面向对象编程的补充,在运行时,动态的将代码切入到类的指定方法、指定位置上的编程思想就是面向切面编程。将不同方法同一个位置抽象成一个切面对象,对该切面进行编程就是AOP。
如何使用?
1.创建Maven工程,pom.xml添加
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.0.11.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.0.11.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.11.RELEASE</version>
</dependency>
2.创建一个计算器接口Cal,定义四个方法
package com.Fw.utils;
public interface Cal {
public int add(int num1, int num2);
public int sub(int num1, int num2);
public int mul(int num1, int num2);
public int div(int num1, int num2);
}
3.创建接口的实现类
①传统方式:
package com.Fw.utils.Impl;
import com.Fw.utils.Cal;
public class CalImpl implements Cal {
public int add(int num1, int num2) {
System.out.println("add方法的参数是[" + num1 + "," + num2 + "]");
int result = num1 + num2;
System.out.println("add方法的结果是" + result);
return result;
}
public int sub(int num1, int num2) {
System.out.println("sub方法的参数是[" + num1 + "," + num2 + "]");
int result = num1 - num2;
System.out.println("sub方法的结果是" + result);
return result;
}
public int mul(int num1, int num2) {
System.out.println("mul方法的参数是[" + num1 + "," + num2 + "]");
int result = num1 * num2;
System.out.println("mul方法的结果是" + result);
return result;
}
public int div(int num1, int num2) {
System.out.println("div方法的参数是[" + num1 + "," + num2 + "]");
int result = num1 / num2;
System.out.println("div方法的结果是" + result);
return result;
}
}
package com.Fw.test;
import com.Fw.utils.Cal;
import com.Fw.utils.Impl.CalImpl;
public class Test {
public static void main(String[] args) {
Cal cal = new CalImpl();
cal.add(1, 1);
cal.sub(2, 1);
cal.mul(2, 3);
cal.div(6, 2);
}
}
运行结果:
add方法的参数是[1,1]
add方法的结果是2
sub方法的参数是[2,1]
sub方法的结果是1
mul方法的参数是[2,3]
mul方法的结果是6
div方法的参数是[6,2]
div方法的结果是3
上述代码中,日志信息和业务逻辑的耦合性很高,不利于系统的维护,使用AOP可以进行优化,如何来实现AOP?使用动态代理的方式来实现。
给业务代码找一个代理,打印日志信息的工作交给代理来做,这样业务代码就只需要关注自身的业务逻辑即可。
②通过动态代理来实现AOP的过程:
package com.Fw.utils.Impl;
import com.Fw.utils.Cal;
public class CalImpl implements Cal {
public int add(int num1, int num2) {
int result = num1 + num2;
return result;
}
public int sub(int num1, int num2) {
int result = num1 - num2;
return result;
}
public int mul(int num1, int num2) {
int result = num1 * num2;
return result;
}
public int div(int num1, int num2) {
int result = num1 / num2;
return result;
}
}
package com.Fw.utils;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class MyInvocationHandler implements InvocationHandler {
// 接收委托对象
private Object object = null;
// 返回代理对象
public Object bind(Object object) {
this.object = object;
// 返回一个动态代理,具备委托对象的所有功能
return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(method.getName() + "方法的参数是" + Arrays.toString(args));
Object result = method.invoke(this.object, args);
System.out.println(method.getName() + "方法的结果是" + result);
return result;
}
}
package com.Fw.test;
import com.Fw.utils.Cal;
import com.Fw.utils.MyInvocationHandler;
import com.Fw.utils.Impl.CalImpl;
public class Test {
public static void main(String[] args) {
Cal cal = new CalImpl();
MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
Cal proxy = (Cal) myInvocationHandler.bind(cal);
proxy.add(1, 1);
proxy.sub(2, 1);
proxy.mul(2, 3);
proxy.div(6, 2);
}
}
以上是通过动态代理实现AOP的过程,比较复杂,不好理解,Spring框架对AOP进行了封装,使用Spring框架可以用面向对象的思想来实现AOP。
Spring框架中不需要创建InvocationHandler,只需要创建一个切面对象,将所有的非业务代码在切面对象中完成即可。Spring框架底层会自动根据切面类以及目标类生成一个代理对象。
③Spring框架实现方式:
package com.Fw.aop;
import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LoggerAspect {
// 切割CalImpl里的所有方法,*是方法通配符,。。是参数通配符
// 在执行方法的业务前执行
@Before(value = "execution(public int com.Fw.utils.Impl.CalImpl.*(..))")
public void before(JoinPoint joinPoint) {
// 获取方法名
String name = joinPoint.getSignature().getName();
// 获取参数
String args = Arrays.toString(joinPoint.getArgs());
System.out.println(name + "方法的参数是:" + args);
}
@After(value = "execution(public int com.Fw.utils.Impl.CalImpl.*(..))")
public void after(JoinPoint joinPoint) {
// 获取方法名
String name = joinPoint.getSignature().getName();
System.out.println(name + "方法的结果执行完毕");
}
@AfterReturning(value = "execution(public int com.Fw.utils.Impl.CalImpl.*(..))", returning = "result")
public void afterReturning(JoinPoint joinPoint, Object result) {
// 获取方法名
String name = joinPoint.getSignature().getName();
System.out.println(name + "方法的结果是:" + result);
}
@AfterThrowing(value = "execution(public int com.Fw.utils.Impl.CalImpl.*(..))", throwing="exception")
public void afterThrowing(JoinPoint joinPoint, Exception exception) {
// 获取方法名
String name = joinPoint.getSignature().getName();
System.out.println(name + "方法拋出異常:" + exception);
}
}
LoggerAspect类定义处添加的两个注解:
- @Aspect:表示该类是切面类
- @Component:将该类注入到IoC容器中
具体方法处添加的注解:
- @Before:表示方法执行的具体位置和时机
CalImpl也需要添加@Component,交给IoC管理
package com.Fw.utils.Impl;
import org.springframework.stereotype.Component;
import com.Fw.utils.Cal;
@Component
public class CalImpl implements Cal {
public int add(int num1, int num2) {
int result = num1 + num2;
return result;
}
public int sub(int num1, int num2) {
int result = num1 - num2;
return result;
}
public int mul(int num1, int num2) {
int result = num1 * num2;
return result;
}
public int div(int num1, int num2) {
int result = num1 / num2;
return result;
}
}
spring.xm中配置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"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:p="http://www.springframework.org/schema/p"
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.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 自动扫描 -->
<context:component-scan base-package="com.Fw"></context:component-scan>
<!-- 使aspect注解生效,为目标类自动生成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
context:component-scan将包com.Fw包中的所有类进行扫描,如果该类同时添加了@Component,则将该类扫描到IoC容器中,及IoC管理它的对象。
aop:aspectj-autoproty 让spring容器框架结合切面类和目标类自动生成动态代理对象。
相关概念:
- 切面:横切关注点被模块化的抽象对象
- 通知:切面完成的工作
- 目标:被通知的对象,即被横切的对象
- 代理:切面,通知,目标混合之后的对象
- 连接点:通知要插入业务代码的具体位置
- 切点:AOP通过切点定位到连接点