Spring AOP
Spring是一个轻型容器，Spring整个系列的最最核心的概念当属IoC、AOP(Aspect Oriented Programming，即面向切面编程)。Spring AOP的底层实现是基于动态代理的实现原理，AOP的拦截功能是由java中的动态代理来实现的。
AOP的源码中用到了两种动态代理来实现拦截切入功能：jdk动态代理和cglib动态代理。jdk动态代理是由java内部的反射机制来实现的，cglib动态代理底层则是借助asm来实现的。总的来说，反射机制在生成类的过程中比较高效，而asm在生成类之后的相关执行过程中比较高效（可以通过将asm生成的类进行缓存，这样解决asm生成类过程低效问题）
我们需要先理即代理模式设计模式，代理又分为静态代理，动态代理，而动态代理实现又分为jdk动态代理、cglib动态代理，接下来会从以上方面理解，并通过一个请求日志监控来理解spring aop。
代理模式
代理模式：给某一个对象提供一个代理，并由代理对象来控制对真实对象的访问。代理模式是一种结构型设计模式。
代理模式角色分为 3 种：
Subject（抽象主题角色）：定义代理类和真实主题的公共对外方法，也是代理类代理真实主题的方法；
RealSubject（真实主题角色）：真正实现业务逻辑的类；
Proxy（代理主题角色）：用来代理和封装真实主题；
代理模式的结构比较简单，其核心是代理类，为了让客户端能够一致性地对待真实对象和代理对象，在代理模式中引入了抽象层
静态代理
通过一个简单例子来理解静态代理以及代理模式，再看看动态代理比静态代理好在哪里
定义一个抽象主题类（UserService-subject）、一个真实主题类(UserServiceImpl-real subject)
public interface UserService {
public void select();
public void update();
}
public class UserServiceImpl implements UserService {
@Override
public void select() {
System.out.println("查询 selectById");
}
@Override
public void update() {
System.out.println("更新 update");
}
}定义一个代理类（UserServiceProxy-proxy）
public class UserServiceProxy implements UserService {
// 被代理的对象
private UserService target;
public UserServiceProxy(UserService target) {
this.target = target;
}
@Override
public void select() {
before();
// 这里才实际调用真实主题角色的方法
target.select();
after();
}
@Override
public void update() {
before();
// 这里才实际调用真实主题角色的方法
target.update();
after();
}
private void before() { // 在执行方法之前执行
System.out.println("-----------start-----------");
}
private void after() { // 在执行方法之后执行
System.out.println("-----------end-----------");
}
}上面就已经实现一个简单的静态代理模式，客户端
public class StaticProxyMain {
public static void main(String[] args) {
UserService userServiceImpl = new UserServiceImpl();
UserService proxy = new UserServiceProxy(userServiceImpl);
proxy.select();
proxy.update();
}
}
执行结果：
-----------start-----------
查询 selectById
-----------end-----------
-----------start-----------
更新 update
-----------end-----------由例子可以看出，静态代理模式需要为每个业务类实现代理类，过于冗余，动态代理能够很好解决该问题
动态代理-Jdk动态代理
同样，我们通过一个简单的例子来理解Jdk动态模式
如上定义一个抽象主题类（UserService-subject）、一个真实主题类(UserServiceImpl-real subject)，代码不重复了
定义动态代理类（LogHander-proxy）,需要实现jdk动态代理类InvocationHandler
public class LogHandler implements InvocationHandler {
Object target;
public LogHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
//调用 target 的 method 方法
Object result = method.invoke(target, args);
after();
//返回方法的执行结果
return result;
}
private void before() {
System.out.println("---------------start--------------");
}
private void after() {
System.out.println("----------------end----------------");
}
}客户端
public class JdkProxyMain {
public static void main(String[] args) throws IllegalAccessException, InstantiationException {
// 设置变量可以保存动态代理类，默认名称以 $Proxy0 格式命名
// System.getProperties().setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
// 1. 创建被代理的对象，UserService接口的实现类
UserServiceImpl userServiceImpl = new UserServiceImpl();
// 2. 获取对应的 ClassLoader
ClassLoader classLoader = userServiceImpl.getClass().getClassLoader();
// 3. 获取所有接口的Class，这里的UserServiceImpl只实现了一个接口UserService，
Class[] interfaces = userServiceImpl.getClass().getInterfaces();
// 4. 创建一个将传给代理类的调用请求处理器，处理所有的代理对象上的方法调用
// 这里创建的是一个自定义的日志处理器，须传入实际的执行对象 userServiceImpl
InvocationHandler logHandler = new LogHandler(userServiceImpl);
/*
5.根据上面提供的信息，创建代理对象 在这个过程中，
a.JDK会通过根据传入的参数信息动态地在内存中创建和.class 文件等同的字节码
b.然后根据相应的字节码转换成对应的class，
c.然后调用newInstance()创建代理实例
*/
UserService proxy = (UserService) Proxy.newProxyInstance(classLoader, interfaces, logHandler);
// 调用代理的方法
proxy.select();
proxy.update();
// 保存JDK动态代理生成的代理类，类名保存为 UserServiceProxy
// ProxyUtils.generateClassFile(userServiceImpl.getClass(), "UserServiceProxy");
}
}InvocationHandler 和 Proxy 的主要方法介绍如下：
java.lang.reflect.InvocationHandler
Object invoke(Object proxy, Method method, Object[] args) 定义了代理对象调用方法时希望执行的动作，用于集中处理在动态代理类对象上的方法调用
java.lang.reflect.Proxy
static InvocationHandler getInvocationHandler(Object proxy) 用于获取指定代理对象所关联的调用处理器
static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) 返回指定接口的代理类
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 构造实现指定接口的代理类的一个新实例，所有方法会调用给定处理器对象的 invoke 方法
static boolean isProxyClass(Class<?> cl) 返回 cl 是否为一个代理类
生成的代理类是怎么样的尼
使用下面类查看生成的代理类情况
public class ProxyUtils {
/**
* 将根据类信息动态生成的二进制字节码保存到硬盘中，默认的是clazz目录下
* params: clazz 需要生成动态代理类的类
* proxyName: 为动态生成的代理类的名称
*/
public static void generateClassFile(Class clazz, String proxyName) {
// 根据类信息和提供的代理类名称，生成字节码
byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces());
String paths = clazz.getResource(".").getPath();
System.out.println(paths);
FileOutputStream out = null;
try {
//保留到硬盘中
out = new FileOutputStream(paths + proxyName + ".class");
out.write(classFile);
out.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
可看到生成的代理类
public final class UserServiceProxy extends Proxy implements UserService {
private static Method m1;
private static Method m2;
private static Method m4;
private static Method m0;
private static Method m3;
public UserServiceProxy(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void select() throws {
try {
super.h.invoke(this, m4, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void update() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m4 = Class.forName("dynamicsproxy.jdk.UserService").getMethod("select");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
m3 = Class.forName("dynamicsproxy.jdk.UserService").getMethod("update");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}从 UserServiceProxy 的代码中我们可以发现：
- UserServiceProxy 继承了 Proxy 类，并且实现了被代理的所有接口，以及equals、hashCode、toString等方法
- 由于 UserServiceProxy 继承了 Proxy 类，所以每个代理类都会关联一个 InvocationHandler 方法调用处理器
- 类和所有方法都被
public final修饰，所以代理类只可被使用，不可以再被继承 - 每个方法都有一个 Method 对象来描述，Method 对象在static静态代码块中创建，以
m + 数字的格式命名 - 调用方法的时候通过
super.h.invoke(this, m1, (Object[])null);调用，其中的super.h.invoke实际上是在创建代理的时候传递给Proxy.newProxyInstance的 LogHandler 对象，它继承 InvocationHandler 类，负责实际的调用处理逻辑
而 LogHandler 的 invoke 方法接收到 method、args 等参数后，进行一些处理，然后通过反射让被代理的对象 target 执行方法
简单理解：jdk动态代理就是将通过反射（能够通过类获取其属性以及方法）给真实抽象类生成一个代理类
动态代理-cglib动态代理
同样通过简单的例子理解
定义抽象类（UserDao）
public class UserDao {
public void select() {
System.out.println("UserDao 查询 selectById");
}
public void update() {
System.out.println("UserDao 更新 update");
}
}定义动态代理类，实现MethodInterceptor
public class LogInterceptor implements MethodInterceptor {
/**
* @param object 表示要进行增强的对象
* @param method 表示拦截的方法
* @param objects 数组表示参数列表，基本数据类型需要传入其包装类型，如int-->Integer、long-Long、double-->Double
* @param methodProxy 表示对方法的代理，invokeSuper方法表示对被代理对象方法的调用
* @return 执行结果
* @throws Throwable
*/
@Override
public Object intercept(Object object, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before();
// 注意这里是调用 invokeSuper 而不是 invoke，否则死循环，methodProxy.invokesuper执行的是原始类的方法，method.invoke执行的是子类的方法
Object result = methodProxy.invokeSuper(object, objects);
after();
return result;
}
private void before() {
System.out.println("---------------start----------------");
}
private void after() {
System.out.println("---------------end------------------");
}
}客户端
public class CglibTest {
public static void main(String[] args) {
LogInterceptor daoProxy = new LogInterceptor();
Enhancer enhancer = new Enhancer();
// 设置超类，cglib是通过继承来实现的
enhancer.setSuperclass(UserDao.class);
enhancer.setCallback(daoProxy);
// 创建代理类
UserDao dao = (UserDao)enhancer.create();
dao.update();
dao.select();
}
}CGLIB 创建动态代理类的模式是：
- 查找目标类上的所有非final 的public类型的方法定义；
- 将这些方法的定义转换成字节码；
- 将组成的字节码转换成相应的代理的class对象；
- 实现 MethodInterceptor接口，用来处理对代理类上所有方法的请求
简单来说：CGLIB是通过继承超类的，实现动态代理
JDK动态代理与CGLIB动态代理对比
JDK动态代理：基于Java反射机制实现，必须要实现了接口的业务类才能用这种办法生成代理对象。
cglib动态代理：基于ASM机制实现，通过生成业务类的子类作为代理类。
JDK Proxy 的优势：
- 最小化依赖关系，减少依赖意味着简化开发和维护，JDK 本身的支持，可能比 cglib 更加可靠。
- 平滑进行 JDK 版本升级，而字节码类库通常需要进行更新以保证在新版 Java 上能够使用。
- 代码实现简单。
基于类似 cglib 框架的优势：
- 无需实现接口，达到代理类无侵入
- 只操作我们关心的类，而不必为其他相关类增加工作量。
- 高性能
spring实现请求日志打印（例子）
/**
* Author: hezishan
* Date: 2018/9/4.
* Description: 接口日志配置
**/
@Aspect
@Component
public class WebLogAspect {
private static final Logger LOG = LoggerFactory.getLogger(WebLogAspect.class);
@Pointcut("execution(public * com.tnaot.recommend.core.controller.*.*(..))")//两个..代表所有子目录，最后括号里的两个..代表所有参数
public void logPointCut() {
}
@Before("logPointCut()")
public void doBefore(JoinPoint joinPoint) throws Throwable {
}
@AfterReturning(returning = "ret", pointcut = "logPointCut()")// returning的值和doAfterReturning的参数名一致
public void doAfterReturning(Object ret) throws Throwable {
}
@Around("logPointCut()")
public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
long startTime = System.currentTimeMillis();
// ob 为方法的返回值
Object ob = pjp.proceed();
LOG.info("CLASS_METHOD :{}.{} , 接口耗时 : {},参数 : {} ,接口返回值 : {} ", pjp.getSignature().getDeclaringTypeName(),
pjp.getSignature().getName(), (System.currentTimeMillis() - startTime), Arrays.toString(pjp.getArgs()), ob);
return ob;
}
}设置pointcut面向所有controller层访问，使用spring aop进行请求日志处理
扫一扫
810
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
