Spring学习笔记 第八章 AOP

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通过切点定位到连接点