自己实现spring核心功能 二

  1. 云栖社区>
  2. 博客>
  3. 正文

自己实现spring核心功能 二

幸运码发放 2019-08-18 14:23:12 浏览136
展开阅读全文

自己实现spring核心功能 二
前言
上一篇我们讲了spring的一些特点并且分析了需要实现哪些功能,已经把准备工作都做完了,这一篇我们开始实现具体功能。

容器加载过程
我们知道,在spring中refesh()方法做了很多初始化的工作,它几乎涵盖了spring的核心流程

public void refresh() throws BeansException, IllegalStateException {

synchronized (this.startupShutdownMonitor) {
    //刷新之前的准备工作,包括设置启动时间,是否激活标识位,初始化属性源(property source)配置
    prepareRefresh();
    //由子类去刷新BeanFactory(如果还没创建则创建),并将BeanFactory返回
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    //准备BeanFactory以供ApplicationContext使用
    prepareBeanFactory(beanFactory);
    try {
        //子类可通过格式此方法来对BeanFactory进行修改
        postProcessBeanFactory(beanFactory);
        //实例化并调用所有注册的BeanFactoryPostProcessor对象
        invokeBeanFactoryPostProcessors(beanFactory);
        //实例化并调用所有注册的BeanPostProcessor对象
        registerBeanPostProcessors(beanFactory);
        //初始化MessageSource
        initMessageSource();
        //初始化事件广播器
        initApplicationEventMulticaster();
        //子类覆盖此方法在刷新过程做额外工作
        onRefresh();
        //注册应用监听器ApplicationListener
        registerListeners();
        //实例化所有non-lazy-init bean
        finishBeanFactoryInitialization(beanFactory);
        //刷新完成工作,包括初始化LifecycleProcessor,发布刷新完成事件等
        finishRefresh();
    }
    catch (BeansException ex) {
        // Destroy already created singletons to avoid dangling resources.
        destroyBeans();
        // Reset 'active' flag.
        cancelRefresh(ex);
        // Propagate exception to caller.
        throw ex;
    }
}

}
做的东西比较复杂,而我们实现做些基本的就好了。

我们在CJDispatcherServlet 类的init方法中,实现如下业务逻辑,就能将spring功能给初始化了,就可以使用依赖注入了

@Override
public void init(ServletConfig config) {
    //加载配置

    //获取要扫描的包地址

    //扫描要加载的类

    //实例化要加载的类

    //加载依赖注入,给属性赋值

    //加载映射地址
 
}

加载配置
String contextConfigLocation = config.getInitParameter("contextConfigLocation");

    loadConfig(contextConfigLocation);

这里会获取到web.xml中init-param节点中的值

具体指向的是spring文件下的application.properties配置文件,里面只有一行配置

通过配置的key名字可以知道,这是指定了需要扫描的包路径

代表的是扫描红框中定义的所有类

第二行代码是创建了一个loadConfig方法,将包路径传进去

void loadConfig(String contextConfigLocation) {
    InputStream is = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
    try {
        properties.load(is);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (null != is) {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

黃色部分的代码需要注意,这里使用了一个成员变量

private Properties properties = new Properties();
在类的上半部分定义就好了,这里的作用是获取application.properties文件中的配置内容加载到properties变量中,供后面使用。

获取要扫描的包地址

//获取要扫描的包地址
String dirpath = properties.getProperty("scanner.package");
这里使用配置中的key读取出目录地址

扫描要加载的类
//扫描要加载的类
doScanner(dirpath);
扫描类我们定义一个doScanner方法,把包目录地址传进去

1 void doScanner(String dirpath) {
2 URL url = this.getClass().getClassLoader().getResource("/" + dirpath.replaceAll("\.", "/"));
3 File dir = new File(url.getFile());
4 File[] files = dir.listFiles();
5 for (File file : files) {
6 if (file.isDirectory()) {
7 doScanner(dirpath + "." + file.getName());
8 continue;
9 }
10
11 //取文件名
12 String beanName = dirpath + "." + file.getName().replaceAll(".class", "");
13 beanNames.add(beanName);
14 }
15 }
第二行代码进行了转义替换

本方法内的代码作业是读取指定路径下的文件,如果是文件夹,则递归调用,如果是文件,把文件名称和路径存进集合容器内

需要注意黄色部分的变量,是在外部定义了一个成员变量

private List beanNames = new ArrayList<>();
我们在类的上半部分加上它。

得到的beanName如下

从这里看出,它已经把我们定义的注解给找出来了。

实例化要加载的类
//实例化要加载的类
doInstance();
刚才我们已经得到了这些定义好的类的名称列表,现在我们需要一个个实例化,并且保存在ioc容器当中。

先定义个装载类的容器,使用HashMap就能做到,将它设为成员变量,在类的上半部分定义

private Map ioc = new HashMap<>();
接着创建一个方法doInstance
1 void doInstance() {
2 if (beanNames.isEmpty()) {
3 return;
4 }
5 for (String beanName : beanNames) {
6 try {
7 Class cls = Class.forName(beanName);
8 if (cls.isAnnotationPresent(JCController.class)) {
9 //使用反射实例化对象
10 Object instance = cls.newInstance();
11 //默认类名首字母小写
12 beanName = firstLowerCase(cls.getSimpleName());
13 //写入ioc容器
14 ioc.put(beanName, instance);
15
16
17 } else if (cls.isAnnotationPresent(JCService.class)) {
18 Object instance = cls.newInstance();
19 JCService jcService = (JCService) cls.getAnnotation(JCService.class);
20
21 String alisName = jcService.value();
22 if (null == alisName || alisName.trim().length() == 0) {
23 beanName = cls.getSimpleName();
24 } else {
25 beanName = alisName;
26 }
27 beanName = firstLowerCase(beanName);
28 ioc.put(beanName, instance);
29 //如果是接口,自动注入它的实现类
30 Class<?>[] interfaces = cls.getInterfaces();
31 for (Class<?> c :
32 interfaces) {
33 ioc.put(firstLowerCase(c.getSimpleName()), instance);
34 }
35 } else {
36 continue;
37 }
38 } catch (ClassNotFoundException e) {
39 e.printStackTrace();
40 } catch (IllegalAccessException e) {
41 e.printStackTrace();
42 } catch (InstantiationException e) {
43 e.printStackTrace();
44 }
45 }
46 }
只要提供类的完全限定名,通过Class.forName静态方法,我们就能将类信息加载到内存中并且返回Class 对象,通过反射来实例化,见第10行代码,

我们通过循环beanNames集合,来实例化每个类,并将实例化后的对象装入HashMap中

注意:第12行将类名的首字母小写后存入map,该方法定义如下

1 String firstLowerCase(String str) {
2 char[] chars = str.toCharArray();
3 chars[0] += 32;
4 return String.valueOf(chars);
5 }
这行代码会将字符串转成char数组,然后将数组中第一个字符转为大写,这里采用了一种比较巧妙的方式实现,tom老师采用了一种比较骚的操作

实例化完成后,ioc容器中的数据如下:

说明:

图片中可以看出,hashMap的key 都是小写,value已经是对象了 ,见红框。

这里为什么要把蓝框标记出来,是因为这是类中的字段属性,此时可以看到,虽然类已经被实例化了,可是属性还是null呢

我这里为了测试依赖注入,所以加了2个接口和2个实现类

接口定义如下:
View Code

实现类:
View Code
View Code
依赖实体:

View Code

加载依赖注入,给属性赋值
//加载依赖注入,给属性赋值

    doAutoWrited();

现在我们实现依赖注入,需要定义一个无参的方法doAutoWrite

1 void doAutoWrited() {
2 for (Map.Entry obj : ioc.entrySet()) {
3 try {
4 for (Field field : obj.getValue().getClass().getDeclaredFields()) {
5 if (!field.isAnnotationPresent(JCAutoWrited.class)) {
6 continue;
7 }
8 JCAutoWrited autoWrited = field.getAnnotation(JCAutoWrited.class);
9 String beanName = autoWrited.value();
10 if ("".equals(beanName)) {
11 beanName = field.getType().getSimpleName();
12 }
13
14 field.setAccessible(true);
15
16 field.set(obj.getValue(), ioc.get(firstLowerCase(beanName)));
17 }
18 } catch (IllegalAccessException e) {
19 e.printStackTrace();
20 }
21
22 }
23
24
25 }
这个方法是通过循环ioc里面的实体,反射找出字段,看看是否有需要注入的标记JCAutoWrited,如果加了标记,就反射给字段赋值,类型从ioc容器中获取

加载映射地址

//加载映射地址

doRequestMapping();

映射地址的作用是根据请求的url匹配method方法

1 void doRequestMapping() {
2 if (ioc.isEmpty()) {
3 return;
4 }
5 for (Map.Entry obj : ioc.entrySet()) {
6 if (!obj.getValue().getClass().isAnnotationPresent(JCController.class)) {
7 continue;
8 }
9 Method[] methods = obj.getValue().getClass().getMethods();
10 for (Method method : methods) {
11 if (!method.isAnnotationPresent(JCRequestMapping.class)) {
12 continue;
13 }
14 String baseUrl = "";
15 if (obj.getValue().getClass().isAnnotationPresent(JCRequestMapping.class)) {
16 baseUrl = obj.getValue().getClass().getAnnotation(JCRequestMapping.class).value();
17 }
18 JCRequestMapping jcRequestMapping = method.getAnnotation(JCRequestMapping.class);
19 if ("".equals(jcRequestMapping.value())) {
20 continue;
21 }
22 String url = (baseUrl + "/" + jcRequestMapping.value()).replaceAll("/+", "/");
23 urlMapping.put(url, method);
24 System.out.println(url);
25 }
26 }
27 }
这里其实就是根据对象反射获取到JCRequestMapping上面的value值

@JCRequestMapping("/sayHi")

取到的就是/sayHi

另外注意的是:黄色部分使用的变量是一个hashMap,在类上半部分定义的

private Map urlMapping = new HashMap<>();

这里面存的是 url 和对应的method对象。后面处理请求的时候要使用到的。

结尾
容器的初始化到这里就结束了,一共使用了4个容器来存放相关对象,后续servlet处理请求的时候会用到它们。

下一篇,将会继续完善它,通过请求来验证是否可以达到预期效果。另外会实现参数绑定,能处理各类请求并响应。

完整代码地址
原文地址https://www.cnblogs.com/jingch/p/11369599.html

网友评论

作者关闭了评论
幸运码发放
+ 关注