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

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

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

总结一下要形成的习惯:

  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的核心概念了。总结一下:

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


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

生成代理对象是经?;岜晃实降囊桓鑫侍猓篠pring提供了两种方式来生成代理对象,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就是动态代理,因为代理的类是在运行时才生成的。

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


欢迎Java工程师朋友们加入Java开发技术进阶互助:416843702

群内提供免费的Java架构学习资料(里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码,

MyBatis,Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料)

合理利用自己每一分每一秒的时间来学习提升自己,不要再用"没有时间“来掩饰自己思想上的懒惰!趁年轻,使劲拼,给未来的自己一个交代!