Spring AOP源码解析——专治你不会看源码的坏毛病!

栏目: Java · 发布时间: 5年前

内容简介:还没关注?快动动手指!

还没关注?

快动动手指!

聊技术、论职场!

为IT人打造一个“有温度”的 狸猫技术窝

昨天有个大牛说我啰嗦,眼光比较细碎,看不到重点。太他爷爷的有道理了!要说看人品,还是女孩子强一些。

原来记得看到一个男孩子的抱怨,说怎么两人刚刚开始在一起,女孩子在心里就已经和他过完了一辈子。哥哥们,不想这么远行吗?看看何洁,看看带着俩娃跳楼的妈妈。

所以现在的女孩子是很明白的,有些男孩子个子不高,其貌不扬,但是一看那人品气质就知道能找个不错的女盆友。不过要说看人的技术能力,男孩子确实更胜一筹,咱得努力了。

总结一下要形成的习惯:

  1. 有空时隔一段时间要做几道算法题,C语言和 JAVA 都可以,主要是训练思维。

  2. 定期阅读spring的源码。因为spring是框架,重设计,能够培养大局观

  3. 阅读底层的书籍,如 linux 方面,虚拟机方面,这是内功。越高级的语言只是招式。

  4. 不要忘记做了一半的东西,如搜索引擎方面,redis方面,可以过一段时间再做,因为到时候自己的境界有提升,深入程度也会有所增加。

下面是今天的正题。我也很菜,看源码也很费力,所以都会从最容易的入手。先了解其原理,再去看源码。

看源码看熟了,以后再遇到问题,就可以通过源码去了解原理了。

spring的AOP,原理懂了,代码相当简单。这也是为什么我记得我还是个菜鸟的时候,面试人家经常问我这个。

先有个大局观,画张整体的spring结构图。以下是备受吐槽的手绘时间:

Spring AOP源码解析——专治你不会看源码的坏毛病!

如果你觉得我左手字写的实在是不能再难看了的话,我有空可以展示一下右手字

天生做不好的两件事:写不好字,梳不整齐头发。自我感觉最近梳头技术有所改观。

AOP面向切面编程是面向对象的补充。它利用一种横切技术,将一些公共行为封装成叫做“方面”的可重用模块,解耦,增加可维护性。

AOP将系统分为核心关注点和横切关注点两部分。核心关注点就是主业务流程,横切关注点就是上面提到的“方面”。

那么看AOP的源码就是要看横切关注点是怎样和核心关注点整合来发挥作用的。

主业务流程归根到底是一个java方法,而且是对象的方法。在AOP中被称为被通知或被代理对象POJO。

AOP的作用就是将核心关注点和横切关注点组合起来,术语叫做“增强”。最后实际用的是增强后的代理对象。

对核心关注点进行增强就涉及到在哪些地方增强的问题。如方法调用或者异常抛出时做增强这些时机叫做连接点Joinpoint。一个通知将被引发的连接点集合叫做切入点,理解时就可以想正则表达式,通配符来指定多个,而不是单单一个连接点。

在连接点都做了哪些增强呢?增强的内容AOP术语叫“通知”Advice。

Spring里定义了四种Advice:BeforeAdvice,AfterAdvice,ThrowAdvice,DynamicIntroducationAdvice。

许多AOP框架包括spring都是以拦截器作为通知模型。维护一个围绕连接点的拦截器链。其中DynamicIntroducationAdvice是可以引入方法或者字段到核心关注点。

这里有个Introduction,AOP术语叫引入。将增强后的AOP代理组装到系统叫做织入。

上面就是AOP的核心概念了。总结一下:

方面(Aspect)
连接点(Joinpoint)
通知(Advice)
切入点(Pointcut)
引入(Introduction)
目标对象(Target Object)
AOP代理(AOP Proxy)
织入(Weaving)

AOP要做的事情就是:生成代理对象,然后织入。

生成代理对象是经常会被问到的一个问题:Spring提供了两种方式来生成代理对象,JDKProxy和Cglib。

具体使用哪种方式由AopProxyFactory根据AdvisedSupport对象的配置来决定。

默认的策略是如果目标类是接口,则使用JDK动态代理技术,否则使用Cglib来生成代理。

Cglib是基于字节码技术的,使用的是ASM。asm是一个java字节码操纵框架,它能被用来动态生成类或者增强既有类的功能。

ASM可以直接产生二进制class文件,也可以在类被加载入JVM之前动态改变类行为。

下面重点来看看JDK动态代理技术。这是我还是个很菜很菜的菜鸟时为数不多能看懂的源码。因为之前看过Java设计模式,写过类似的例子,所以会比较顺畅。今天先讲这一部分。

下面是调用测试类:

package dynamic.proxy; 

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

/**
* 实现自己的InvocationHandler
* @author zyb
* @since 2012-8-9
*
*/

public class MyInvocationHandler implements InvocationHandler {

// 目标对象
private Object target;

/**
* 构造方法
* @param target 目标对象
*/

public MyInvocationHandler(Object target) {
super();
this.target = target;
}


/**
* 执行目标对象的方法
*/

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

// 在目标对象的方法执行之前简单的打印一下
System.out.println("------------------before------------------");

// 执行目标对象的方法
Object result = method.invoke(target, args);

// 在目标对象的方法执行之后简单的打印一下
System.out.println("-------------------after------------------");

return result;
}

/**
* 获取目标对象的代理对象
* @return 代理对象
*/

public Object getProxy() {
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
target.getClass().getInterfaces(), this);
}
}

package dynamic.proxy;

/**
* 目标对象实现的接口,用JDK来生成代理对象一定要实现一个接口
* @author zyb
* @since 2012-8-9
*
*/

public interface UserService {

/**
* 目标方法
*/

public abstract void add();

}

package dynamic.proxy;

/**
* 目标对象
* @author zyb
* @since 2012-8-9
*
*/

public class UserServiceImpl implements UserService {

/* (non-Javadoc)
* @see dynamic.proxy.UserService#add()
*/

public void add() {
System.out.println("--------------------add---------------");
}
}

package dynamic.proxy;

import org.junit.Test;

/**
* 动态代理测试类
* @author zyb
* @since 2012-8-9
*
*/

public class ProxyTest {

@Test
public void testProxy() throws Throwable {
// 实例化目标对象
UserService userService = new UserServiceImpl();

// 实例化InvocationHandler
MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);

// 根据目标对象生成代理对象
UserService proxy = (UserService) invocationHandler.getProxy();

// 调用代理对象的方法
proxy.add();

}
}

执行结果如下: 
------------------before--------------- 
--------------------add--------------- 
-------------------after-----------------

很简单,核心就是 invocationHandler.getProxy();这个方法调用的Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),target.getClass().getInterfaces(), this);  怎么生成对象的。

/**
* Returns an instance of a proxy class for the specified interfaces
* that dispatches method invocations to the specified invocation
* handler.
*
*

{@code Proxy.newProxyInstance} throws
* {@code IllegalArgumentException} for the same reasons that
* {@code Proxy.getProxyClass} does.
*
* @param loader the class loader to define the proxy class
* @param interfaces the list of interfaces for the proxy class
* to implement
* @param h the invocation handler to dispatch method invocations to
* @return a proxy instance with the specified invocation handler of a
* proxy class that is defined by the specified class loader
* and that implements the specified interfaces
* @throws IllegalArgumentException if any of the restrictions on the
* parameters that may be passed to {@code getProxyClass}
* are violated
* @throws SecurityException if a security manager, s, is present
* and any of the following conditions is met:
*


  • *

  • the given {@code loader} is {@code null} and
    * the caller's class loader is not {@code null} and the
    * invocation of {@link SecurityManager#checkPermission
    * s.checkPermission} with
    * {@code RuntimePermission("getClassLoader")} permission
    * denies access;


  • *

  • for each proxy interface, {@code intf},
    * the caller's class loader is not the same as or an
    * ancestor of the class loader for {@code intf} and
    * invocation of {@link SecurityManager#checkPackageAccess
    * s.checkPackageAccess()} denies access to {@code intf};


  • *

  • any of the given proxy interfaces is non-public and the
    * caller class is not in the same {@linkplain Package runtime package}
    * as the non-public interface and the invocation of
    * {@link SecurityManager#checkPermission s.checkPermission} with
    * {@code ReflectPermission("newProxyInPackage.{package name}")}
    * permission denies access.


  • *


* @throws NullPointerException if the {@code interfaces} array
* argument or any of its elements are {@code null}, or
* if the invocation handler, {@code h}, is
* {@code null}
*/

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class[] interfaces,
InvocationHandler h)

throws IllegalArgumentException
{
Objects.requireNonNull(h);

final Class[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}

/*
* Look up or generate the designated proxy class.
*/

Class cl = getProxyClass0(loader, intfs);

/*
* Invoke its constructor with the designated invocation handler.
*/

try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}

final Constructor cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction () {
public Void run() {
cons.setAccessible( true);
return null;
}
});
}
return cons.newInstance( new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}

这个代码是JDK1.8中的,里面用到了1.8的一些语法,如果不太了解,建议先看看 这本书。

代码看着不少,实际上都在进行一些安全校验,包装之类的,真正有用的就两句: 

Class cl = getProxyClass0(loader, intfs);这句话查找或者生成代理类。跟进去:

/**
* Generate a proxy class. Must call the checkProxyAccess method
* to perform permission checks before calling this.
*/

private static Class getProxyClass0(ClassLoader loader,
Class... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}

// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
return proxyClassCache.get(loader, interfaces);
}

对,就是从缓存里把接口拿将出来。然后用return cons.newInstance(new Object[]{h}) 这一句将接口用invocationHandler进行包装。

具体源码可以跟进去看,不详述。想必看到这里,JDK动态代理的原理都已经很明白了。

这里要说一点理论性的东西:

  • AOP解决的问题往往可以用代理模式来解决。Java开发中常说动态代理和静态代理,而AOP就是动态代理,因为代理的类是在运行时才生成的。

  • 而一般说的代理模式写成的代码是编译期就已经生成的,叫静态代理。

作者: 编程一生

来源:

https://www.cnblogs.com/xiexj/p/7366890.html

本文版权归作者所有

END

长按下图二维码,即刻关注【 狸猫技术窝

阿里、京东、美团、字节跳动

顶尖技术专家 坐镇

为IT人打造一个 “有温度” 的技术窝!

Spring AOP源码解析——专治你不会看源码的坏毛病!


以上所述就是小编给大家介绍的《Spring AOP源码解析——专治你不会看源码的坏毛病!》,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对 码农网 的支持!

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

Web容量规划的艺术

Web容量规划的艺术

阿尔斯帕瓦 / 叶飞、罗江华 / 机械工业出版社 / 2010-1 / 29.00元

《Web容量规划的艺术》由John Allspaw(F订ickr的工程运营经理)撰写,结合了他个人在F1ickr成长过程中的许多经历和很多其他产业中同行的洞察力。在衡量增长、预测趋势、成本效益等方面,他们的经验都会给你一些可靠并有效的指导。 网站的成功是以使用和增长来衡量的,而且网站类公司的成败(生死)是依赖于他们是否有能力来衡量决定他们的基础结构,从而适应不断增长的需求。作者通过自身实践给......一起来看看 《Web容量规划的艺术》 这本书的介绍吧!

JSON 在线解析
JSON 在线解析

在线 JSON 格式化工具

XML、JSON 在线转换
XML、JSON 在线转换

在线XML、JSON转换工具

HSV CMYK 转换工具
HSV CMYK 转换工具

HSV CMYK互换工具