SpringBoot-01-快速开始和自动配置

SpringBoot 快速开始

导包

SpringBoot 项目只需要一个普通的 Maven 项目就可以了。我们是通过运行 SpringBoot 的 SpringApplication.run() 方法，来让 SpringBoot 控制整个项目的。

首先我们需要将在 Maven 中引入包含了大量依赖信息的 SpringBoot parent（继承信息），和我们要进行 Web 开发的 starter （真正的引入依赖下载 jar 包）

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.3</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

也就是 parent 引入保存的各种开发场景对应的依赖需求集合，我们在 dependencies 真正的引入这些依赖的时候，就不需要一个个写了，直接调用依赖集合名就好了。

然后我们就能看到所有关于 web 开发的 jar 包就都被导入了，包括 tomcat。这些 jar 包的集合被 SpringBoot 叫作一个 starter，开始集合。

让 SpringBoot 接管项目

就像配置 DispatcherServlet 让 SpringMVC 接管业务流程一样，这里是让 SpringBoot 直接从根本接管所有东西，不仅仅是业务流程，包括了 Tomcat 的创建。

只需要创建一个方法，在 main 方法中运行 SpringBoot 的启动程序，SpringApplication.run()，参数就是这个类本身的 class 和输入的参数，当然这个类也需要用注解标记为 SpringBoot 启动类。要运行整个项目的时候，就直接运行 main 方法即可。

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

开始写业务逻辑

剩下的部分就是按照 SpringMVC 的形式写了，不用管配置啥的，直接各种注解随便用：

//Controller 和 RequestBody 的结合，意思为用来实现 rest 风格的 Controller
@RestController 
public class HelloController {
    @RequestMapping("/hello")
    public String handle01() {
        return "Hello SpringBoot!";
    }
}

更改配置

SpringBoot 因为一个人就接管了整个项目，所以可以将整个项目的所有配置都简化到一个文件中： application.properties ，这个文件可以改所有的配置。

比如将端口号改为 8888，只需要在 application.properties 中写下即可：

1	servet.port=8888

而在 application.properties 里面的各种配置信息提示需要将配置处理器 Springboot-configurationg-processor 引入依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

然后在 maven 插件配置的地方设置打包去除到这个 processor ，因为只是支持配置提示，也不需要打包成运行环境。

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <version>2.5.3</version>
    <configuration>
        <excludes>
            <exclude>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
            </exclude>
        </excludes>
    </configuration>
</plugin>

开始部署

以前部署是打包成 war 包，放到服务器的 Tomcat 环境上面的，现在因为所有的东西都被 SpringBoot 管理，所以只需要让 SpringBoot 跑起来就可以了。

那么我们就可以将项目打包成一个可以运行 main 方法的 jar 包即可。（main 方法负责启动 SpringBoot）

我们是用 Maven 进行打包的，先引入 SpringBoot 关于 Maven 的打包插件：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.5.3</version>
        </plugin>
    </plugins>
</build>

然后运行（注意 IDEA 需要停止运行当前的 SpringBoot 防止端口占用）

java -jar SpringBoot-1.0-SNAPSHOT.jar

SpringBoot 依赖管理

原理

SpringBoot 一个让我们省心的就是它的 starter 直接配齐了所有的生产环境。starter 的实现就是依靠 SpringBoot 的依赖管理，什么样的生产环境需要什么依赖，以及依赖的版本号，都被记录在 spring-boot-starter-parent 中。

版本更改

依赖的具体版本是通过在 SpringBoot 的依赖管理中的 <properties></properties> 标签中定义好的：

<!--截取一部分-->
<jstl.version>1.2</jstl.version>
<jtds.version>1.3.1</jtds.version>
<junit.version>4.13.2</junit.version>
<junit-jupiter.version>5.7.2</junit-jupiter.version>
<kafka.version>2.7.1</kafka.version>

我们要更改它的版本只需要在 Maven 中配置 <properties></properties> 中设置具体的版本即可，比如想要文艺复兴，使用 8.0.1 的 tomcat，改就完事了：

1
2
3

<properties>
    <tomcat.version>8.0.1</tomcat.version>
</properties>

SpringBoot 自动配置

组件配置

以前我们要引入很多的组件，比如 DispatcherServlet，CharacterEncoding 等等，现在使用了 SpringBoot 之后就不需要写了，这是因为 SpringBoot 会自动将一整套的开发环境预设到 IOC 容器中，SpringApplication.run(MainApplication.class, args) 的返回结果就是这个 IOC 容器。

包扫描

SpringBoot 会扫描标注了 @SpringBootApplication 的启动类以下的所有子包：

com
 +- example
     +- myapplication
         +- Application.java //下面的 customer 和 order 两个包都会被扫描注解
         |
         +- customer
         |   +- Customer.java
         |   +- CustomerController.java
         |   +- CustomerService.java
         |   +- CustomerRepository.java
         |
         +- order
             +- Order.java
             +- OrderController.java
             +- OrderService.java
             +- OrderRepository.java

所以我们才不需要配置扫描的包。但如果真的想要配置，在 @SpringBootApplication 添加属性：scanBasePackages = "space.xorex" 。

配置信息

SpringBoot 所有场景的默认配置信息都在 spring-boot-autoconfigure 里面：

容器功能

添加容器

Spring 一个重要功能就是 IOC ，那么到了 SpringBoot，如何使用 IOC 容器呢？

@Configuration 用来标注表示这是一个配置类，然后对方法 @Bean 表示这是一个 Bean 配置，方法名就是 id，返回的结果就是配置 Bean 获取的结果。

这样成功将 id=userXorex 的 User 实例添加到了 IOC 容器中，默认为 单实例对象 。

@Configuration
public class MyConfig {
    @Bean
    public Uesr userXorex() {
        return new Uesr("Xorex","Tempest");
    }
    @Bean
    public Address xorexAddress() {
        return new Address("ChengDu");
    }
}

实例获取

因为上面写过之后两个 bean 都被加入了单例的 IOC 中，所以自然可以用 @Autowired 来获取单例 bean 的实例：

@Autowired
static Uesr user1;
@Autowired
static Uesr user2;
System.out.println(user1==user2);//true

但是还有另外一种获取方法，就是调用 MyConfig 里面的方法返回 bean 实例。当我们的 @Configuration 配置的为默认： proxyBeanMethods=true 的时候，也就是使用代理获取对象的时候，在外部获取的都是容器中的单例 Bean：

MyConfig config=run.getBean(MyConfig.class); 
//从 IOC 中拿到 Config，此时的 proxyBeanmethods=true ，也就是 Config IOC 代理了，返回的实例是从 IOC 容器中拿出来的。
Uesr user1=config.userXorex(); // 从 Config 中返回 bean
Uesr user2=config.userXorex();
System.out.println(user1==user2); //true

当我们将 proxyBeanMethods=false 的时候，上面从 IOC 中取出来的 MyConfig 就是普通类了（等同于 new 出来一个普通的 MyConfig），调用方法返回的 bean 也是方法里面 new 出来的，就不是 IOC 控制的单例对象了。

快速添加

可以使用 @Import({XXX1.class,XXX2.class}) 快速将两个类 XXX1 和 XXX2 的无参构造器的实例放入 IOC 容器中，id 就是这个类的全类名。

配置绑定

这里的配置绑定指的是将 application.properties 中的配置信息和 IOC 容器中的 Bean 的属性相绑定。

比如我们将配置文件中的 info.xxx 配置于 Info 类中的属性 xxx 相绑定，只需要在 @ConfigurationProperties

1. @Component + @ConfigurationProperties

@Component
@ConfigurationProperties(prefix = "info")
public class Info {
    private String name;
}

2. @ConfigurationProperties + @Bean

第二种主要适用于对第三方包里面的类进行属性设置：

@Bean //加入到 IOC 容器中
@ConfigurationProperties(prefix = "info") //添加配置映射信息
public Info info() {
    return new Info();
}