关于java:30个类手写Spring核心原理之Ioc顶层架构设计2

38次阅读

共计 10853 个字符，预计需要花费 28 分钟才能阅读完成。

本文节选自《Spring 5 外围原理》

1 Annotation（自定义配置）模块

Annotation 的代码实现咱们还是沿用 Mini 版本的，放弃不变，复制过去便可。

1.1 @GPService

@GPService 代码如下：


package com.tom.spring.formework.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 业务逻辑，注入接口
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPService {String value() default "";
     
}

1.2 @GPAutowired

@GPAutowired 代码如下：


package com.tom.spring.formework.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 主动注入
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPAutowired {String value() default "";
     
}

1.3 @GPController

@GPController 代码如下：


package com.tom.spring.formework.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 页面交互
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPController {String value() default "";
     
}

1.4 @GPRequestMapping

@GPRequestMapping 代码如下：


package com.tom.spring.formework.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 申请 URL
 */
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPRequestMapping {String value() default "";
     
}

1.5 @GPRequestParam

@GPRequestParam 代码如下：


package com.tom.spring.formework.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 申请参数映射
 */
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPRequestParam {String value() default "";
     
}

2 core（顶层接口）模块

2.1 GPFactoryBean

对于顶层接口设计，通过后面的学习咱们理解了 FactoryBean 的根本作用，在此不做过多解释。


package com.tom.spring.formework.core;

public interface GPFactoryBean {

}

2.2 GPBeanFactory

作为所有 IoC 容器的顶层设计，后面也曾经具体介绍了 BeanFactory 的作用。


package com.tom.spring.formework.core;

/**
 * 单例工厂的顶层设计
 */
public interface GPBeanFactory {

    /**
     * 依据 beanName 从 IoC 容器中取得一个实例 Bean
     * @param beanName
     * @return
     */
    Object getBean(String beanName) throws Exception;

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

}

3 beans（配置封装）模块

3.1 GPBeanDefinition

BeanDefinition 次要用于保留 Bean 相干的配置信息。


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

// 用来存储配置文件中的信息
// 相当于保留在内存中的配置
public class GPBeanDefinition {

    private String beanClassName;  // 原生 Bean 的全类名
    private boolean lazyInit = false; // 标记是否延时加载
    private String factoryBeanName;  // 保留 beanName，在 IoC 容器中存储的 key
        
    public String getBeanClassName() {return beanClassName;}
        
    public void setBeanClassName(String beanClassName) {this.beanClassName = beanClassName;}
        
    public boolean isLazyInit() {return lazyInit;}
        
    public void setLazyInit(boolean lazyInit) {this.lazyInit = lazyInit;}
        
    public String getFactoryBeanName() {return factoryBeanName;}
        
    public void setFactoryBeanName(String factoryBeanName) {this.factoryBeanName = factoryBeanName;}
        
}

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 中，对 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”可获取残缺源码。

本文为“Tom 弹架构”原创，转载请注明出处。技术在于分享，我分享我高兴！如果您有任何倡议也可留言评论或私信，您的反对是我保持创作的能源。关注微信公众号『Tom 弹架构』可获取更多技术干货！

原创不易，保持很酷，都看到这里了，小伙伴记得点赞、珍藏、在看，一键三连加关注！如果你感觉内容太干，能够分享转发给敌人滋润滋润！

正文完
java
发表至： java
2021-12-10
 0
JAVA面试题19
关于java:优雅转化DTOVOBOPODO
MyBatis源码下载安装教程
如何在Github提交图片，做一个自己的图片仓库