源码分析之SpringBoot启动流程原理

落日映苍穹つ 2022-11-12 15:59 270阅读 0赞

### 源码分析之SpringBoot启动流程原理 ###

*   *  1、解析启动初始化SpringApplication构造器
     *   *  1.1、推端Web应用类型
         *  1.2、初始化应用上下文
         *  1.3、初始化监听器类
         *  1.4、推演主程序类
     *  2、解析run方法
     *   *  2.1、获取启动监听器
         *  2.2、准备环境
         *   *  2.2.1、配置环境
             *  2.2.2、环境准备完成
         *  2.3、配置忽略的bean
         *  2.4、打印banner
         *  2.5、创建容器
         *  2.6、创建容器
         *  2.7、刷新应用上下文
         *  2.8、刷新后处理
         *  2.9、发布监听应用启动事件
         *  2.10、执行Runner
         *  2.11、发布上下文准备完成的事件
     *  3、往期佳文
     *   *  3.1、面试系列
         *  3.2、技术系列

public static void main(String[] args) { 
    	SpringApplication.run(DemoApplication.class, args);
    }

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

## 1、解析启动初始化SpringApplication构造器 ##

// SpringApplication构造器
    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) { 
    	// 资源加载器
    	this.resourceLoader = resourceLoader;
    	Assert.notNull(primarySources, "PrimarySources must not be null");
    	this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    	// 1.可能的web应用程序的类型
    	this.webApplicationType = WebApplicationType.deduceFromClasspath();
    	this.bootstrappers = new ArrayList<>(getSpringFactoriesInstances(Bootstrapper.class));
    	// 2.设置初始化应用context
    	setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    	// 3.设置初始化监听
    	setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    	// 4.推演主程序类
    	this.mainApplicationClass = deduceMainApplicationClass();
    }

### 1.1、推端Web应用类型 ###

this.webApplicationType = WebApplicationType.deduceFromClasspath();

// 不是web应用
    NONE,
    // servlet容器
    SERVLET,
    // 反应型web应用
    REACTIVE;
    static WebApplicationType deduceFromClasspath() { 
    	if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
    			&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) { 
    		return WebApplicationType.REACTIVE;
    	}
    	for (String className : SERVLET_INDICATOR_CLASSES) { 
    		if (!ClassUtils.isPresent(className, null)) { 
    			return WebApplicationType.NONE;
    		}
    	}
    	return WebApplicationType.SERVLET;
    }

--------------------

### 1.2、初始化应用上下文 ###

setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) { 
    	ClassLoader classLoader = getClassLoader();
    	// Use names and ensure unique to protect against duplicates
    	// 加载ApplicationContextIninializer.class类型的类
    	// 这里传入就是参数ApplicationContextIninializer.class
    	Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    	// 实例化加载到的类
    	List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    	AnnotationAwareOrderComparator.sort(instances);
    	return instances;
    }

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) { 
        ClassLoader classLoaderToUse = classLoader;
        if (classLoader == null) { 
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }
    
        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

// 主要加载 spring-boot、spring-bean、Spring-boot-autoconfigure包下的spring.factories
    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) { 
    	// 从缓存中获取
    	Map<String, List<String>> result = cache.get(classLoader);
    	if (result != null) { 
    		return result;
    	}
    
    	result = new HashMap<>();
    	try { 
    		Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
    		while (urls.hasMoreElements()) { 
    			URL url = urls.nextElement();
    			UrlResource resource = new UrlResource(url);
    			Properties properties = PropertiesLoaderUtils.loadProperties(resource);
    			for (Map.Entry<?, ?> entry : properties.entrySet()) { 
    				String factoryTypeName = ((String) entry.getKey()).trim();
    				String[] factoryImplementationNames =
    						StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
    				for (String factoryImplementationName : factoryImplementationNames) { 
    					result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
    							.add(factoryImplementationName.trim());
    				}
    			}
    		}
    
    		// Replace all lists with unmodifiable lists containing unique elements
    		result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
    				.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
    		cache.put(classLoader, result);
    	}
    	catch (IOException ex) { 
    		throw new IllegalArgumentException("Unable to load factories from location [" +
    				FACTORIES_RESOURCE_LOCATION + "]", ex);
    	}
    	// 返回加载到的所有类
    	return result;
    }

private List<ApplicationContextInitializer<?>> initializers;
    public void setInitializers(Collection<? extends ApplicationContextInitializer<?>> initializers) { 
    	this.initializers = new ArrayList<>(initializers);
    }

### 1.3、初始化监听器类 ###

setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

与初始化上下文类似

--------------------

### 1.4、推演主程序类 ###

this.mainApplicationClass = deduceMainApplicationClass();

private Class<?> deduceMainApplicationClass() { 
    	try { 
    		// StackTraceElement表示StackTrace(堆栈轨迹)中的一个元素
    		StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
    		for (StackTraceElement stackTraceElement : stackTrace) { 
    			if ("main".equals(stackTraceElement.getMethodName())) { 
    				// 通过放射创建对象
    				return Class.forName(stackTraceElement.getClassName());
    			}
    		}
    	}
    	catch (ClassNotFoundException ex) { 
    		// Swallow and continue
    	}
    	return null;
    }

--------------------

## 2、解析run方法 ##

public ConfigurableApplicationContext run(String... args) { 
    	StopWatch stopWatch = new StopWatch();
    	// 计时器开始
    	stopWatch.start();
    	DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    	ConfigurableApplicationContext context = null;
    	// 配置Headless模式，是在缺少显示屏、键盘或者鼠标是的系统配置
    	// 默认为true
    	configureHeadlessProperty();
    	// 获取所有监听器
    	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
    		Banner printedBanner = printBanner(environment);
    		// 创建容器
    		context = createApplicationContext();
    		context.setApplicationStartup(this.applicationStartup);
    		// 准备应用上下文
    		prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
    		// 刷新容器
    		refreshContext(context);
    		// 刷新容器后的扩展接口
    		afterRefresh(context, applicationArguments);
    		stopWatch.stop();
    		if (this.logStartupInfo) { 
    			new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
    		}
    		// 发布监听应用上下文启动完成
    		listeners.started(context);
    		// 执行runner
    		callRunners(context, applicationArguments);
    	}
    	catch (Throwable ex) { 
    		handleRunFailure(context, ex, listeners);
    		throw new IllegalStateException(ex);
    	}
    
    	try { 
    		// 监听应用上下文运行中
    		listeners.running(context);
    	}
    	catch (Throwable ex) { 
    		handleRunFailure(context, ex, null);
    		throw new IllegalStateException(ex);
    	}
    	return context;
    }

### 2.1、获取启动监听器 ###

private SpringApplicationRunListeners getRunListeners(String[] args) { 
    	Class<?>[] types = new Class<?>[] {  SpringApplication.class, String[].class };
    	return new SpringApplicationRunListeners(logger,
    			getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
    			this.applicationStartup);
    }

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) { 
    	ClassLoader classLoader = getClassLoader();
    	// Use names and ensure unique to protect against duplicates
    	Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    	List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    	AnnotationAwareOrderComparator.sort(instances);
    	return instances;
    }

// 拿到EventPulbishingRunListener启动监听器，下一步就是启动监听器
    void starting(ConfigurableBootstrapContext bootstrapContext, Class<?> mainApplicationClass) { 
    	doWithListeners("spring.boot.application.starting", (listener) -> listener.starting(bootstrapContext),
    			(step) -> { 
    				if (mainApplicationClass != null) { 
    					step.tag("mainApplicationClass", mainApplicationClass.getName());
    				}
    			});
    }

### 2.2、准备环境 ###

ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
    		DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) { 
    	// Create and configure the environment
    	// 根据依赖类型创建一个对应的容器
    	ConfigurableEnvironment environment = getOrCreateEnvironment();
    	// 配置环境
    	configureEnvironment(environment, applicationArguments.getSourceArgs());
    	ConfigurationPropertySources.attach(environment);
    	// 环境准备完成
    	listeners.environmentPrepared(bootstrapContext, environment);
    	DefaultPropertiesPropertySource.moveToEnd(environment);
    	configureAdditionalProfiles(environment);
    	bindToSpringApplication(environment);
    	if (!this.isCustomEnvironment) { 
    		environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
    				deduceEnvironmentClass());
    	}
    	ConfigurationPropertySources.attach(environment);
    	return environment;
    }

#### 2.2.1、配置环境 ####

protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) { 
    	if (this.addConversionService) { 
    		// 嵌入式的转换器
    		ConversionService conversionService = ApplicationConversionService.getSharedInstance();
    		environment.setConversionService((ConfigurableConversionService) conversionService);
    	}
    	// 配置属性资源文件
    	configurePropertySources(environment, args);
    	// 配置文件
    	configureProfiles(environment, args);
    }

#### 2.2.2、环境准备完成 ####

同上面启动监听时间，这次的环境准备也是同样的代码，这里是7个监听器对象

void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) { 
    	doWithListeners("spring.boot.application.environment-prepared",
    			(listener) -> listener.environmentPrepared(bootstrapContext, environment));
    }

### 2.3、配置忽略的bean ###

configureIgnoreBeanInfo(environment);

### 2.4、打印banner ###

class SpringBootBanner implements Banner { 
    
    	private static final String[] BANNER = {  "", " . ____ _ __ _ _",
    			" /\\\\ / ___'_ __ _ _(_)_ __ __ _ \\ \\ \\ \\", "( ( )\\___ | '_ | '_| | '_ \\/ _` | \\ \\ \\ \\",
    			" \\\\/ ___)| |_)| | | | | || (_| | ) ) ) )", " ' |____| .__|_| |_|_| |_\\__, | / / / /",
    			" =========|_|==============|___/=/_/_/_/" };
    
    	private static final String SPRING_BOOT = " :: Spring Boot :: ";
    	····
    }

### 2.5、创建容器 ###

context = createApplicationContext();

// 根据应用类型创建对应的容器
    ApplicationContextFactory DEFAULT = (webApplicationType) -> { 
    	try { 
    		switch (webApplicationType) { 
    		case SERVLET:
    			return new AnnotationConfigServletWebServerApplicationContext();
    		case REACTIVE:
    			return new AnnotationConfigReactiveWebServerApplicationContext();
    		default:
    			return new AnnotationConfigApplicationContext();
    		}
    	}
    	catch (Exception ex) { 
    		throw new IllegalStateException("Unable create a default ApplicationContext instance, "
    				+ "you may need a custom ApplicationContextFactory", ex);
    	}
    };

### 2.6、创建容器 ###

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
    		ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
    		ApplicationArguments applicationArguments, Banner printedBanner) { 
    	// 设置环境参数
    	context.setEnvironment(environment);
    	// 设置后处理应用上下文
    	postProcessApplicationContext(context);
    	// 把ApplicationContextInitializer初始化
    	applyInitializers(context);
    	// EventPulbishingRunListener发布应用上下文时间
    	listeners.contextPrepared(context);
    	bootstrapContext.close(context);
    	// 打印启动日志
    	if (this.logStartupInfo) { 
    		logStartupInfo(context.getParent() == null);
    		logStartupProfileInfo(context);
    	}
    	// Add boot specific singleton beans
    	ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    	// 注册一个字是springApplicationArguments单例的bean
    	beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    	if (printedBanner != null) { 
    		// 注册一个字是springBootBanner单例的bean
    		beanFactory.registerSingleton("springBootBanner", printedBanner);
    	}
    	if (beanFactory instanceof DefaultListableBeanFactory) { 
    		((DefaultListableBeanFactory) beanFactory)
    				.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    	}
    	if (this.lazyInitialization) { 
    		context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
    	}
    	// Load the sources
    	// 获取所有资源
    	Set<Object> sources = getAllSources();
    	Assert.notEmpty(sources, "Sources must not be empty");
    	// 创建BeanDefinitionLoader架子啊器加载注册所有资源
    	load(context, sources.toArray(new Object[0]));
    	// 同之前，发不应用上下文加载事件
    	listeners.contextLoaded(context);
    }

### 2.7、刷新应用上下文 ###

refreshContext(context);

@Override
    public void refresh() throws BeansException, IllegalStateException { 
    	synchronized (this.startupShutdownMonitor) { 
    		StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
    
    		// Prepare this context for refreshing.
    		// 准备刷新上下文
    		prepareRefresh();
    
    		// Tell the subclass to refresh the internal bean factory.
    		// 通知子类刷新内部工厂
    		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    		// Prepare the bean factory for use in this context.
    		// 准备Bean工厂
    		prepareBeanFactory(beanFactory);
    
    		try { 
    			// Allows post-processing of the bean factory in context subclasses.
    			// 允许在上下文子类中对bean工厂进行后处理
    			postProcessBeanFactory(beanFactory);
    
    			StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
    			// Invoke factory processors registered as beans in the context.
    			// 调用上下文注册为bean的工厂处理器
    			invokeBeanFactoryPostProcessors(beanFactory);
    
    			// Register bean processors that intercept bean creation.
    			// 注册后置处理器
    			registerBeanPostProcessors(beanFactory);
    			beanPostProcess.end();
    
    			// Initialize message source for this context.
    			// 初始化上下文
    			initMessageSource();
    
    			// Initialize event multicaster for this context.
    			// 初始化上下文时间发布器
    			initApplicationEventMulticaster();
    
    			// Initialize other special beans in specific context subclasses.
    			// 初始化其他自定义bean
    			onRefresh();
    
    			// Check for listener beans and register them.
    			// 注册监听器
    			registerListeners();
    
    			// Instantiate all remaining (non-lazy-init) singletons.
    			// 完成bean工厂初始化
    			finishBeanFactoryInitialization(beanFactory);
    
    			// Last step: publish corresponding event.
    			// 完成刷新，清缓存，初始化生命周期，事件发布
    			finishRefresh();
    		}
    
    		catch (BeansException ex) { 
    			if (logger.isWarnEnabled()) { 
    				logger.warn("Exception encountered during context initialization - " +
    						"cancelling refresh attempt: " + ex);
    			}
    
    			// Destroy already created singletons to avoid dangling resources.
    			// 销毁bean
    			destroyBeans();
    
    			// Reset 'active' flag.
    			cancelRefresh(ex);
    
    			// Propagate exception to caller.
    			throw ex;
    		}
    
    		finally { 
    			// Reset common introspection caches in Spring's core, since we
    			// might not ever need metadata for singleton beans anymore...
    			resetCommonCaches();
    			contextRefresh.end();
    		}
    	}
    }

创建tomcat容器

@Override
    protected void onRefresh() { 
    	super.onRefresh();
    	try { 
    		// 创建web服务
    		createWebServer();
    	}
    	catch (Throwable ex) { 
    		throw new ApplicationContextException("Unable to start web server", ex);
    	}
    }

private void createWebServer() { 
    	WebServer webServer = this.webServer;
    	ServletContext servletContext = getServletContext();
    	if (webServer == null && servletContext == null) { 
    		StartupStep createWebServer = this.getApplicationStartup().start("spring.boot.webserver.create");
    		ServletWebServerFactory factory = getWebServerFactory();
    		createWebServer.tag("factory", factory.getClass().toString());
    		// 获取到服务器对象
    		this.webServer = factory.getWebServer(getSelfInitializer());
    		createWebServer.end();
    		getBeanFactory().registerSingleton("webServerGracefulShutdown",
    				new WebServerGracefulShutdownLifecycle(this.webServer));
    		getBeanFactory().registerSingleton("webServerStartStop",
    				new WebServerStartStopLifecycle(this, this.webServer));
    	}
    	else if (servletContext != null) { 
    		try { 
    			getSelfInitializer().onStartup(servletContext);
    		}
    		catch (ServletException ex) { 
    			throw new ApplicationContextException("Cannot initialize servlet context", ex);
    		}
    	}
    	initPropertySources();
    }

设置参数

@Override
    public WebServer getWebServer(ServletContextInitializer... initializers) { 
    	if (this.disableMBeanRegistry) { 
    		Registry.disableRegistry();
    	}
    	Tomcat tomcat = new Tomcat();
    	File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
    	tomcat.setBaseDir(baseDir.getAbsolutePath());
    	Connector connector = new Connector(this.protocol);
    	connector.setThrowOnFailure(true);
    	tomcat.getService().addConnector(connector);
    	customizeConnector(connector);
    	tomcat.setConnector(connector);
    	tomcat.getHost().setAutoDeploy(false);
    	configureEngine(tomcat.getEngine());
    	for (Connector additionalConnector : this.additionalTomcatConnectors) { 
    		tomcat.getService().addConnector(additionalConnector);
    	}
    	prepareContext(tomcat.getHost(), initializers);
    	return getTomcatWebServer(tomcat);
    }

启动tomcat

public TomcatWebServer(Tomcat tomcat, boolean autoStart, Shutdown shutdown) { 
    	Assert.notNull(tomcat, "Tomcat Server must not be null");
    	this.tomcat = tomcat;
    	this.autoStart = autoStart;
    	this.gracefulShutdown = (shutdown == Shutdown.GRACEFUL) ? new GracefulShutdown(tomcat) : null;
    	initialize();
    }
    
    private void initialize() throws WebServerException { 
    	logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
    	synchronized (this.monitor) { 
    		try { 
    			addInstanceIdToEngineName();
    
    			Context context = findContext();
    			context.addLifecycleListener((event) -> { 
    				if (context.equals(event.getSource()) && Lifecycle.START_EVENT.equals(event.getType())) { 
    					// Remove service connectors so that protocol binding doesn't
    					// happen when the service is started.
    					removeServiceConnectors();
    				}
    			});
    
    			// Start the server to trigger initialization listeners
    			this.tomcat.start();
    
    			// We can re-throw failure exception directly in the main thread
    			rethrowDeferredStartupExceptions();
    
    			try { 
    				ContextBindings.bindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
    			}
    			catch (NamingException ex) { 
    				// Naming is not enabled. Continue
    			}
    
    			// Unlike Jetty, all Tomcat threads are daemon threads. We create a
    			// blocking non-daemon to stop immediate shutdown
    			startDaemonAwaitThread();
    		}
    		catch (Exception ex) { 
    			stopSilently();
    			destroySilently();
    			throw new WebServerException("Unable to start embedded Tomcat", ex);
    		}
    	}
    }

### 2.8、刷新后处理 ###

afterRefresh(context, applicationArguments);

空方法便于后面扩展

protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) { 
    }

### 2.9、发布监听应用启动事件 ###

void started(ConfigurableApplicationContext context) { 
    	doWithListeners("spring.boot.application.started", (listener) -> listener.started(context));
    }

### 2.10、执行Runner ###

获取所有的ApplicationRunner和CommandLineRunner来初始化一些参数

private void callRunners(ApplicationContext context, ApplicationArguments args) { 
    	List<Object> runners = new ArrayList<>();
    	runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
    	runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
    	AnnotationAwareOrderComparator.sort(runners);
    	for (Object runner : new LinkedHashSet<>(runners)) { 
    		if (runner instanceof ApplicationRunner) { 
    			callRunner((ApplicationRunner) runner, args);
    		}
    		if (runner instanceof CommandLineRunner) { 
    			callRunner((CommandLineRunner) runner, args);
    		}
    	}
    }

### 2.11、发布上下文准备完成的事件 ###

void running(ConfigurableApplicationContext context) { 
    	doWithListeners("spring.boot.application.running", (listener) -> listener.running(context));
    }

## 3、往期佳文 ##

### 3.1、面试系列 ###

1、[吊打面试官之一面自我介绍][Link 1]  
2、[吊打面试官之一面项目介绍][Link 2]  
3、[吊打面试官之一面系统架构设计][Link 3]  
4、[吊打面试官之一面你负责哪一块][Link 4]

······持续更新中······

--------------------

### 3.2、技术系列 ###

1、[吊打面试官之分布式会话][Link 5]  
2、[吊打面试官之分布式锁][Link 6]  
3、[吊打面试官之乐观锁][Link 7]  
4、[吊打面试官之幂等性问题][Link 8]  
5、[吊打面试关之分布式事务][Link 9]

······持续更新中······

--------------------

[Link 1]: https://blog.csdn.net/wtyicy/article/details/114933478
[Link 2]: https://blog.csdn.net/wtyicy/article/details/114983053
[Link 3]: https://blog.csdn.net/wtyicy/article/details/115005012
[Link 4]: https://blog.csdn.net/wtyicy/article/details/115064661
[Link 5]: https://blog.csdn.net/wtyicy/article/details/114685293
[Link 6]: https://blog.csdn.net/wtyicy/article/details/114915987
[Link 7]: https://blog.csdn.net/wtyicy/article/details/114915177
[Link 8]: https://blog.csdn.net/wtyicy/article/details/114888754
[Link 9]: https://blog.csdn.net/wtyicy/article/details/115081790