让你一下子看明白spring的AOP

什么是AOP？

AOP:(Aspect Oriented Progarming)面向切面编程
OOP:(Object Oriented Progarming)面向对象编程

面向切面编程： 基于OOP基础之上的编程
指的是在代码运行期间，将某段代码动态的切入(插入)到指定的位置进行运行的编程方式

我们用计算机运行计算方法的时候进行日志记录的场景进行模拟

加日志记录：

1. 直接编写在方法内部,修改维护麻烦
   日志记录：系统辅助功能
   逻辑代吗：系统核心业务逻辑
   耦合：系统核心功能和日志记录同时出现在代码中
2. 我们希望的是：
   业务逻辑：(核心功能);日志模块：在核心功能运行期间自己动态的加上
   运行的时候日志功能加上
   可以使用动态代理将日志代码动态的在目标方法执行前后进行执行

实现步骤
程序结构如下：

1. 创建Claculator的接口：

public interface  Claculator {
	public int add(int i,int j) ;
	public int sub(int i,int j) ;
	public int mul(int i,int j) ;
	public int div(int i,int j) ;

}

2. 实现Claculator接口：

package com.mzc.impl;

import com.mzc.inter.Claculator;
import com.mzc.utils.logUtils;

public class MyMathClaculator implements Claculator{

	@Override
	public int add(int i, int j) {
		int res = i +j;
		return res;
	}

	@Override
	public int sub(int i, int j) {
		int res = i-j;
		
		return res;
	}

	@Override
	public int mul(int i, int j) {
		int res = i*j;
		
		return res;
	}

	@Override
	public int div(int i, int j) {
		int res = i/j;
		return res;
	}

}

3.定义动态代理类代理计算方法，并在计算的方法前后添加日志

package com.mzc.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

import com.mzc.inter.Claculator;
import com.mzc.utils.logUtils;

/**
 * 帮助Claculator.java生成代理对象的类
 * 
 * @author dall
 *
 */
public class ClaculatorProxy {

	/**
	 * 为传入的参数对象创建一个动态代理对象
	 * @param claculator
	 * @return
	 * 
	 * Claculator claculator：被代理对象（王宝宝）
	 * 返回的是：宋喆
	 */
	public static Claculator getProxy(Claculator claculator) {
		// TODO Auto-generated method stub
		
		//InvocationHandler就是目标方法，帮助对象执行目标方法
		InvocationHandler h = new InvocationHandler(){

			/**
			 * Object proxy:这是代理对象，给jdk使用，我们不要动
			 * Method method：当前将要执行的目标对象方法
			 * Object[] args:调用的时候传入参数的值
			 */
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				// TODO Auto-generated method stub
				//利用反射执行目标方法
				//result目标方法执行后的返回值
				//System.out.println("这是动态代理！将要帮你执行方法...");
				
				Object result = null;
				try {
					logUtils.logStart(method,args);
					result = method.invoke(claculator,args);
					logUtils.logReturn(method, result);
				} catch (Exception e) {
					logUtils.logException(method, e);
					
				}finally {
					logUtils.logEnd(method);
					
				}
			
				//返回值必须返回回去，外界才能拿到值
				return result;
			}
			
		};
		Class<?>[] interfaces = claculator.getClass().getInterfaces();
		ClassLoader loader = claculator.getClass().getClassLoader();
		
		//proxy为目标对象创建代理对象
		Object proxy = Proxy.newProxyInstance(loader,interfaces,h);
		return (Claculator) proxy;
	}

}

4. 定义LogUtil类，对日志方法进行封装

package com.mzc.utils;

import java.lang.reflect.Method;
import java.util.Arrays;



public class logUtils {
	public static void logStart(Method method,Object... args) {
		System.out.println("【"+method.getName()+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
	}
	
	public static void logReturn(Method method,Object... result) {
		System.out.println("【"+method.getName()+"】方法执行完成，计算结果是："+Arrays.asList(result));
	}

	public static void logException(Method method, Exception e) {
		System.out.println("【"+method.getName()+"】方法执行异常,异常信息是"+e);
		
	}

	public static void logEnd(Method method) {
		System.out.println("【"+method.getName()+"】方法结束！");
		
	}

}

5. 定义测试类进行测试

package com.mzc.test;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

import com.mzc.impl.MyMathClaculator;
import com.mzc.inter.Claculator;
import com.mzc.proxy.ClaculatorProxy;

/**
 * 有了动态代理，日志记录可以做的非常强大，而且逻辑代码和日志文件解耦
 * @author dall
 * 
 * jdlk默认的动态代理，如果目标对象没有实现任何借口，就无法为他创建代理对象
 *
 */
class AOP_test {

	@Test
	void test() {
		Claculator claculator = new MyMathClaculator();
		
		System.out.println("======================");
		//如果是拿到了这个对象的代理对象，代理对象执行加减乘除，就可以在执行逻辑代码前后增加日志功能
		Claculator proxy = ClaculatorProxy.getProxy(claculator);
		proxy.add(2,3);
		
		proxy.sub(5,3);
	}

}

6. 运行结果：

动态代理：

1. 写起来难
2. jdk默认的动态代理，如果目标对象没有实现任何借口，就无法为他创建代理对象

Spring动态代理难，spring实现了AOP功能；底层就是动态代理

1.可以利用spring一句代码都不写的创建动态代理
2. 实现简单，没有强制要求必须实现接口