什么是AOP?
AOP:(Aspect Oriented Progarming)面向切面编程
OOP:(Object Oriented Progarming)面向对象编程
面向切面编程: 基于OOP基础之上的编程
指的是在代码运行期间,将某段代码动态的切入(插入)到指定的位置进行运行的编程方式
我们用计算机运行计算方法的时候进行日志记录的场景进行模拟
加日志记录:
- 直接编写在方法内部,修改维护麻烦
日志记录:系统辅助功能
逻辑代吗:系统核心业务逻辑
耦合:系统核心功能和日志记录同时出现在代码中 - 我们希望的是:
业务逻辑:(核心功能);日志模块:在核心功能运行期间自己动态的加上
运行的时候日志功能加上
可以使用动态代理将日志代码动态的在目标方法执行前后进行执行
实现步骤
程序结构如下:
- 创建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) ;
}
- 实现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;
}
}
- 定义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()+"】方法结束!");
}
}
- 定义测试类进行测试
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. 运行结果:
动态代理:
- 写起来难
- jdk默认的动态代理,如果目标对象没有实现任何借口,就无法为他创建代理对象
Spring动态代理难,spring实现了AOP功能;底层就是动态代理
1.可以利用spring一句代码都不写的创建动态代理
2. 实现简单,没有强制要求必须实现接口