Spring Boot

Spring Boot是什么

Spring Boot是一套基于Spring框架的微服务框架。

Spring Boot框架出现的背景

由于Spring是一个轻量级的企业开发框架，主要的功能就是用于整合和管理其他框架。

但随着整合的框架越来越多，Spring的整合配置也日益繁琐。在这个情况下，Spring团体有了一个想法：就是将平时主流使用到的框架的整合配置预先写好，然后通过简单的几个参数就可以实现框架的快速整合。

这个想法催生Spring boot框架。

我们将这个实现了各种主流框架与Spring的自动整合的框架。

 Spring Boot的作用是什么

就是大大减少了Spring与其他框架整合的代码，也实现了Spring开发的Web应用的快速部署。

Spring Boot的特点

1.实现了各种主流的框架的快速整合

2.实现了Spring的应用的快速部署，使用Spring Boot的Web应用可以以Jar的方式部署。

Spring Boot学习的前提

1.由于Spring Boot的最小配置都是基于SpringMVC框架的，所以学习Spring Boot先要有Spring和SpringMVC框架的基础。

2.SpringBoot默认不推荐使用JSP视图，官方推荐使用Thymeleaf或者Freemarker模板引擎。本文档没有对这两个模板引擎作详细介绍。

3.SpringBoot使用了Maven 或者Gradle管理需要的jar包，没有提供zip压缩包的发布形式，所以学习SpringBoot必须要学习Maven或者Gradle构建工具，现在主流使用的是Maven，所以学习Maven就可以了。

4.Spring Boot中可以使用Spring框架的所有注解。如果没有学过纯注解Spring框架配置，需要先学习Spring纯注解的配置。

所谓的纯注解：就是一个Spring配置文件都没有的配置。

涉及Spring框架的纯注解配置类常用注解如下：

注解名	说明
@Configuration	声明一个配置类，配置类的功能等同spring的配置文件（重点）
@Bean	将没有声明 @Component/@Controller/@Serivce/@Repository的类加入到Spring容器 等同于Spring配置文件的<bean>标签
@PropertySource	在Spring的配置里读取，增加的这个注解，可以使用@Value注解获得properties文件的内容
@Value	获得上下文中，Properties文件的内容 等同与Spring配置文件的 ${key}
@ComponentScan	用于扫描类，创建对象到Spring容器中 等同Spring配置文件 <context:component-scan>
@ConditionalOnMissingBean	表示如果Spring容器已经有该类的对象就不执行创建对象的方法再创建一次了(单列)。

1.6. Spring Boot准备工具

学习Spring Boot建议使用Eclipse安装STS插件或者直接使用STS开发工具。

下载官网：https://spring.io/tools/sts

1.7. 参考资料

本文档编写参考了

1.SpringBoot官方参考文档，地址如下：

https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started

2.spring boot 官方案例，地址如下：

https://github.com/spring-projects/spring-boot

2. Spring Boot的入门

2.1. 简单配置入门

2.1.1. 配置流程

1.新建一个maven项目

2.填写创建项目的信息，注意使用jar的方式创建项目就可以

3.到spring boot官方复制pom的依赖到pom.xml文件

网站地址为: https://start.spring.io/

pom.xml文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <!-- SpringBoot的核心依赖 包 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.21.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <!-- 自己项目内容 -->
    <groupId>cn.sxt</groupId>
    <artifactId>spring_boot01</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring_boot01</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>
    
<!-- springBoot对 SpringMVC的集成依赖-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
<!--  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <!--  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
<!--  -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

4.编写一个简单的Java类

package hello;
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;

//声明@Controller存储类型注解,表示SampleController类启动是,对象会加载到Spring容器
@Controller
//声明@EnableAutoConfiguration,表示程序使用Springboot默认的配置
@EnableAutoConfiguration
public class HelloController {
    /**
     * 表示如果访问路径/,返回字符串Hello World!
     */
    @RequestMapping("/hello")
    @ResponseBody
    String home() {
        return "Hello World!";
    }
    public static void main(String[] args) throws Exception {
        //启动Spring Boot程序
        SpringApplication.run(SampleController.class, args);
    }
}

5.启动

 注意事项

maven是需要联网下载的jar包的。注意一下网络是否畅通。

 

 

使用@SpringBootApplication注解配置

上面的示例有一个问题，代码如下：

 SpringApplication.run(SampleController.class, args);

启动的Controller只有一个，如果一个项目需要将多个类扫描到Spring的容器中如何解决呢？

答：使用@SpringBootApplication注解来配置。

 入口类使用@SpringBootApplication注解，启动项目时，SpringBoot框架会扫描入口类的加了@SpringBootApplication注解的入口类的同级目录和子目录的组件类的对象到Spring容器。

1.在cn.zj.springboot文件夹下创建一个入口类Application.java

package cn.sxt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
public class Application {
    public static void main(String[] args) {
        /*
         * SpringApplication
         * SpringBoot的启动类，执行run方法 读取当前
         * Application 上面的注解对应的配置，启动SpringBoot框架
         */
        SpringApplication.run(Application.class, args);
    }
}

1.创建一个Controller,业务控制器

package cn.sxt.controller;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
//把对象交给spring框架
@Controller
//声明@EnableAutoConfiguration,表示程序使用Springboot默认的配置（早期使用，下面有更强大的注解）
@EnableAutoConfiguration
public class HelloController {

    @RequestMapping("/hello")
    @ResponseBody
    String hong() {
        return "hello world";
    }
    
}

1.1.1. 注意事项

1.为什么放在cn.zj.springboot包下呢？

答:@SpringBootApplication的配置默认根据入口类的所在位置扫描包以及入口类所在位置以及子包范围。

根据以上配置，使用@SpringBootApplication配置Spring boot项目。会自动扫描cn.zj.springboot.*下面HelloController类。

从而可以得出使用@SpringBootApplication可以实现将多个类扫描到Spring容器里面。

 热启动

使用spring-boot:run命令启动项目，每次修改完成代码都要重新启动。是非常麻烦的。

我们就有那么一个想法，能不能修改完代码，程序不用重启直接自动编译了？

我们将修改完代码开发工具自动编译的过程称为，热启动。

Spring boot是支持热启动的。只有加入以下依赖就可以

<dependency>  
       <groupId>org.springframework.boot</groupId>  
       <artifactId>spring-boot-devtools</artifactId>  
       <!-- 
           optional=true,依赖不会传递，该项目依赖devtools；
           之后依赖该项目的项目如果想要使用devtools，需要重新引入 
       -->
       <optional>true</optional>  
</dependency>

SpringBoot常见基础包说明

 

 

常用API说明

SpringApplication类

说明

作用:用于启动Spring Boot的程序，根据传入的类声明的注解来决定不同的启动方式。

一般都在 main方法中调用执行

@EnableAutoConfiguration注解

注解的声明

@SuppressWarnings("deprecation")

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

@AutoConfigurationPackage

@Import(EnableAutoConfigurationImportSelector.class)

public @interface EnableAutoConfiguration {

String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

Class<?>[] exclude() default {};

String[] excludeName() default {};

}

package cn.sxt.controller;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
//把对象交给spring框架
@Controller
//声明@EnableAutoConfiguration,表示程序使用Springboot默认的配置（早期使用，下面有更强大的注解）
@EnableAutoConfiguration
public class HelloController {

    @RequestMapping("/hello")
    @ResponseBody
    String hong() {
        return "hello world";
    }
    
}

.属性说明

exclude属性：使用Class格式的方式，排除默认自动启动中不需要的配置类

excludeName属性：使用类的限制名的方式，排序默认自动启动中不需要的配置类

作用

@EnableAutoConfiguration注解的作用是：启动程序时，告诉SpringApplication启动对象使用SpringBoot的默认配置。

只要在SpringBoot项目的入口类配置了@EnableAutoConfiguration，在SpringBoot框架启动是就会自动根据你导入的jar包来加载spring-boot-autoconfigure-2.1.6.RELEASE-sources.jar中的xxxAutoconfiguration配置类，使用其默认配置。

@SpringBootApplication注解

package cn.sxt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//SpringBoot启动的配置注解
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        /*
         * SpringApplication
         * SpringBoot的启动类，执行run方法 读取当前
         * Application 上面的注解对应的配置，启动SpringBoot框架
         */
        SpringApplication.run(Application.class, args);
    }
}

 

根据注解的声明可以得出：

@SpringBootApplication注解也是启动Springboot的默认配置。只是在@EnableAutoConfiguration注解的基础上增加了扫描包@ComponentScan的这个注解。实现了并且扫描指定范围的类创建对象到容器里面。

@ComponentScan ：注解就是Spring中注解配置 配置组件的包扫描位置的注解

 

注解属性说明

1.basePackages属性

@SpringBootApplication默认扫描的范围是使用该注解的当前的类的包以及子包,如果要指定其他范围的包，可以是basePackages指定。

2.basePackageClasses属性

用于精确指定哪些类需要创建对象加载到Spring容器里面。

3.exclude属性

通过Class的方式排除不扫描的类，就是该类不创建对象。

4.excludeName属性

通过类的全限制名的方式，排除不扫描的类,指定的类不会在容器中创建对象。

@AutoConfigureBefore注解

 注解说明

指定在SpringBoot框架自动配置的配置类执行完成之前，执行指定的自定义的配置类。

如果放在Application入口类，表示在所有自动配置的配置类还没有可以就先加载自定义的配置类。

@AutoConfigureBefore注解属性：

value:使用类的方式指定自动配置类

name：使用类的全限制名（字符串）类指定

@AutoConfigureAfter注解

指定在SpringBoot框架自动配置的配置类执行完成之后，然后执行指定的自定义的配置类。

具体配置参考@AutConfigureBefore方式

@SpringBootTest注解

注解说明

用于使用JUnit测试SpringBoot程序，启动SpringBoot框架。测试SpringBoot一定要加上。

 示例代码

1.创建一个普通的类，没有任何注解

package cn.zj.springboot.springboot.utils;

/*

 * 创建一个没有被Spring 注入的类

 */

public class TestUtil {

public String test() {

return "注入测试对象成功";

}

}

2.创建一个自定义配置类，注入普通的类到Spring容器

package cn.zj.springboot.springboot.config;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

/*

 * @Configuration 把当前类作为spring框架的 配置类

 * 等价于 applicationContext.xml 配置文件

 */

import cn.zj.springboot.springboot.utils.TestUtil;

@Configuration

public class SpringConfig {

/*

 * applicationContext.xml 配置 TestUtil

 * <bean id="testUtil" class="cn.zj.springboot.springboot.utils.TestUtils">

 *

 */

@Bean(name = "testUtil")

public TestUtil getTestUtil() {

TestUtil testUtil = new TestUtil();

return testUtil;

}

}

3.在入口类配置加入自定义配置类

package cn.zj.springboot.springboot;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.AutoConfigureBefore;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import cn.zj.springboot.springboot.config.SpringConfig;

//SpringBoot启动的配置注解

@SpringBootApplication

//在SpringBoot配置之前启动SpringConfig配置的配置

@AutoConfigureBefore(value = {SpringConfig.class})

public class Application {

public static void main(String[] args) {

/*

 * SpringApplication

 * SpringBoot的启动类，执行run方法 读取当前

 * Application 上面的注解对应的配置，启动SpringBoot框架

 */

SpringApplication.run(Application.class, args);

}

}

4.在Controller里面使用这个注入的对象

package cn.zj.springboot.springboot.controller;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.ResponseBody;

import cn.zj.springboot.springboot.utils.TestUtil;

@Controller

public class HelloController {

@Autowired

private TestUtil testUtil;

@RequestMapping("/hello")

@ResponseBody

public String hello() {

//获取测试工具类test方法返回的字符串

String test = testUtil.test();

return test;

}

}

SpringBoot配置流程（重点）

概述

Spring Boot框架是一个将整合框架的整合代码都写好了的框架。所以我们要知道它的工作原理才能够，找到各种整合框架可以配置的属性，以及属性对应的属性名。

本章主要讲述如何在SpringBoot框架代码中找到application.properties配置文件的属性值。

 配置流程说明

1.SpringBoot的spring-boot-autoconfigure-2.1.6.RELEASE.jar中编写了所有内置支持的框架的自动整合代码

2.所以支持的框架根据功能类型来划分包，每个包都有一个XxxxAutoConfiguration配置类，都是一个基于纯注解的配置类，是各种框架整合的框架代码。如图所示：

 配置流程图

第一步：配置一个内置整合框架的参数，先到spring-boot-autoconfigure-2.1.6.RELEASE.jar找到对应的模块。

第二步：如果该框架有可以配置的参数，那么对应的整合模块中一定有一个XxxxProperties类，在里面可以找可以设置的参数。

第三部：在resources源目录下的application.properties文件里面可以修改XxxxProperties类中默认的参数。

 

配置文件

Spring Boot的参数配置文件支持两种格式。分别为application.propertie，application.yml。

配置Spring Boot时可以二选一。

application.propertie：是键值对风格

application.yml：是层级键值对风格

application.properties配置文件

application.properties说明

默认情况下，Spring Boot会加载resources目录下的application.properties来获得配置的参数。

application.properties多配置文件支持

1.在application.properties配置文件下，增加多个application-xxx.properties文件名的配置文件，其中xxx是一个任意的字符串。

例如：

application-database.properties

application-mvc.properties

application-freemarker.properties

2.在application.properties总配置文件指定，加载的多个配置文件

例如：要同时使用，四个配置文件

application.properties、

application-databaseproperties

application-mvc.properties

application-freemarker.properties

那么在application.properties其他配置文件指定为：

spring.profiles.active=database,mvc,freemarker

 application.yml配置文件

application.yml说明

SpringBoot支持一种由SpringBoot框架自制的配置文件格式。后缀为yml。yml后缀的配置文件的功能和properties后缀的配置文件的功能是一致的。配置时可以二选一。

例如：配置文件：application.properties

#数据源配置

spring.datasource.driverClassName=com.mysql.jdbc.Driver

spring.datasource.url=jdbc:mysql://localhost:3306/pleage

spring.datasource.username=root

spring.datasource.password=admin

#指定数据源类型 :dbcp,c3p0,druid

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

可以修改为配置文件：application.yml，内容为：

#配置数据源

spring:

    datasource:

      url: jdbc:mysql://localhost:3306/school

      driverClassName: com.mysql.jdbc.Driver

      username: root

      password: root

      #配置连接池

      type: com.alibaba.druid.pool.DruidDataSource

其实application.yml配置文件就是将原来application.properties使用（.）分割的方式，改为树状结构，使用（:）分割。

 

注意：最后key的字段与值之间的冒号（:）后面一定要有一个空格。

 

 application.yml多配置文件支持

1.在application.yml配置文件下，增加多个application-xxx.yml文件名的配置文件，其中xxx是一个任意的字符串。

例如：

application-database.yml

application-mvc.yml

application-freemarker.yml

2.在application.yml总配置文件指定，加载的多个配置文件

例如：要同时使用，四个配置文件

application.yml

application-database.yml

application-mvc.yml

application-freemarker.yml

那么在application.yml其他配置文件指定为：

spring:

   profiles:

     active: database,mvc,freemarker

 

配置示例-Spring数据源配置

配置Spring数据源,并支持DBCP2数据源

1.在pom.xml加入支持数据源的类库

1.

<!-- mysql驱动 -->

<dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

</dependency>

<!-- 连接池 -->

<dependency>

<groupId>com.alibaba</groupId>

<artifactId>druid-spring-boot-starter</artifactId>

<version>1.1.9</version>

</dependency>

<!-- spring-boot jdbc  -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-jdbc</artifactId>

</dependency>

2.找到数据源的配置类

3.application.properties配置文件修改数据源参数：

#配置web 上下文路径，端口
server.port=8081
server.context-path=/spring-boot
#数据源配置
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/logistics?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT
spring.datasource.username=root
spring.datasource.password=gzsxt
#指定数据源 druid,dbcp,c3p0 
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

1.spring.datasource这个前缀就是DataSourceProperties的@ConfigurationProperties(prefix = "spring.datasource")注解声明的前缀

2.属性就是DataSourceProperties对应的属性

1.测试代码

pa

c

kag

e cn.zj.springboot.springboot.test;

import static org.junit.Assert.*;

import java.sql.Connection;

import javax.sql.DataSource;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)

@SpringBootTest

public class DataSourceTest {

@Autowired

private DataSource dataSource;

@Test

public void testGetConeection() throws Exception {

Connection connection = dataSource.getConnection();

System.out.println("connection :"+connection);

}

}

获得自定义application.properties声明的属性值

使用@ConfigurationProperties注解可以直接获得application.properties配置的属性值。

@ConfigurationProperties属性说明：

prefix属性：表示获得application.properties时忽略的指定的前缀，如：

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)

ignoreUnknownFields属性：忽略未知的字段值。如果为true时，就是当application.properties设置的输入找不到对应的字段时，就忽略它。

@ConfigurationProperties的使用：

1.在pom.xml导入支持的依赖包

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-configuration-processor</artifactId>

<optional>true</optional>

</dependency>

2.自定义一个TestProperties 属性类

package cn.zj.springboot.utils;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix="cn.zj.springboot" )

public class TestProperties {

private String path;

public String getPath() {

return path;

}

public void setPath(String path) {

this.path = path;

}

}

3.自定义一个application-test.properties文件

cn.zj.springboot.path=demo-03

4.在application.properties指定application-test.properties配置文件

spring.datasource.url=jdbc:mysql://localhost:3306/school

spring.datasource.driverClassName=com.mysql.jdbc.Driver

spring.datasource.username=root

spring.datasource.password=123456

spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource

spring.profiles.active=test

5.启动支持TestProperties类自动配置

在入口类Application增加EnableConfigurationProperties注解支持

package cn.zj.springboot;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.context.properties.EnableConfigurationProperties;

import cn.zj.springboot.utils.TestProperties;

@SpringBootApplication

@EnableConfigurationProperties(value=TestProperties.class)

public class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

}

6.调用配置的属性path

package cn.zj.springboot.controller;

import java.util.HashMap;

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import cn.zj.springboot.service.StudentService;

import cn.zj.springboot.utils.TestProperties;

@Controller

public class StudentController {

@Autowired

private TestProperties testProperties;

@RequestMapping(value="/path")

public String path(){

    System.out.println(testProperties.getPath()+"==============");

return "index";

}

}