写点什么

30 个类手写 Spring 核心原理之 Ioc 顶层架构设计(2)

  • 2022 年 5 月 04 日
  • 本文字数:4409 字

    阅读完需:约 14 分钟

[](()3.2 GPBeanWrapper

BeanWrapper 主要用于封装创建后的对象实例,代理对象(Proxy Object)或者原生对象(Original Object)都由 BeanWrapper 来保存。


package com.tom.spring.formework.beans;


public class GPBeanWrapper {


private Object wrappedInstance;


private Class<?> wrappedClass;


public GPBeanWrapper(Object wrappedInstance){


this.wrappedInstance = wrappedInstance;


}


public Object getWrappedInstance(){


return this.wrappedInstance;


}


//返回代理以后的 Class


//可能会是这个 $Proxy0


public Class<?> getWrappedClass(){


return this.wrappedInstance.getClass();


}


}


[](()4 context(IoC 容器)模块



[](()4.1 GPAbstractApplicationContext

IoC 容器实现类的顶层抽象类,实现 IoC 容器相关的公共逻辑。为了尽可能地简化,在这个 Mini 版本中,暂时只设计了一个 refresh()方法。


package com.tom.spring.formework.context.support;


/**


  • IoC 容器实现的顶层设计


*/


public abstract class GPAbstractApplicationContext {


//受保护,只提供给子类重写


public void refresh() throws Exception {}


}

[](()4.2 GPDefaultListableBeanFactory

DefaultListableBeanFactory 是众多 IoC 容器子类的典型代表。在 Mini 版本中我只做了一个简单的设计,就是定义顶层的 IoC 缓存,也就是一个 Map,属性名字也和原生 Spring 保持一致,定义为 beanDefinitionMap,以方便大家对比理解。


package com.tom.spring.formework.beans.support;


import com.tom.spring.formework.beans.config.GPBeanDefinition;


import com.tom.spring.formework.context.support.GPAbstractApplicationContext;


import java.util.Map;


import java.util.concurrent.ConcurrentHashMap;


public class GPDefaultListableBeanFactory extends GPAbstractApplicationContext{


//存储注册信息的 BeanDefinition


protected final Map<String, GPBeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, GPBeanDefinition>();


}

[](()4.3 GPApplicationContext

ApplicationContext 是直接接触用户的入口,主要实现 DefaultListableBeanFactory 的 refresh()方法和 BeanFactory 的 getBean()方法,完成 IoC、DI、AOP 的衔接。


package com.tom.spring.formework.context;


import com.tom.spring.formework.annotation.GPAutowired;


import com.tom.spring.formework.annotation.GPController;


import com.tom.spring.formework.annotation.GPService;


import com.tom.spring.formework.beans.GPBeanWrapper;


import com.tom.spring.formework.beans.config.GPBeanPostProcessor;


import com.tom.spring.formework.core.GPBeanFactory;


import com.tom.spring.formework.beans.config.GPBeanDefinition;


import com.tom.spring.formework.beans.support.GPBeanDefinitionReader;


import com.tom.spring.formework.beans.support.GPDefaultListableBeanFactory;


import java.lang.reflect.Field;


import java.util.List;


import java.util.Map;


import java.util.Properties;


import java.util.concurrent.ConcurrentHashMap;


/**


  • 按之前源码分析的套路,IoC、DI、MVC、AOP


*/


public class GPApplicationContext extends GPDefaultListableBeanFactory implements GPBeanFactory {


private String [] configLoactions;


private GPBeanDefinitionReader reader;


//单例的 IoC 容器缓存


private Map<String,Object> factoryBeanObjectCache = new ConcurrentHashMap<String, Object>();


//通用的 IoC 容器


private Map<String,GPBeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<String, GPBeanWrapper>();


public GPApplicationContext(String... configLoactions){


this.configLoactions = configLoactions;


try {


refresh();


} catch (Exception e) {


e.printStackTrace();


}


}


@Override


public void refresh() throws Exception{


//1. 定位,定位配置文件


reader = new GPBeanDefinitionReader(this.configLoactions);


//2. 加载配置文件,扫描相关的类,把它们封装成 BeanDefinition


List<GPBeanDefinition> beanDefinitions = reader.loadBeanDefinitions();


//3. 注册,把配置信息放到容器里面(伪 IoC 容器)


doRegisterBeanDefinition(beanDefinitions);


//4. 把不是延时加载的类提前初始化


doAutowrited();


}


//只处理非延时加载的情况


private void doAutowrited() {


for (Map.Entry<String, GPBeanDefinition> beanDefinitionEntry : super.beanDefinitionMap.entrySet()) {


String beanName = beanDefinitionEntry.getKey();


if(!beanDefinitionEntry.getValue().isLazyInit()) {


try {


getBean(beanName);


} catch (Exception e) {


e.printStackTrace();


}


}


}


}


private void doRegisterBeanDefinition(List<GPBeanDefinition> beanDefinitions) throws Exception {


for (GPBeanDefinition beanDefinition: beanDefinitions) {


if(super.beanDefinitionMap.containsKey(beanDefinition.getFactoryBeanName())){


throw new Exception("The “" + beanDefinition.getFactoryBeanName() + "” is exists!!");


}


super.beanDefinitionMap.put(beanDefinition.getFactoryBeanName(),beanDefinition);


}


//到这里为止,容器初始化完毕


}


public Object getBean(Class<?> beanClass) throws Exception {


return getBean(beanClass.getName());


}


//依赖注入,从这里开始,读取 BeanDefinition 中的信息


//然后通过反射机制创建一个实例并返回


//Spring 做法是,不会把最原始的对象放出去,会用一个 BeanWrapper 来进行一次包装


//装饰器模式:


//1. 保留原来的 OOP 关系


//2. 需要对它进行扩展、增强(为了以后的 AOP 打基础)


public Object getBean(String beanName) throws Exception {


return null;


}


public String[] getBeanDefinitionNames() {


return this.beanDefinitionMap.keySet().toArray(new String[this.beanDefinitionMap. size()]);


}


public int getBeanDefinitionCount(){


return this.beanDefinitionMap.size();


}


public Properties getConfig(){


return this.reader.getConfig();


}


}

[](()4.4 GPBeanDefinitionReader

根据约定,BeanDefinitionReader 主要完成对 application.properties 配置文件的解析工作,实现逻辑非常简单。通过构造方法获取从 ApplicationContext 传过来的 locations 配置文件路径,然后解析,扫描并保存所有相关的类并提供统一的访问入口。


package com.tom.spring.formework.beans.support;


import com.tom.spring.formework.beans.config.GPBeanDefinition;


import java.io.File;


import java.io.IOException;


import java.io.InputStream;


import java.net.URL;


import java.util.ArrayList;


import java.util.List;


import java.util.Properties;


//对配置文件进行查找、读取、解析


public class GPBeanDefinitionReader {


private List<String> registyBeanClasses = new ArrayList<String>();


private Properties config = new Properties();


//固定配置文件中的 key,相对于 XML 的规范


private final String SCAN_PACKAGE = "scanPackage";


public GPBeanDefinitionReader(String... locations){


//通过 URL 定位找到其所对应的文件,然后转换为文件流


InputStream is = this.getClass().getClassLoader().getResourceAsStream(locations[0]. replace("classpath:",""));


try {


config.load(is);


} catch (IOException e) {


e.printStackTrace();


}finally {


if(null != is){


try {


is.close();


} catch (IOException e) {


e.printStackTrace();


}


}


}


doScanner(config.getProperty(SCAN_PACKAGE));


}


private void doScanner(String scanPackage) {


//转换为文件路径,实际上就是把.替换为/


URL url = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll ("\.","/"));


File classPath = new File(url.getFile());


for (File file : classPath.listFiles()) {


if(file.isDirectory()){


doScanner(scanPackage + "." + file.getName());


}else{


if(!file.getName().endsWith(".class")){ continue;}


String className = (scanPackage + "." + file.getName().replace(".class",""));


registyBeanClasses.add(className);


}


}


}


public Properties getConfig(){


return this.config;


}


//把配置文件中扫描到的所有配置信息转换为 GPBeanDefinition 对象,以便于之后的 IoC 操作


public List<GPBeanDefinition> loadBeanDefinitions(){


List<GPBeanDefinition> result = new ArrayList<GPBeanDefinition>();


try {


for (String className : registyBeanClasses) {


Class<?> beanClass = Class.forName(className);


if(beanClass.isInterface()) { continue; }


result.add(doCreateBeanDefinition(toLowerFirstCase(beanClass.getSimpleName()), beanClass.getName()));


Class<?> [] interfaces = beanClass.getInterfaces();


for (Class<?> i : interfaces) {


result.add(doCreateBeanDefinition(i.getName(),beanClass.getName()));


}


}


}catch (Exception e){


e.printStackTrace();


}


return result;


}


//把每一个配置信息解析成一个 BeanDefinition


private GPBeanDefinition doCreateBeanDefinition(String factoryBeanName,String beanClassName){


GPBeanDefinition beanDefinition = new GPBeanDefinition();


beanDefinition.setBeanClassName(beanClassName);


beanDefinition.setFactoryBeanName(factoryBeanName);


return beanDefinition;


}


//将类名首字母改为小写


//为了简化程序逻辑,就不做其他判断了,大家了解就好


private String toLowerFirstCase(String simpleName) {


char [] chars = simpleName.toCharArray();


//因为大小写字母的 ASCII 码相差 32


//而且大写字母的 ASCII 码要小于小写字母的 ASCII 码


《一线大厂 Java 面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》无偿开源 威信搜索公众号【编程进阶路】 //在 Java 中,对 char 做算术运算,实际上就是对 ASCII 码做算术运算


chars[0] += 32;


return String.valueOf(chars);


}


}

[](()4.5 GPApplicationContextAware

相信很多“小伙伴”都用过 ApplicationContextAware 接口,主要是通过实现侦听机制得到一个回调方法,从而得到 IoC 容器的上下文,即 ApplicationContext。在这个 Mini 版本中只是做了一个顶层设计,告诉大家这样一种现象,并没有做具体实现。这不是本书的重点,感兴趣的“小伙伴”可以自行尝试。


package com.tom.spring.formework.context;


/**


  • 通过解耦方式获得 IoC 容器的顶层设计

  • 后面将通过一个监听器去扫描所有的类,只要实现了此接口,

  • 将自动调用 setApplicationContext()方法,从而将 IoC 容器注入目标类中


*/


public interface GPApplicationContextAware {


void setApplicationContext(GPApplicationContext applicationContext);


}


关注微信公众号『 Tom 弹架构 』回复“Spring”可获取完整源码。

用户头像

还未添加个人签名 2022.04.13 加入

还未添加个人简介

评论

发布
暂无评论
30个类手写Spring核心原理之Ioc顶层架构设计(2)_Java_爱好编程进阶_InfoQ写作社区