Spring Boot 入门

37) Boot 骨架项目

https://start.spring.io/pom.xml

38) Boot War项目

步骤1：创建模块，区别在于打包方式选择 war

步骤2：编写控制器

@Controller
public class MyController {
​
    @RequestMapping("/hello")
    public String abc() {
        System.out.println("进入了控制器");
        return "hello";
    }
}

步骤3：编写 jsp 视图，新建 webapp 目录和一个 hello.jsp 文件，注意文件名与控制器方法返回的视图逻辑名一致

src
    |- main
        |- java
        |- resources
        |- webapp
            |- hello.jsp

步骤4：配置视图路径，打开 application.properties 文件

spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

将来 prefix + 控制器方法返回值 + suffix 即为视图完整路径

测试

内置Tomcat测试 如果用 mvn 插件 mvn spring-boot:run 或 main 方法测试

• 必须添加如下依赖，因为此时用的还是内嵌 tomcat，而内嵌 tomcat 默认不带 jasper（用来解析 jsp）

<dependency>
    <groupId>org.apache.tomcat.embedgroupId>
    <artifactId>tomcat-embed-jasperartifactId>
    <scope>providedscope>
dependency>

也可以使用 Idea 配置 tomcat 来测试，此时用的是外置 tomcat

• 骨架生成的代码中，多了一个 ServletInitializer，它的作用就是配置外置 Tomcat 使用的，在外置 Tomcat 启动后，去调用它创建和运行 SpringApplication

对于 jar 项目，若要支持 jsp，也可以在加入 jasper 依赖的前提下，把 jsp 文件置入 META-INF/resources

39) Boot 启动过程

阶段一：SpringApplication 构造

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		// 记录 BeanDefinition 源
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		// 推断应用类型
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
		this.bootstrapRegistryInitializers = getBootstrapRegistryInitializersFromSpringFactories();
		// 记录 ApplicationContext 初始化器
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		// 记录监听器
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        // 推断主启动类
		this.mainApplicationClass = deduceMainApplicationClass();
	}

1. 记录 BeanDefinition 源

2. 推断应用类型

3. 记录 ApplicationContext 初始化器

4. 记录监听器

5. 推断主启动类

阶段二：执行 run 方法

public ConfigurableApplicationContext run(String... args) {
		// ...
 
        // 1.得到 SpringApplicationRunListeners，名字取得不好，实际是事件发布器
		SpringApplicationRunListeners listeners = getRunListeners(args);
        // 发布 application starting 事件1️⃣,代表Spring Boot 应用开始启动了
        listeners.starting(bootstrapContext, this.mainApplicationClass);
        try {
            // 2.封装启动 args 把参数分为选项参与非选项参数
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            // 3.
			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
			configureIgnoreBeanInfo(environment);
            // 7.打印 banner（*）
			Banner printedBanner = printBanner(environment);
            // 8.创建容器
			context = createApplicationContext();
			context.setApplicationStartup(this.applicationStartup);
			// 9.准备容器
            prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
			// 11.refresh 容器 
            refreshContext(context);
			afterRefresh(context, applicationArguments);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
			}
            // 11.1 发布 application started 事件5️⃣
			listeners.started(context);
            // 12.执行 runner
			callRunners(context, applicationArguments);
		}catch (Throwable ex) {
			handleRunFailure(context, ex, listeners);
			throw new IllegalStateException(ex);
		}
 
		try {
            // 持续运行
			listeners.running(context);
		}
        // ....
}
        
 
 
// 3.
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
		// Create and configure the environment
		ConfigurableEnvironment environment = getOrCreateEnvironment();
        // 根据参数信息封装成一个propertiesSource并添加到 Environment -基于命令行的参数
        // 4.ConfigurationPropertySources 处理（*）
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		// 对命名不规范的键统一处理成 ‘-’分割
        ConfigurationPropertySources.attach(environment);
        // 4.1发布 application environment 已准备事件2️⃣
        // 5.通过 EnvironmentPostProcessorApplicationListener 进行 env 后处理（*）
 
        //* application.properties，由 StandardConfigDataLocationResolver 解析
        // * spring.application.json
		listeners.environmentPrepared(bootstrapContext, environment);
		DefaultPropertiesPropertySource.moveToEnd(environment);
		Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
				"Environment prefix cannot be set via properties.");
		// 6.绑定 spring.main 到 SpringApplication 对象（*）
        bindToSpringApplication(environment);
		if (!this.isCustomEnvironment) {
			environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
					deduceEnvironmentClass());
		}
		ConfigurationPropertySources.attach(environment);
		return environment;
	}
 
// 9.
private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
		context.setEnvironment(environment);
		postProcessApplicationContext(context);
		// 9.1发布 application context 已初始化事件3️⃣
        applyInitializers(context);
		listeners.contextPrepared(context);
		bootstrapContext.close(context);
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}
		// Add boot specific singleton beans
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
		if (printedBanner != null) {
			beanFactory.registerSingleton("springBootBanner", printedBanner);
		}
		if (beanFactory instanceof DefaultListableBeanFactory) {
			((DefaultListableBeanFactory) beanFactory)
					.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
		if (this.lazyInitialization) {
			context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
		}
		// Load the sources
        // 10.加载 bean 定义
		Set