网站主机名是什么,搭建视频服务器,桐乡网站二次开发,为什么说做网站赚钱Spring源码阅读目录
第一部分——IOC篇
第一章 Spring之最熟悉的陌生人——IOC 第二章 Spring之假如让你来写IOC容器——加载资源篇 第三章 Spring之假如让你来写IOC容器——解析配置文件篇 第四章 Spring之假如让你来写IOC容器——XML配置文件篇 第五章 Spring之假如让你来写…Spring源码阅读目录
第一部分——IOC篇
第一章 Spring之最熟悉的陌生人——IOC 第二章 Spring之假如让你来写IOC容器——加载资源篇 第三章 Spring之假如让你来写IOC容器——解析配置文件篇 第四章 Spring之假如让你来写IOC容器——XML配置文件篇 第五章 Spring之假如让你来写IOC容器——BeanFactory和FactoryBean 第六章 Spring之假如让你来写IOC容器——Scope和属性填充 第七章 Spring之假如让你来写IOC容器——属性填充特别篇SpEL表达式 第八章 Spring之假如让你来写IOC容器——拓展篇 第九章 Spring之源码阅读——环境搭建篇 第十章 Spring之源码阅读——IOC篇
第二部分——AOP篇
第十一章 Spring之不太熟的熟人——AOP 第十二章 Spring之不得不了解的内容——概念篇 第十三章 Spring之假如让你来写AOP——AOP联盟篇 第十四章 Spring之假如让你来写AOP——雏形篇 第十五章 Spring之假如让你来写AOP——Joinpoint连接点篇 第十六章 Spring之假如让你来写AOP——Pointcut切点篇 第十七章 Spring之假如让你来写AOP——Advice通知上篇 第十八章 Spring之假如让你来写AOP——Advice通知下篇 第十九章 Spring之假如让你来写AOP——番外篇Spring早期设计 第二十章 Spring之假如让你来写AOP——Aspect切面篇 第二十一章 Spring之假如让你来写AOP——Weaver织入器篇 第二十二章 Spring之假如让你来写AOP——Target Object目标对象篇 第二十三章 Spring之假如让你来写AOP——融入IOC容器篇 第二十四章 Spring之源码阅读——AOP篇 文章目录 Spring源码阅读目录第一部分——IOC篇第二部分——AOP篇 前言尝试动手写IOC容器第二十二版 Target Object目标对象 总结 前言 对于Spring一直都是既熟悉又陌生说对它熟悉吧平时用用没啥问题但面试的时候被问的一脸懵逼就很尴尬都不好意思在简历上写着熟悉Spring了 所以决定花点时间研究研究Spring的源码。主要参考的书籍是《Spring源码深度解析第2版》、《Spring揭秘》、《Spring技术内幕深入解析Spring架构与设计原理第2版》 书接上回在上篇 第二十一章 Spring之假如让你来写AOP——Weaver织入器篇 中A君 已经完成了 Weaver织入器 部分整个 AOP 也进入了尾声啦。接下来看看 A君 会有什么骚操作吧
尝试动手写IOC容器 出场人物A君苦逼的开发、老大项目经理 背景老大要求A君在一周内开发个简单的 IOC容器 前情提要 A君 已经完成了 Weaver织入器 部分整个 AOP 也进入了尾声 。。。
第二十二版 Target Object目标对象 “A君 呐折腾了这么久总算快完事了。AOP 还差最后一部分内容了。你对 Target Object目标对象 理解似乎不够直接用 Object 来代表目标对象你忘了件事之前在做 IOC容器 的时候可是存在 作用域Scope 的也就是说 Target Object目标对象 可以是单例也可以是多例。再往广的说也有可能是对象池亦或是 ThreadLocal甚至于用户自定义你直接用 Object 显然满足不了这么多的需求。拿回去改改吧” “果然老大 不是好糊弄的” 虽然 A君 早有心理准备心里还是不免一阵感叹 感叹归感叹活还是少不了的。不过类似的话A君 在写 IOC容器 时都快听腻了面向接口编程懂懂懂A君 提取一个 TargetSource 接口作为所有 Target Object目标对象 的标准代码如下
/*** 切面目标对象接口*/
public interface TargetSource {/*** 获取目标对象class对象** return*/Class? getTargetClass();/*** 是否是静态对象* 什么是静态对象* 单例这种可以算静态** return*/boolean isStatic();/*** 获取目标对象** return* throws Exception*/Object getTarget() throws Exception;/*** 释放对象* 用于对象池之类的实现时才有用** param target* throws Exception*/void releaseTarget(Object target) throws Exception;
}好了接口有了。接下来就是考虑具体实现的问题了。对于单例对象没什么好说的直接定义一个 final 修饰的属性即可问题在于多例上面先易后难吧。A君 定义个 SingletonTargetSource 类。代码如下
import com.hqd.ch03.v22.aop.TargetSource;
import lombok.AllArgsConstructor;/*** 单例 targetSource*/
AllArgsConstructor
public class SingletonTargetSource implements TargetSource {private final Object target;Overridepublic Class? getTargetClass() {return this.target.getClass();}Overridepublic boolean isStatic() {return true;}Overridepublic Object getTarget() {return target;}Overridepublic void releaseTarget(Object target) throws Exception {}/*** param other* return*/Overridepublic boolean equals(Object other) {if (other instanceof SingletonTargetSource) {return ((SingletonTargetSource) other).target.equals(this);}return false;}Overridepublic int hashCode() {return target.hashCode();}
}单例弄完之后现在轮到多例了多例细说的话也可以分为很多种对象池、Scope、ThreadLocal等。经过前段时间的洗礼A君 几乎形成条件反射了一旦涉及到多个实现首先想到的就是能否定义抽象类提取公共代码。“要说到公共部分那就是 Target Object目标对象 应该都是从 IOC容器 中获取。” A君 心想。于是A君 先把这部分内容提取成一个抽象类AbstractBeanFactoryBasedTargetSource 代码如下
import com.hqd.ch03.v22.aop.TargetSource;
import com.hqd.ch03.v22.aware.BeanFactoryAware;
import com.hqd.ch03.v22.factory.BeanFactory;public abstract class AbstractBeanFactoryBasedTargetSource implements BeanFactoryAware, TargetSource {private final String targetBeanName;private BeanFactory beanFactory;private volatile Class? targetClass;public AbstractBeanFactoryBasedTargetSource(String targetBeanName) {this.targetBeanName targetBeanName;}Overridepublic Class? getTargetClass() {try {if (this.targetClass ! null) {return this.targetClass;}synchronized (this) {this.targetClass this.beanFactory.getType(targetBeanName);/*获取失败这创建对象获取*/if (this.targetClass null) {Object bean this.beanFactory.getBean(targetBeanName);if (bean ! null) {this.targetClass bean.getClass();}}}} catch (Exception e) {throw new RuntimeException(e);}return this.targetClass;}Overridepublic boolean isStatic() {return false;}public BeanFactory getBeanFactory() {return beanFactory;}Overridepublic void setBeanFactory(BeanFactory beanFactory) {if (this.targetBeanName null) {throw new IllegalStateException(targetBeanName 值为空);}this.beanFactory beanFactory;}public String getTargetBeanName() {return targetBeanName;}Overridepublic void releaseTarget(Object target) throws Exception {}//TODO 重新equals
}
AbstractBeanFactoryBasedTargetSource 只是提供了 BeanFactory多例的话还需要创建对象销毁等操作A君 在提取一个抽象类——AbstractPrototypeBasedTargetSource代码如下 import com.hqd.ch03.v17.aop.target.AbstractBeanFactoryBasedTargetSource;
import com.hqd.ch03.v17.factory.BeanFactory;public class AbstractPrototypeBasedTargetSource extends AbstractBeanFactoryBasedTargetSource {public AbstractPrototypeBasedTargetSource(String targetBeanName) {super(targetBeanName);}Overridepublic void setBeanFactory(BeanFactory beanFactory) {super.setBeanFactory(beanFactory);try {/*** 不是多例抛出异常*/if (!beanFactory.isPrototype(getTargetBeanName())) {throw new RuntimeException(bean不是多例);}} catch (Exception e) {throw new RuntimeException(e);}}/*** 创建对象** return*/protected Object newPrototypeInstance() {return this.getBeanFactory().getBean(getTargetBeanName());}protected void destroyPrototypeInstance(Object target) {//TODO 销毁对象}
}公共代码都提取完毕了多例也就没有多少代码了。只需要调用父类实现即可PrototypeTargetSource 代码如下
public class PrototypeTargetSource extends AbstractPrototypeBasedTargetSource {public PrototypeTargetSource(String targetBeanName) {super(targetBeanName);}Overridepublic Object getTarget() {return newPrototypeInstance();}Overridepublic void releaseTarget(Object target) throws Exception {destroyPrototypeInstance(target);}
}
TargetSource 实现类都准备完毕了还需要对 AdvisedSupport 进行一番改造将Object替换成 TargetSource 即可代码如下 还有一个改造点在 CglibAopProxy需要根据是否单例来创建不同的方法拦截器。如果非单例的话每次都需要获取 DynamicUnadvisedExposedInterceptor 代码如下 private static class DynamicUnadvisedExposedInterceptor implements MethodInterceptor, Serializable {private final TargetSource targetSource;public DynamicUnadvisedExposedInterceptor(TargetSource targetSource) {this.targetSource targetSource;}Overridepublic Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {Object oldProxy null;Object target this.targetSource.getTarget();try {oldProxy AopContext.setCurrentProxy(proxy);Object retVal invokeMethod(target, method, args, methodProxy);return processReturnType(proxy, target, method, retVal);} finally {AopContext.setCurrentProxy(oldProxy);if (target ! null) {this.targetSource.releaseTarget(target);}}}}接下来又到了愉快的测试环节不过在编写测试时A君 发现了一个问题按理说Target Object目标对象 应该是根据Scope来创建不同的实现类单例就创建 SingletonTargetSource多例就创建 PrototypeTargetSource。后续和 IOC容器 整合创建Bean时候应该返回代理对象那么代理对象和目标对象的Scope是一样的 Target Object目标对象 处境似乎有点尴尬了如果目标对象是单例那么 Target Object目标对象 可以是 SingletonTargetSource目标对象是多例 Target Object目标对象 也可以是 SingletonTargetSource因为代理对象和目标对象的Scope是一致的那么是 SingletonTargetSource 还是 PrototypeTargetSource 意义不大。如此说来只有一种情况才能解释这个设计那就是目标对象是多例而代理对象是单例 “算了不想了回头问下 老大。” A君 放弃了继续开始它的测试之旅其实也没得测试现在还没有和 IOC 结合只能看下是否是使用 TargetSource 即可测试代码如下 Testpublic void v17() throws Throwable {System.out.println(############# 第十七版 Target Object目标对象 #############);AspectJExpressionPointcut pointcut new AspectJExpressionPointcut(execution(* *.test(..)));Object ap new AopBean();Method method AopBean.class.getDeclaredMethod(test);AopTest aop new AopTest();Method beforeTest aop.getClass().getDeclaredMethod(beforeTest);Method afterTest aop.getClass().getDeclaredMethod(afterTest);Method afterReturnTest aop.getClass().getDeclaredMethod(afterReturnTest);ListMethodInterceptor list new ArrayList();//前置通知AspectJMethodBeforeAdvice aspectJMethodBeforeAdvice new AspectJMethodBeforeAdvice(pointcut, beforeTest, aop);MethodBeforeAdviceInterceptor methodBeforeAdviceInterceptor new MethodBeforeAdviceInterceptor(aspectJMethodBeforeAdvice);list.add(methodBeforeAdviceInterceptor);//后置通知list.add(new AspectJAfterAdvice(pointcut, afterTest, aop));//返回通知AspectJAfterReturningAdvice aspectJAfterReturningAdvice new AspectJAfterReturningAdvice(pointcut, afterReturnTest, aop);list.add(new AfterReturningAdviceInterceptor(aspectJAfterReturningAdvice));ProxyFactory proxyFactory new ProxyFactory(AopBean.class, ap, method);proxyFactory.addAdvisors(list);AopBean proxy (AopBean) proxyFactory.getProxy();proxy.test();System.out.println(proxyFactory.getTargetSource().getClass());}测试结果如下 “OK今天的任务完成了” A君 欢呼 小插曲 下班前A君 终于逮到了 老大把自己的疑问说了出来老大 回答道“其实 Spring 除了 ProxyFactory还有 ProxyFactoryBean 不仅能把代理工厂融入到 IOC还能把代理的细节都交给开发包括你提到的 TargetObject只是 Spring 默认使用 ProxyFactory屏蔽了这些东西就是 ProxyFactory 也有 TargetSourceCreator 可以配置自定义创建 TargetSource ” 总结 正所谓树欲静而风不止欲知后事如何请看下回分解(✪ω✪)
