第六十五章 Spring之假如让你来写Boot—

本文链接：https://blog.csdn.net/weixin_42789334/article/details/146704687

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之曾经的老朋友——事务
第二十六章 Spring之假如让你来写事务——初稿篇
第二十七章 Spring之假如让你来写事务——铁三角篇
第二十八章 Spring之假如让你来写事务——属性篇
第二十九章 Spring之假如让你来写事务——状态篇
第三十章 Spring之假如让你来写事务——管理篇
第三十一章 Spring之假如让你来写事务——融入IOC容器篇
第三十二章 Spring之源码阅读——事务篇

第四部分——MVC篇

第五部分——Boot篇

前言

对于Spring一直都是既熟悉又陌生，说对它熟悉吧，平时用用没啥问题，但面试的时候被问的一脸懵逼，就很尴尬，都不好意思在简历上写着熟悉Spring了
在这里插入图片描述

所以决定花点时间研究研究Spring的源码。主要参考的书籍是：《Spring源码深度解析（第2版）》、《Spring揭秘》、《Spring技术内幕：深入解析Spring架构与设计原理（第2版）》

书接上回，在上篇 第六十四章 Spring之假如让你来写Boot——内嵌Web容器篇 中，A君已经完成了内嵌Web容器，又是一个新的里程碑，完成 BOOT 计日而待了。。。

尝试动手写IOC容器

出场人物：A君（苦逼的开发）、老大（项目经理）

背景：老大要求 A君在一周内开发个简单的 IOC容器

前情提要：A君已经完成了内嵌Web容器，又是一个新的里程碑，完成 BOOT 计日而待了。。。

第五十一版 Main方法启动

“A君，干得漂亮，现在基本都完事了。还差一点，在优化下吧！” 项目进入了尾声，老大现在整个人也都放松了起来，变得和颜悦色了

“优化啥？” A君问道

“看了你自己写的测试代码，没发现点端倪吗？用户还要注册好几个BeanDefinition，怪麻烦的。最好是让用户‘啪’一下就能启动起来项目，不用管那么多弯弯绕绕的东西。”

A君稍加思索，说道：“好吧，用户想要一键启动，最快的方法莫过于用Main方法启动了，相信只要是开发都接触过右键->run的时代。”

“A君，你长大了呀，现在懂的举一反三了。” 老大由衷的赞叹，想起当初刚认识 A君的那会儿，还是个啥也不懂的毛头小子，一晃眼，已经成长了这么多了。当下继续说道：“现在的你，应该足够应付这些情况了，去吧，让我们一起有个好的收尾吧。”

“好！” A君这次也回答的斩钉截铁，跟着老大学习了这么久，收获颇多。他心里也是由衷的感谢老大肯带着他成长

引导上下文

回到工位上之后，A君收拾了下心情，现在不是多愁善感的时候，活没有做完呢？需要先考虑下要如何实现一键启动的效果。在之前工作中，A君在启动的过程中处处埋点，留足拓展，生怕用户在使用中过程中无法进行定制化。那么现在 BOOT 自然也是一样的，拓展的方式无非就是接口、事件，这些东西都要有个地方存储，这就引出了上下文了，不过启动过程中的上下文是临时的，一旦启动完成，这个上下文也就没用了。这就像电脑开机时候的 BootLoader 一样，电脑刚开启时，需要把 CPU 引导到操作系统的代码处，当操作系统启动完成后，BootLoader 也就完成它的使命了。用更通俗一点的例子：A君想租房子时，谁都不认识，所以去找中介介绍、当中介把 A君带到房东面前后，就没有中介什么事了，后续就是 A君和房东之间的问题了。明白原委之后，A君新增BootstrapContext接口，代码如下：

/**
 * 启动引导上下文
 */
public interface BootstrapContext {
    /**
     * 如果类型已注册，则从上下文中返回一个实例
     * 如果以前没有访问过该实例，则将创建该实例
     */
    <T> T get(Class<T> type) throws IllegalStateException;

    <T> T getOrElse(Class<T> type, T other);

    <T> T getOrElseSupply(Class<T> type, Supplier<T> other);

    <T, X extends Throwable> T getOrElseThrow(Class<T> type, Supplier<? extends X> exceptionSupplier) throws X;

    <T> boolean isRegistered(Class<T> type);
}

只是上下文，显然没有任何操作空间，这时候就需要提供接口给用户实现，而后框架把他们管理起来，在需要的时候调用就行了。A君新增InstanceSupplier接口，代码如下：

@FunctionalInterface
interface InstanceSupplier<T> {

    static <T> InstanceSupplier<T> of(T instance) {
        return (registry) -> instance;
    }

    static <T> InstanceSupplier<T> from(Supplier<T> supplier) {
        return (registry) -> (supplier != null) ? supplier.get() : null;
    }

    T get(BootstrapContext context);

    default Scope getScope() {
        return Scope.SINGLETON;
    }
}

两个接口还是太多了，把它们整成一个接口吧。新增ConfigurableBootstrapContext接口，代码如下：

public interface ConfigurableBootstrapContext extends BootstrapRegistry, BootstrapContext {
}

接下来就是默认实现，基本就是一个读取的方法了。新增DefaultBootstrapContext类，代码如下：

public class DefaultBootstrapContext implements ConfigurableBootstrapContext {

    private final Map<Class<?>, InstanceSupplier<?>> instanceSuppliers = new HashMap<>();

    private final Map<Class<?>, Object> instances = new HashMap<>();

    private final ApplicationEventMulticaster events = new SimpleApplicationEventMulticaster();

    private <T> void register(Class<T> type, InstanceSupplier<T> instanceSupplier, boolean replaceExisting) {
        synchronized (this.instanceSuppliers) {
            boolean alreadyRegistered = this.instanceSuppliers.containsKey(type);
            if (replaceExisting || !alreadyRegistered) {
                this.instanceSuppliers.put(type, instanceSupplier);
            }
        }
    }

    @Override
    public <T> T get(Class<T> type) throws IllegalStateException {
        return getOrElseThrow(type, () -> new IllegalStateException(type.getName() + " has not been registered"));
    }

	//省略其他代码。。。
}

应用参数

除却上下文之外，应用在启动的过程中也可能携带参数。比如说命令行java -jar your-application.jar --server.port=8081启动时就携带了端口的配置。这时候自然也就需求把这些参数封装起来了。A君新增ApplicationArguments接口，代码如下：

/**
 * 应用参数
 */
public interface ApplicationArguments {

    /**
     * 返回传递给应用程序的未处理的原始参数
     */
    String[] getSourceArgs();

    /**
     * 返回所有选项参数的名称。例如，如果参数是
     * “——foo=bar——debug”将返回值{@code ["foo", "debug"]}。
     */
    Set<String> getOptionNames();

    /**
     * 是否包含某个选项
     */
    boolean containsOption(String name);

    List<String> getOptionValues(String name);

    List<String> getNonOptionArgs();

}

再给个实现类吧，自然也是一堆的读取方法，没啥特殊的地方。参数虽然没有特殊的地方，但是参数来源可以是多种多样，可以是传统的命令行，也可以是 JOP。这里就不一一展开了，设计方式明白了就行，实现细节就先不纠结了。A君新增``

public class DefaultApplicationArguments implements ApplicationArguments {
    /**
     * 参数来源
     */
    private final Source source;
    /**
     * 参数
     */
    private final String[] args;

    public DefaultApplicationArguments(String... args) {
        this.source = new Source(args);
        this.args = args;
    }

    @Override
    public Set<String> getOptionNames() {
        String[] names = this.source.getPropertyNames();
        return Collections.unmodifiableSet(new HashSet<>(Arrays.asList(names)));
    }
    //省略其它代码。。。
}

打印横幅

A君折腾了这么久，呕心沥血弄出来的东西，不能默默无闻，要让世人知道这一伟大的框架，为此 A君决定在启动时候打印框架的名称，让他闻名于世。话虽如此，这样符合设计的规范，顶多算个软广，硬广反而会起到反作用。A君新增Banner接口，代码如下：

/**
 * 横幅接口
 */
@FunctionalInterface
public interface Banner {
    /**
     * 打印横幅
     */
    void printBanner(Environment environment, Class<?> sourceClass, PrintStream out);

    enum Mode {

        /**
         * 禁用横幅
         */
        OFF,

        /**
         * 控制台
         */
        CONSOLE,

        /**
         * 日志
         */
        LOG
    }
}

打印的方式可以是文字，也可以是图片，这里就以文字为例吧，图片涉及到太多图形化的知识，研究这玩意就偏离了轨道了。当然了，内容要想可配置，最好的方式就是把要打印的内容整成一个文本文件，这样子框架只需要读取内容就行了。A君新增ResourceBanner类，代码如下：

/**
 * 根据对应资源打印横幅
 */
public class ResourceBanner implements Banner {

    /**
     * 文本资源
     */
    private Resource resource;

    @Override
    public void printBanner(Environment environment, Class<?> sourceClass, PrintStream out) {
        try {
            String banner = StreamUtils.copyToString(this.resource.getInputStream(),
                    environment.getProperty("spring.banner.charset", Charset.class, StandardCharsets.UTF_8));
            for (PropertyResolver resolver : getPropertyResolvers(environment, sourceClass)) {
                banner = resolver.resolvePlaceholders(banner);
            }
            out.println(banner);
        } catch (Exception ex) {
            logger.warn(LogMessage.format("Banner not printable: %s (%s: '%s')", this.resource, ex.getClass(),
                    ex.getMessage()), ex);
        }
    }
}

只是支持单一的风格，一向不是 A君的风格，为此，A君提供了混合打印模式，可以自由组合。新增Banners类，代码如下：

/**
     * 混合模式
     */
    private static class Banners implements Banner {
        /**
         * 包含的横幅实现
         */
        private final List<Banner> banners = new ArrayList<>();

        void addIfNotNull(Banner banner) {
            if (banner != null) {
                this.banners.add(banner);
            }
        }

        @Override
        public void printBanner(Environment environment, Class<?> sourceClass, PrintStream out) {
            for (Banner banner : this.banners) {
                banner.printBanner(environment, sourceClass, out);
            }
        }

    }

打印是没什么事了，接下来就是关于一些路径的配置，这些可以单独整理成一个类，方便使用。A君新增SpringApplicationBannerPrinter类，代码如下：

class SpringApplicationBannerPrinter {

    static final String BANNER_LOCATION_PROPERTY = "spring.banner.location";

    static final String BANNER_IMAGE_LOCATION_PROPERTY = "spring.banner.image.location";

    static final String DEFAULT_BANNER_LOCATION = "banner.txt";

    static final String[] IMAGE_EXTENSION = {"gif", "jpg", "png"};

    private static final Banner DEFAULT_BANNER = new SpringBootBanner();

    private final ResourceLoader resourceLoader;

    private final Banner fallbackBanner;

    SpringApplicationBannerPrinter(ResourceLoader resourceLoader, Banner fallbackBanner) {
        this.resourceLoader = resourceLoader;
        this.fallbackBanner = fallbackBanner;
    }

    Banner print(Environment environment, Class<?> sourceClass, Log logger) {
        Banner banner = getBanner(environment);
        try {
            logger.info(createStringFromBanner(banner, environment, sourceClass));
        } catch (UnsupportedEncodingException ex) {
            logger.warn("Failed to create String for banner", ex);
        }
        return new PrintedBanner(banner, sourceClass);
    }

    Banner print(Environment environment, Class<?> sourceClass, PrintStream out) {
        Banner banner = getBanner(environment);
        banner.printBanner(environment, sourceClass, out);
        return new PrintedBanner(banner, sourceClass);
    }
	//省略其他代码。。。
}

启动！！！

一切都准备好了，现在只要把这些东西整合起来就行了。像这种可以分成第一步、第二步的都可以使用 模板模式。A君新增SpringApplication类，代码如下：

public class SpringApplication {
	public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        return run(new Class<?>[]{primarySource}, args);
    }

    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return new SpringApplication(primarySources).run(args);
    }
	
	public ConfigurableApplicationContext run(String... args) {
        long startTime = System.nanoTime();
        /**
         * 创建BOOT上下文
         */
        DefaultBootstrapContext bootstrapContext = createBootstrapContext();
        ConfigurableApplicationContext context = null;
        configureHeadlessProperty();
        /**
         * 获取SpringBoot运行时监听
         */
        SpringApplicationRunListeners listeners = getRunListeners(args);
        //触发启动监听
        listeners.starting(bootstrapContext, this.mainApplicationClass);
        try {
            //启动时参数
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            //准备环境
            ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
            //忽略Bean
            configureIgnoreBeanInfo(environment);
            //打印横幅
            Banner printedBanner = printBanner(environment);
            //创建ApplicationContext对象
            context = createApplicationContext();
            context.setApplicationStartup(this.applicationStartup);
            prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
            //调用Application#refresh方法
            refreshContext(context);
            //拓展方法，有子类实现
            afterRefresh(context, applicationArguments);
            Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
            //触发启动完成事件
            listeners.started(context, timeTakenToStartup);
            callRunners(context, applicationArguments);
        } catch (Throwable ex) {
            handleRunFailure(context, ex, listeners);
            throw new IllegalStateException(ex);
        }
        try {
            Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
            listeners.ready(context, timeTakenToReady);
        } catch (Throwable ex) {
            handleRunFailure(context, ex, null);
            throw new IllegalStateException(ex);
        }
        return context;
    }
    //省略其他代码
}

测试

一切都准备好了，现在就是检验最终成果的时候了。A君怀着激动的心，颤抖着手，写了测试代码，哦，不对，没有测试代码，只有一个启动类。如下：

@Configuration
@EnableAutoConfiguration
@ComponentScan(basePackages = "com.hqd.ch03.test.boot.v51",
        excludeFilters = {@ComponentScan.Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
                @ComponentScan.Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)})

public class MainApplication {
    public static void main(String[] args) {
        try {
            System.setProperty("spring.banner.image.location", "file:E:/1.jpg");
            SpringApplication.run(MainApplication.class, args);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}