简介
AOP:Aspect Oriented Programming 面向切面编程
优点:
- 降低模块之间的耦合度
- 使系统更加容易拓展
- 更好的代码复用
- 非业务代码更加集中,便于统一管理
- 业务代码更加简洁纯粹
AOP是对面向队形编程的一个补充,在运行时,动态的将代码切入到累的制定方法,指定位置上的编程思想就是面向切面编程,将不同方法的同一位置抽象成一个切面对象,对该切面对象进行编程就是AOP。
使用示例
- 创建maven工程,pom.xml添加依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.25.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>4.3.25.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>4.3.25.RELEASE</version>
</dependency>
- 创建一个计算器接口Cal,定义4个方法。
原始方式
public interface Cal {
int add(int num1, int num2);
int sub(int num1, int num2);
int mul(int num1, int num2);
int div(int num1, int num2);
}
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;
}
}
上述代码中,日志信息和业务逻辑的耦合性很高,不利于系统的维护,使用AOP进行优化,
如何使用AOP?
使用动态代理来实现
给业务代码找一个代理,打印日志信息的工作交个代理来做,这样的话业务代码就只需要关注自身的业
务即可。
创建动态代理类,实现InvocationHandler接口
public class MyInvacationHandler implements InvocationHandler {
//接收委托对象
private Object obj;
//返回代理对象
public Object bind(Object obj){
this.obj=obj;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.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.obj,args);
System.out.println(method.getName()+"结果是"+result);
return result;
}
}
业务方法:
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;
}
}
main 方法:
public static void main(String[] args) {
Cal cal=new CalImpl();
MyInvacationHandler invacationHandler=new MyInvacationHandler();
Cal cal1=(Cal)invacationHandler.bind(cal);
cal1.add(1,1);
cal1.sub(2,1);
cal1.mul(2,1);
cal1.div(4,2);
}
以上是通过动态代理实现aop的过程,比较复杂,不好理解,spring 框架对Aop进行了封装,使用spring 框架可以用面向对象的思想来实现aop
spring 框架中不需要创建InvocationHandler,只需要创建一个切面对象,将所欲偶的非业务代码在切面对象中完成即可,Spring 框架底层会自动根据切面类以及目标类生成一个代理对象。
创建LoggerAspect切面类
@Aspect
@Component
public class LoggerAspect {
@Before("execution (public int com.youzm.impl.CalImpl.*(..))")
public void before(JoinPoint joinPoint){
String name=joinPoint.getSignature().getName();
String args=Arrays.toString(joinPoint.getArgs());
System.out.println(name+"方法的参数是:"+ args);
}
@After("execution (public int com.youzm.impl.CalImpl.*(..))")
public void after(JoinPoint joinPoint){
String name=joinPoint.getSignature().getName();
System.out.println(name+"执行完毕");
}
@AfterReturning(value = "execution (public int com.youzm.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.youzm.impl.CalImpl.*(..))",throwing = "ex")
public void afterThrowing(JoinPoint joinPoint,Exception ex){
String name=joinPoint.getSignature().getName();
System.out.println(name+"方法抛出异常"+ex);
}
}
类定义添加的注解:
- ```@Aspect````:表示该类是切面类
- ```@Component``:将该类的对象注入到ioc容器
具体方法出添加的注解:
@Before
:表示⽅法执⾏的具体位置和时机。
CalImpl也需要添加@Component
,交给ioc容器管理
@Component
public class CalImpl implements Cal
Spring.xml中进行配置
<?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.youzm"></context:component-scan>
<!--使Aspect注解生效,为目标类自动生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
context:component-scan
将com.youzm
包中的所有类进行扫描,如果该类添加@Component
,则将该类扫描的ioc容器中。
aop:aspectj-autoproxy
让spring框架结合切面类和目标类自动生成动态代理对象。
使用:
public static void main(String[] args) {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring-aop.xml");
Cal cal=(Cal)applicationContext.getBean("calImpl");
cal.add(1,5);
}
- 切面:横切关注点被模块化的抽象对象
- 通知:切面对象完成的工作
- 目标:被通知的对象,被横切的对象
- 代理:切面,通知,目标混合之后的对象
- 连接点:同志要插入业务代码的集体位置
- 切点:aop通过切点定位到连接点
参考视频:B站楠哥–spring