目录

一：Spring Boot 入门

1. Spring能做什么？

2. SpringBoot特点

3. 如何学习SpringBoot

4. 创建Spring Boot项目

Maven的配置

入门案例：

SpringBoot中几个重要的注解

5. 了解自动配置原理

依赖管理

自动配置

6. SpringBoot核心配置文件

多环境测试

自定义配置

7. SpringBoot中使用JSP（了解）

8. SpringBoot中使用ApplicationContext（上下文对象）

9. CommandLineRunner接口 & ApplicationRunner接口

图书推荐：集齐“Java四大名著”召唤神龙

---

一：Spring Boot 入门

SpringBoot是Spring家族中的一个成员， 可以简化Spring、SpringMVC的使用。它的核心还是IOC容器，底层是Spring！

1. Spring能做什么？

微服务：将项目的工程拆分成一个个微小的功能模块，每一个微小的功能模块就是一个微服务。

• 微服务是一种架构风格；
• 一个应用拆分为一组小型服务；
• 每个服务运行在自己的进程内，也就是可独立部署和升级；
• 服务之间使用轻量级HTTP交互；
• 服务围绕业务功能拆分；
• 可以由全自动部署机制独立部署；
• 去中心化，服务自治。服务可以使用不同的语言、不同的存储技术；

响应式：基于异步非阻塞的方式，应用之间构建一个异步数据流的方式，异步数据流允许占用少量的线程资源，可以构建一个高吞吐量的开发。

分布式、云开发：将项目拆分成很多微小的服务就会产生分布式应用。

分布式的困难：远程调用、服务发现、负载均衡、服务容错、配置管理、服务监控、链路追踪、日志管理、任务调度。

分布式的困难：SpringBoot + SpringCloud。

无服务开发：函数式开发，上到云平台。

事件驱动：构建一个实时的数据流，有了实时数据流就可以通过响应的方式，让系统占用少量的资源，完成高吞吐量的业务。

批处理：自动化任务。

2. SpringBoot特点

特点如下：

①Create stand-alone Spring applications.

解释：创建一个独立spring应用（用SpringBoot实际上还是用spring，SpringBoot是一个高级框架，实际上底层是Spring）。

②Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files).

解释：内嵌Web服务器，如：Tomcat、Jetty或Undertow服务器（无需部署WAR文件）。

③Provide opinionated 'starter' dependencies to simplify your build configuration.

解释：提供了starter起步依赖，简化应用的配置。比如：使用MyBatis框架 ， 需要在Spring项目中，配置MyBatis的对象 SqlSessionFactory ， Dao的代理对象等；现在在SpringBoot项目中，在pom.xml里面, 只需要加入一个 mybatis-spring-boot-starter依赖，就表示上面两个等配置已经配置好了。

④Automatically configure Spring and 3rd party libraries whenever possible.

解释：自动配置Spring以及第三方功能（就是把spring中的，第三方库中的对象都提前创建好，放到容器中， 可以直接使用）。

⑤Provide production-ready features such as metrics, health checks, and externalized configuration

解释：提供生产级别的监控，健康检查及外部化配置（以前修改了代码需要重新打包部署，现在可以实时监控变化）。

⑥Absolutely no code generation and no requirement for XML configuration

解释：不用生成代码， 不用使用xml做配置。

3. 如何学习SpringBoot

SpringBoot的官方文档查找：Spring Boot

SpringBoot的官网架构：

查看版本更新了什么新特性： Home · spring-projects/spring-boot Wiki · GitHub

4. 创建Spring Boot项目

Maven的配置

找到Maven的配置文件的settngs.xml配置，C:\dev\maven_work\apache-maven-3.3.9\conf\settings.xml，配置成阿里云的镜像和JDK编译的版本。

      
        nexus-aliyun
        central
        Nexus aliyun
        http://maven.aliyun.com/nexus/content/groups/public
      
  
 
  
         
              jdk-1.8
              
                true
                1.8
              
              
                1.8
                1.8
                1.8
              
         
  

第一种方式：https://start.spring.io，使用国外的地址，必须联网

①新建项目

②设置基本信息

③选择依赖的列表

④项目的结构

⑤生成的pom.xml配置

    4.0.0
    
    
        org.springframework.boot
        spring-boot-starter-parent
        3.0.3
        
    
    
    com.zl
    study-springboot-002
    0.0.1-SNAPSHOT
    study-springboot-002
    study-springboot-002
    
    
        1.8
    
    
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
    
    
        
            
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

第二种方式：https://start.springboot.io，使用国外的地址，必须联网，创建项目的步骤同上

①对于其他版本的高版本的IDEA是以下界面

②也可以在浏览器上直接输入https://start.springboot.io 进行设置

③选择好以后，点击生成GENERATE，会下载一个压缩包

④解压这个压缩包，就可以把项目导进去

第三种方式：使用 maven 向导创建项目

根据官方文档的提示：Getting Started

①创建一个普通的Maven项目

②手动添加父parent和web的依赖

添加父依赖：spring-boot-start-parent作为【版本仲裁中心】 统一控制导入依赖的版本信息。

web的依赖：spring-boot-start-web用来写web项目的起步依赖。

    4.0.0
    com.zl
    study-springboot-004
    1.0.0
    jar
    
    
        org.springframework.boot
        spring-boot-starter-parent
        3.0.3
        
    
    
    
        
            org.springframework.boot
            spring-boot-starter-web
        
    
    
        8
        8
    

③手动添加项目缺失的目录

入门案例：

第一步：创建一个SpringBoot的web工程项目

第二步：创建一个Controller，发出请求

注：在使用springmvc框架的时候，在处理json的时候需要用到spring框架特有的注解@ResponseBody或者@RestController注解，这两个注解都会处理返回的数据格式，使用了该类型注解后返回的不再是视图，不会进行转跳，而是返回json或xml数据格式，输出在页面上。

①@ResponseBody注解，一般是使用在单独的方法上的，需要哪个方法返回json数据格式，就在哪个方法上使用，具有针对性。

②@RestController复合注解，一般是使用在类上的，它表示的意思其实就是结合了@Controller和@ResponseBody两个注解，如果哪个类下的所有方法需要返回json数据格式的，就在哪个类上使用该注解，具有统一性；需要注意的是，使用了@RestController注解之后，其本质相当于在该类的所有方法上都统一使用了@ResponseBody注解，所以该类下的所有方法都会返回json数据格式，输出在页面上，而不会再返回视图。

package com.zl.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
// 以下两个注解写成一个
@RestController
// @Controller // 类要想当做controller使用，就添加这个注解
public class HelloSpringBoot {
    @RequestMapping("/hello")
    // @ResponseBody // 把返回的String字符串当做数据来用，返回给浏览器
    public String helloSpringBoot(){
        return "欢迎使用SpringBoot！";
    }
}

第三步：启动入口类

（1）这个类是自动生成的，也可以自己创建；使用@SpringBootApplication注解就表明这是一个SpringBoot项目！

（2）在类中编写main方法，方法中只写一行代码，调用SpringApplication类的静态run()方法，表示主方法跑起来：参数一个是当前类的.class、一个是主方法中的参数args。

注：这个类的执行会启动内置的Tomcat服务器！

package com.zl;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

第四步：进行访问

这里的端口号还可以在application.properties中进行更改

第五步：创建一个可执行的jar包（简化了部署）

默认的打包方式是jar包，对于web应用我们需要写上打包方式为war包，然后部署到Tomcat服务器上进行应用。现在可以通过一个插件直接就打成jar包，进行运行！

    
        
            org.springframework.boot
            spring-boot-maven-plugin
        
    

①找到生命周期进行打包

②得到以下.jar文件

③找到.jar文件的位置，使用cmd命令行执行打包的jar文件

④ 使用java -jar *.jar就可以运行

SpringBoot中几个重要的注解

①@SpringBootApplication注解： @SpringBootApplication注解其实是一个复合注解，是由 @SpringBootConfiguration注解、@EnableAutoConfiguration注解、@ComponentScan 联合在一起组成的；从源码中就可以看出：

②@SpringBootConfiguration注解： 这个注解就是@Configuration这个注解的功能，使用@SpringBootConfiguration这个注解的类就是当做配置文件作用，从源码中就可以看出：

注：既然有@Configuration功能，结合@Bean注解，就可以把一个对象放到Spring容器当中 

package com.zl;
import com.zl.controller.Student;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    // 声明对象，把这个对象注入到Spring容器当中
    @Bean
    public Student myStudent(){
        return new Student();
    }
}

③@EnableAutoConfiguration注解：启用自动配置， 把java对象配置好，注入到spring容器中。例如：可以把mybatis的对象创建好，放入到容器中。

④@ComponentScan注解：组件扫描器， 扫描注解，根据注解的功能，创建java bean，给属性赋值等。组件扫描器默认扫描的包是 @ComponentScan 注解所在的类， 类所在的包和子包。 所以对于带有@SpringBootApplication注解的入口类Application建议放在主包下！

5. 了解自动配置原理

依赖管理

例如：我们引入父依赖后并写上版本号，后面在引入其它依赖（实际上采用了自动版本仲裁机制），就不需要写版本号，此时就是父依赖作为依赖管理！

 
    org.springframework.boot
    spring-boot-starter-parent
    2.3.4.RELEASE
  
  
  
    
      org.springframework.boot
      spring-boot-starter-web
    

实际上spring-boot-start-parent的父项目是spring-boot-dependencies

 
    org.springframework.boot
    spring-boot-dependencies
    2.3.4.RELEASE
  

点进去spring-boot-dependencies找到properties属性几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制！

    5.15.13
    2.7.7
    1.9.82
    2.12.0
    1.9.6
    3.16.1
    4.0.6
    4.0.3
    2.1.4
    3.1.0
    1.10.14
    2.8.5
    4.6.1
    1.5.1
    1.14
    2.7.0
    3.10
    1.6
    2.8.1
    3.0.8
    11.5.4.0
    1.0.10.RELEASE
    10.14.2.0
    4.1.12.1
    2.10.6
    3.8.1
    7.6.2
    2.2.0
    1.6.0
    1.2.5
    6.4.4
    2.3.30
    3.0.1
    3.0.3
    2.3.3
    2.5.13
    2.8.6
    1.4.200
    2.2
    3.12.9
    1.3.2
    5.4.21.Final
    6.1.5.Final
    3.4.5
    2.5.1
    2.40.0
    4.1.4
    4.5.12
    4.4.13
    10.1.8.Final
    2.18
    2.11.2
    1.2.2
    1.3.5
    2.0.3
    1.1.6
    1.0.2
    1.6.5
    2.2.3
    4.0.4
    1.2.7
    1.3.3
    2.0.2
    1.1.2
    2.1.6
    2.3.3
    1.4.2
    2.3.3
    3.1.2
    1.2.0
    1.3.2
    1.1.1
    2.3.1
    2.3.1
    2.0.1
    1.1.4
    1.0
    1.6.2
    1.0.3
    2.2
    1.3
    2.0.1.Final
    1.1
    1.2.0
    3.0.9
    3.4.1.Final
    7.6.0.Final
    2.0.6
    3.3.0
    2.30.1
    8.5.54
    2.2.0.v201112011158
    1.1.4
    9.4.31.v20200723
    1.15
    1.2.8
    1.6.2
    3.13.4
    2.4.0
    2.3
    1.5.0
    1.2
    1.3.1
    4.13
    5.6.2
    2.5.1
    1.3.72
    1.3.8
    5.3.4.RELEASE
    3.8.9
    2.13.3
    1.2.3
    1.18.12
    2.6.2
    1.8
    3.3.0
    3.1.0
    3.8.1
    3.1.2
    2.8.2
    3.0.0-M3
    2.22.2
    3.2.0
    2.5.2
    3.2.1
    3.2.0
    3.2.0
    3.1.0
    3.2.4
    3.2.1
    2.22.2
    3.2.3
    1.5.5
    1.9.13
    3.3.3
    4.0.5
    7.4.1.jre8
    8.0.21
    1.9.22
    3.2.16
    4.1.52.Final
    2.0.34.Final
    1.1.0
    7.1.1
    8.19
    19.3.0.0
    3.14.9
    19.3.0.0
    1.1.2
    42.2.16
    0.9.0
    2.3.2
    4.3.1
    Arabba-SR7
    5.9.0
    1.0.3
    Dysprosium-SR12
    3.3.0
    1.0.2
    1.3.8
    1.2.1
    2.2.19
    1.5.2
    3.141.59
    2.40.0
    4.4.8
    4.0.1
    1.7.30
    1.26
    8.5.2
    2.2.11.RELEASE
    4.2.4.RELEASE
    Neumann-SR4
    5.2.9.RELEASE
    1.1.2.RELEASE
    5.3.2.RELEASE
    2.5.6.RELEASE
    2.3.3.RELEASE
    2.0.5.RELEASE
    1.2.5.RELEASE
    5.3.4.RELEASE
    Dragonfruit-SR1
    3.0.10.RELEASE
    3.31.1
    1.6.5
    3.0.11.RELEASE
    2.0.1
    3.0.4.RELEASE
    3.0.4.RELEASE
    2.4.1
    9.0.38
    4.0.14
    2.1.4.Final
    2.7
    3325375
    0.45
    1.6.3
    1.0.2
    2.7.0
  

如果此时需要换版本号怎们办呢？

查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。就是用上面的properties标签对应的属性进行重写；实际上使用的是就近原则！

    
        5.1.43
    

开发导入starter场景启动器

（1）见到很多 spring-boot-starter-* ： *就某种场景；官方的启动器，只要引入starter，这个场景的所有常规需要的依赖我们都自动引入！SpringBoot所有支持的场景：Developing with Spring Boot

（2）见到的  *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。

（3）所有场景启动器（start）最底层的依赖是spring-boot-start

    
      org.springframework.boot
      spring-boot-starter
      2.3.4.RELEASE
      compile
    

自动配置

我们直接执行启动类就可以访问，实际上是自动进行了一系列的配置！

①自动配好Tomcat

（1）引入Tomcat依赖；

（2）配置Tomcat；

②自动配好SpringMVC常见功能，如：前端控制器DispatcherServlet、字符编码问题CharaterEncodingFilter、视图解析器ViewResolver

（1）引入SpringMVC全套组件；实际上启动类的SpringBootApplication类的静态方法放回的是IOC容器，通过这个IOC容器的getBeanDefinitionNames方法就可以查看容器里面的组件！

（2）自动配好SpringMVC常用组件（功能）；

package com.zl;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        // 实际上返回的是IOC容器
        ConfigurableApplicationContext applicationContext = SpringApplication.run(MyApplication.class, args);
        // 查看容器里面的组件
        String[] names = applicationContext.getBeanDefinitionNames();
        for (String name : names) {
            System.aout.println(name);
        }
    }
}

③默认的包结构

（1）主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来，不需要以前的包扫描配置；

（2）要想改变扫描路径，使用@SpringBootApplication注解的scanBasePackages属性去指定(scanBasePackages="com.zl")，或者使用@ComponentScan注解指定扫描路径；

（3）@SpringBootApplication是一个复合注解等同于以下三个注解：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.zl")

④按需加载所有自动配置项

（1）在实际上开发中有非常多的场景（start），引入了哪些场景这个场景的自动配置才会开启；

（2）SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面；

6. SpringBoot核心配置文件

配置文件名称是：application，扩展名有：properties、yml；例如：application.properties或者application.yml。

注：使用properties扩展名配置是key=value的格式，使用yml扩展名配置是key:value的格式

第一步：创建一个controller

package com.zl.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class SpringController {
    @RequestMapping("/spring")
    @ResponseBody
    public String doSome(){
        return "hello SpringBoot";
    }
}

第二步：创建启动类，对于启动类我们可以删除自动生成的，自己手写一个

①类名随意，里面有一个主方法，在主方法中调用SpringApplication的run方法，一个参数是本类.class，另一个参数是上面main方法的参数args。

②给本类增加上@SpringBootApplication注解。

package com.zl;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class,args);
    }
}

第三步：使用application.properties/yml配置文件，配置端口号、上下文的路径等

①采用默认的

②自己进行配置application.properties，#代表注释

#设置端口号
server.port=8082
#设置访问应用上下文路径，contextpath
server.servlet.context-path=/myboot

 ③使用yml的配置方式，application.yml

yml是一种yaml格式的配置文件，主要采用一定的空格、换行等格式排版进行配置。 yaml是一种直观的能够被计算机识别的的数据序列化格式，容易被人类阅读，yaml 类似于xml，但是语法比xml 简洁很多，值与前面的冒号配置项必须要有一个空格， yml 缀也可以使用 yaml 后缀。

server:
  port: 8082
  servlet:
    context-path: /myboot

注意： 当两种格式配置文件同时存在，默认使用的是properties，在SpringBoot2.4开始，使用的是yml配置文件，推荐使用 yml格式配置文件。

多环境测试

在实际开发的过程中，我们的项目会经历很多的阶段（开发->测试->上线），每个阶段的配置也会不同，例如：端口、上下文根、数据库等，那么这个时候为了方便在不同的环境之间切换，SpringBoot 提供了多环境配置，具体步骤如下：

注：为每个环境创建一个配置文件，命名必须以application-环境标识.properties或yml！ 

开发环境application-dev.properties：

#配置端口号
server.port=8081
#配置应用根路径
server.servlet.context-path=/mydev

测试环境application-test.properties：

#配置端口号
server.port=8082
#配置应用根路径
server.servlet.context-path=/mytest

上线环境application-onlion.properties：

#配置端口号
server.port=8083
#配置应用根路径
server.servlet.context-path=/myonlion

在application.properties中指定要使用的配置文件

#激活使用哪个配置文件
spring.profiles.active=dev
spring.profiles.active=test
spring.profiles.active=onlion

自定义配置

（1）@Value注解

注：在application.properties中添加自定义的配置项，然后在类中需要时，使用@Value(${变量名})注解进行引入。

application.properties配置

#配置端口号
server.port=8082
#context-path
server.servlet.context-path=/myboot
#自定义key=value
school.name=大连大学
school.website=www.baidu.com
school.address=辽宁省大连市
site=www.sina.com.cn

在controller中联合@Value注解获取数据

注：这例也可以使用@ConfigurationProperties注解指定配置的前缀，后缀与实体类的属性名相同也可以完成属性的赋值。

package com.zl.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class DataController {
    // 定义变量接收赋值
    @Value("${server.port}")
    private Integer port;
    @Value("${server.servlet.context-path}")
    private String contextPath;
    // 自定义的
    @Value("${school.name}")
    private String name;
    @Value("${site}")
    private String site;
    @RequestMapping("/data")
    @ResponseBody
    public String queryData(){
        return name+","+site+",项目访问的地址"+contextPath+",使用的端口"+port;
    }
}

执行结果：

（2）@ConfigurationProperties注解

前面我们是一个个取出值，现在我们将整个文件映射成一个Java对象，用于自定义配置项比较多的情况！ 

工作原理：定义一个类使用@ConfigurationProperties注解，并指定前缀prefix，它会根据这个前缀到配置中找以这个前缀开头的属性；如果以这个前缀开头的后面的属性与我们定义的Java对象的属性相同就赋上值！

定义一个School类

关键点：配置文件的数据与School类中的属性怎么对应上？

使用@ConfigurationProperties注解，指定一个前缀！

package com.zl.vo;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component // 创建对象
@ConfigurationProperties(prefix = "school") // 把school开头的配置项找出来
public class School {
    private String name;
    private String website;
    private String address;
    public School() {
    }
    public School(String name, String website, String address) {
        this.name = name;
        this.website = website;
        this.address = address;
    }
    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", website='" + website + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getWebsite() {
        return website;
    }
    public void setWebsite(String website) {
        this.website = website;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

进行测试：

package com.zl.controller;
import com.zl.vo.School;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
@Controller
public class DataController {
    @Resource // 赋值
    private School school;
    @RequestMapping("/school")
    @ResponseBody
    public School querySchool(){
        return school;
    }
}

执行结果：

实际上还有一个报错信息，让我们添加一个依赖，当然不添加也不影响的项目的正常运行

 添加以下依赖

    org.springframework.boot
    spring-boot-configuration-processor
    true

7. SpringBoot中使用JSP（了解）

SpringBoot不推荐使用jsp ，而是使用模板技术代替jsp，作为视图来使用！

使用jsp需要配置：

①加入一个处理jsp的依赖， 负责编译jsp文件

    org.apache.tomcat.embed
    tomcat-embed-jasper

②如果需要使用servlet， jsp，jstl的功能，还需要加对应的依赖

	javax.servlet
	jstl


	javax.servlet
	javax.servlet-api


javax.servlet.jsp
	javax.servlet.jsp-api
	2.3.1

③在resources下创建一个存放jsp的目录，一般叫做webapp，这个目录默认是不能创建jsp文件，需要我们手动更改webapp目录的属性

编写index.jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


使用jsp显示Controller中的数据${data}

④需要在pom.xml指定jsp文件编译后的存放目录；META-INF/resources（固定的）

    
        
        
            
                
                src/main/webapp
                
                META-INF/resources
                
                
                    
                    **/*.*
                
            
        
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

⑤创建Controller， 访问jsp

package com.zl.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
@Controller
public class JspController {
    // 方法一：使用HttpServletRequest对象
    /*public String doJsp(HttpServletRequest request){
        request.setAttribute("data","SpringBoot使用JSP进行显示");
        // 返回视图的逻辑名称
        return  "index";
    }*/
    // 方法二：使用Model对象
    @RequestMapping("/myjsp")
    public String doJsp(Model model){
        model.addAttribute("data","SpringBoot使用JSP进行显示");
        // 返回视图的逻辑名称
        return  "index";
    }
}

⑥在application.propertis文件中配置视图解析器

#配置端口号
server.port=9090
#配置context-path
server.servlet.context-path=/myboot
#配置视图解析器
# / 就是src/main/webapp
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

8. SpringBoot中使用ApplicationContext（上下文对象）

怎么使用容器对象？要想从容器中获取对象，通过SpringApplication.run(Application.class, args); 返回值获取容器，返回值类型是什么呢？通过源码分析：

先定位到SpringApplication的run方法

run方法的返回值是ConfigurableApplicationContext接口

ConfigurableApplicationContext接口继承ApplicationContext接口

 所以run方法的返回值其实就是一个ApplicationContext容器（Spring容器中创建ClassPathXmlApplicationContext对象时，返回的结果就是ApplicationContext[是ClassPathXmlApplicationContext的父类]，然后调用getBean方法就能获取对象）！

案例：在main方法中使用SpringApplication.run()方法获取返回的Spring容器上下文对象，再调用getBean()方法进行调用！

创建一个UserService 接口：

package com.zl.service;
public interface UserService {
    void sayHello(String name);
}

编写UserService接口的实现类：

package com.zl.service.impl;
import com.zl.service.UserService;
import org.springframework.stereotype.Service;
@Service("userService") // 交给Spring容器管理
public class UserServiceImpl implements UserService {
    @Override
    public void sayHello(String name) {
        System.out.println("对"+name+"说sayHello");
    }
}

在入口方法中取出被Spring容器管理的UserServiceImpl 类：

package com.zl;
import com.zl.service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // 返回一个ConfigurableApplicationContext接口容器或者父接口的
        // ConfigurableApplicationContext cac = SpringApplication.run(Application.class, args);
        ApplicationContext cac = SpringApplication.run(Application.class, args);
        // 调用getBean方法，获取交给Spring容器管理的对象
        UserService userService = cac.getBean("userService", UserService.class);
        // 方法的调用
        userService.sayHello("张三");
    }
}

执行结果：

9. CommandLineRunner接口 & ApplicationRunner接口

（1）开发中可能会有这样的情景：需要在容器启动后执行一些内容；比如：读取配置文件，数据库连接之类的；SpringBoot 给我们提供了两个接口来帮助我们实现这种需求，这两个接口分别为CommandLineRunner 和 ApplicationRunner，它们的执行时机为容器启动完成的时候（容器对象创建好后，自动执行run方法）。

（2）这两个接口中有一个run()方法，我们只需要实现这个方法即可。

（3）这两个接口的不同之处在于：ApplicationRunner中run()方法的参数为ApplicationArguments，而CommandLineRunner接口中run方法的参数为String 数组。

ApplicationRunner接口

package org.springframework.boot;
@FunctionalInterface
public interface ApplicationRunner {
    void run(ApplicationArguments args) throws Exception;
}

CommandLineRunner接口

package org.springframework.boot;
@FunctionalInterface
public interface CommandLineRunner {
    void run(String... args) throws Exception;
}

案例：

编写SomeService接口

package com.zl.service;
public interface SomeService {
    String doSome(String name);
}

编写SomeService接口的实现类SomeServiceImpl 

package com.zl.service.impl;
import com.zl.service.SomeService;
import org.springframework.stereotype.Service;
@Service("someService") // 交给Spring容器管理
public class SomeServiceImpl implements SomeService {
    @Override
    public String doSome(String name) {
        return  name+"----》去打篮球了！";
    }
}

让启动口类Application实现CommandLineRunner接口，并重写run()方法

package com.zl;
import com.zl.service.SomeService;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@SpringBootApplication
public class Application implements CommandLineRunner {
    @Resource // 下面容器创建好以后就会给属性赋值
    private SomeService someService;
    public static void main(String[] args) {
        System.out.println("准备创建容器对象"); // 1
        // 创建容器对象
        SpringApplication.run(Application.class, args);
        System.out.println("容器对象创建好之后"); // 3
    }
    @Override
    public void run(String... args) throws Exception {
        // 在这个run方法里做自定义的操作
        System.out.println("容器对象创建好，马上执行的！"); // 2
        // 调用容器中对象的方法
        // 在这里执行，已经保证1的容器对象创建好了
        String str = someService.doSome("张大傻");
        System.out.println(str);
    }
}

执行顺序结果：

图书推荐：集齐“Java四大名著”召唤神龙

Java 28岁了，当打之年，并且还会打很多年。为即将或正在使用Java的你推荐Java“此生错过必遗憾”系列书单。看看你还缺哪本？请补齐。优惠购书链接就在文中，拿好不谢！

1. Java核心技术第12版开发基础+高级特性

“Java四大名著”之一Core Java最新版，一键打包全套2册！建议入门小白和准备升级到Java17的开发者购买。本书根据Java17新特性全面升级！赠送作者亲授视频课+海量代码集。

限时秒杀链接：点击购买

2. Java核心技术第11版基础知识+高级特性

“Java四大名著”之一Core Java次新版，一键打包全套2册！建议实际生产环境仍在使用Java8、Java11开发且暂时没有升级版本打算的开发者购买。本书基于Java9-11编写，赠送作者亲授视频课+海量代码集。

限时秒杀链接：点击购买

3. Java编程思想[Thinking in Java]

“Java四大名著”之一，需要有一定编程基础的人才可阅读，即使很多内容还无法理解，但每次读完一定会有所收获。本书单最前面推荐的《Java核心技术》侧重技术，而《Java编程思想》侧重于“思想”，本书为你剖析Java中各个内容的设计理念。这是一本伴随我们技术成长的好书，买一本放在旁边，摸着就有底气。

限时秒杀链接：点击购买

4. Effective Java 中文版（原书第3版）

 “Java四大名著”之一，适合已经掌握Java核心技术的程序员，想更加深入地了解Java编程语言的开发者阅读。针对如何编写高效、设计优良的程序提出了最实用、最权威的指导方针，通过90条简短、独立的经验法则，探索新的设计模式和语言习惯用法，帮你更加有效地使用Java编程语言及其基本类库，指引你少走弯路。这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。是Java开发人员案头上的一本不可或缺的参考书。

限时秒杀链接：点击购买

5. Java语言程序设计基础篇+进阶篇

本套书相较于《Java核心技术》更加的基础，如果你阅读《Java核心技术》有些吃力，建议从本书读起。畅销20余年的“长城书”一键打包全套！被世界各地的大学选作教材，更新至Java9、10和11。本书通过示例讲解问题求解技巧，提供大量的程序清单，每章配有丰富的复习题和编程练习题，帮助读者掌握编程技术并解决实际开发中遇到的问题。

限时秒杀链接：点击购买

6. Java并发编程实战

让注重实战的你更快领悟Java并发编程的要领，快速构建大规模并发应用程序。“Java四大名著”之一《Effective Java》的作者Joshua Bloch参与编写。本书是Java并发编程领域的里程碑著作！从并发编程的基本理论入手，逐步介绍了在设计Java并发程序时各种重要的设计原则、设计模式与思维模式。另一本蚂蚁金服方腾飞老师写的《Java并发编程的艺术》也适合一并阅读。

限时秒杀链接：点击购买

7. 软件架构实践

让你少走弯路的进阶架构师避坑指南！图书届奥斯卡Jolt大奖双冠王作品！全球10余个国出版。卡内基梅隆等名校教材，IEEE杂志10佳图书，软件架构图书事实标准。

 

限时秒杀链接：点击购买

以上图书当当网全部限时秒杀，满100-50，买的越多，优惠越多！了解更多好书点击：Core Java 全面升级！