只要你愿意走,踩过的都是路;只要你不回避与退缩,生命的掌声终会为你响起。
SpringAOP内容如下
AOP
AOP:Aspect Oriented Programming ⾯向切⾯编程。
AOP 的优点:
1.降低模块之间的耦合度。
2.使系统更容易扩展。
3.更好的代码复⽤。
4.⾮业务代码更加集中,不分散,便于统⼀管理。
5.业务代码更加简洁存粹,不参杂其他代码的影响。
AOP 是对⾯向对象编程的⼀个补充,在运⾏时,动态地将代码切⼊到类的指定⽅法、指定位置上的编程 思想就是⾯向切⾯编程。将不同⽅法的同⼀个位置抽象成⼀个切⾯对象,对该切⾯对象进⾏编程就是 AOP。
如何使⽤?
创建 Maven ⼯程,pom.xml 添加
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.11.RELEASE</version>
</dependency>
<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>
</dependencies>
创建⼀个计算器接⼝ Cal,定义4个⽅法
package com.southwind.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);
}
创建接⼝的实现类 CalImpl。
package com.southwind.utils.impl;
import com.southwind.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;
}
上述代码中,⽇志信息和业务逻辑的耦合性很⾼,不利于系统的维护,使⽤ AOP 可以进⾏优化,如何
来实现 AOP?使⽤动态代理的⽅式来实现。
给业务代码找⼀个代理,打印⽇志信息的⼯作交个代理来做,这样的话业务代码就只需要关注⾃身的业
务即可。
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;
}
}
以上是通过动态代理实现 AOP 的过程,⽐较复杂,不好理解,Spring 框架对 AOP 进⾏了封装,使⽤ Spring 框架可以⽤⾯向对象的思想来实现 AOP。
Spring 框架中不需要创建 InvocationHandler,只需要创建⼀个切⾯对象,将所有的⾮业务代码在切⾯ 对象中完成即可,Spring 框架底层会⾃动根据切⾯类以及⽬标类⽣成⼀个代理对象。
LoggerAspect
package com.southwind.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
@Aspect
@Component
public class LoggerAspect {
@Before(value = "execution(public int com.southwind.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.southwind.utils.impl.CalImpl.*
(..))")
public void after(JoinPoint joinPoint){
//获取⽅法名
String name = joinPoint.getSignature().getName();
System.out.println(name+"⽅法执⾏完毕");
}
@AfterReturning(value = "execution(public int
com.southwind.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.southwind.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.southwind.utils.impl;
import com.southwind.utils.Cal;
import org.springframework.stereotype.Component;
@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;
}
}
<?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/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
">
<!-- ⾃动扫描 -->
<context:component-scan base-package="com.southwind">
</context:component-scan>
<!-- 是Aspect注解⽣效,为⽬标类⾃动⽣成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
context:component-scan 将 com.southwind 包中的所有类进⾏扫描,如果该类同时添加了 @Component ,则将该类扫描到 IoC 容器中,即 IoC 管理它的对象。
aop:aspectj-autoproxy 让 Spring 框架结合切⾯类和⽬标类⾃动⽣成动态代理对象。
切⾯:横切关注点被模块化的抽象对象。
通知:切⾯对象完成的⼯作。
⽬标:被通知的对象,即被横切的对象。
代理:切⾯、通知、⽬标混合之后的对象。
连接点:通知要插⼊业务代码的具体位置。
切点:AOP 通过切点定位到连接点。