1、spring-boot入门基础

参考博客
月光中的污点
纯洁的微笑

1、什么是spring boot

Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。

学习了spring boot会发现开发更加简单和快捷。

之前我们搭建一个web 工程，会配置web.xml，加载spring配置和springMVC配置，配置数据库，配置spring事物...等等，配置完成后我们部署到Tomcat中启动。可以看错折腾很多步，如果要再创建一个新的项目，又需要折腾一遍，这就是spring boot出现的原因吧，还有一个原因可能是微服务的流行。

我们首先搭建一个helloworld项目，看看spring boot到底是什么样的

2、搭建helloworld项目

1. 创建maven 项目，目录结构如下

image.png

spring boot建议目录为：

com
  +- example
    +- myproject
      +- Application.java
      |
      +- domain
      |  +- Customer.java
      |  +- CustomerRepository.java
      |
      +- service
      |  +- CustomerService.java
      |
      +- controller
      |  +- CustomerController.java
      |

2. 添加依赖，在pom.xml文件添加依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </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>
                <configuration>
                    <!-- 没有该配置，devtools 不生效 -->
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
    </build>

3. 创建spring boot的启动类

@SpringBootApplication
public class Application implements ServletContextInitializer{

    private static Logger LOGGER = LoggerFactory.getLogger(Application.class);

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
    }
}

4. 创建helloworld controller（需要在启动类路径下面）

@RestController
public class Controller {

    @RequestMapping(value = "/")
    public String index() {
        return "spring boots hello";
    }
}

5. 在Application.java 右键 Run as -> Java Application。当看到 “Tomcat started on port(s): 8080 (http)” 字样说明启动成功。
   打开浏览器访问 http://localhost:8080/helloworld，结果如下：
   
   image.png

现在helloworld的项目已经搭建成功了！

3、helloworld项目解析

参考博客
我没有三颗心脏

1. 关于pom.xml文件

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

这个标签是在配置 Spring Boot 的父级依赖，有了这个，当前的项目才是 Spring Boot 项目，spring-boot-starter-parent 是一个特殊的 starter ，它用来提供相关的 Maven 默认依赖，使用它之后，常用的包依赖就可以省去 version 标签。

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

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

添加spring-boot 依赖和测试依赖

2. 关于Application.java类

@SpringBootApplication
@EnableCaching
public class Application implements ServletContextInitializer{

    private static Logger LOGGER = LoggerFactory.getLogger(Application.class);

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
    }
}

此类是spring boot项目的入口类，入口类里有一个 main 方法， 这个 main 方法其实就是一个标准的 Javay 应用的入口方法。通过这个类的main方法启动项目
@SpringBootApplication 是 Spring Boot 的核心注解，它是一个组合注解，该注解组合了：@Configuration、@EnableAutoConfiguration、@ComponentScan；

3. 关于controller类

@RestController
public class Controller {

    @RequestMapping(value = "/")
    public String index() {
        return "spring boots hello";
    }
}

@RestController 注解： 该注解是 @Controller 和 @ResponseBody 注解的合体版

4、配置文件环境切换

现在我们对spring-boot 有了大致了解，接下来我们看看配置文件的使用。

Spring Boot 使用一个全局的配置文件 application.properties 或 application.yml，放置在【src/main/resources】目录或者类路径的 /config 下。

Spring Boot 不仅支持常规的 properties 配置文件，还支持 yaml 语言的配置文件。yaml 是以数据为中心的语言，在配置数据的时候具有面向对象的特征。

Spring Boot 的全局配置文件的作用是对一些默认配置的配置值进行修改。

1. 这里主要说一下application.properties文件
   我们现实开发中一版分为开发环境，测试环境和生成环境，而这三个环境的配置可能都不一样，例如数据库，开发环境时开发的库，测试环境时测试的库，生产环境是生产环境的库，这就涉及到数据库连接配置不一样。为了解决上述问题，springboot 提供多环境配置的机制，让开发者非常容易的根据需求而切换不同的配置环境。

可以在 src/main/resources 目录下创建三个配置文件:

application-dev.properties：用于开发环境
application-test.properties：用于测试环境
application-prod.properties：用于生产环境

我们可以在这个三个配置文件中设置不同的信息，然后在application.properties文件中配置公共的信息，然后在application.properties文件中设置spring.profiles.active属性激活相应的环境的配置文件
例如：

spring.profiles.active=dev
#表示application-dev.properties配置文件生效
#同理，可将 spring.profiles.active 的值修改成 test 或 prod 达到切换环境的目的。

2. 切换项目启动的环境不仅对读取配置文件信息有效，也可以对 Bean 有效。
   当我们需要对不同环境使用不同的 Bean 时，可以通过 @Profile 注解进行区分
   示例代码：

/**
 * 使用profile注解
 */
@Configuration
public class BeanConfiguration {

    private static Logger LOGGER = LoggerFactory.getLogger(BeanConfiguration.class);

    @Bean
    @Profile(value = "dev")
    public Runnable dev() {
        LOGGER.info("开发环境使用bean");
        return () -> {};
    }

    @Bean
    @Profile(value = "test")
    public Runnable test() {
        LOGGER.info("测试环境使用bean");
        return () -> {};
    }

    @Bean
    @Profile(value = "prod")
    public Runnable prod() {
        LOGGER.info("线上环境使用bean");
        return () -> {};
    }
}

当启动项目后，Spring 会根据 spring.profiles.active 的值实例化对应的 Bean。

5、配置日志

1. 配置logback日志
   spring boot 默认会加载 classpath:logback-spring.xml 或者 classpath:logback-spring.groovy。
   如需要自定义文件名称，在 application.properties 中配置 logging.config 选项即可。
   在 src/main/resources 下创建 logback-spring.xml 文件，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!--springProfile 标签的 name 属性对应 application.properties 中的 spring.profiles.active 的配置-->
<configuration>
    <!-- 文件输出格式 -->
    <property name="PATTERN" value="%-12(%d{yyyy-MM-dd HH:mm:ss.SSS}) |-%-5level [%thread] %c [%L] -| %msg%n" />
    <!-- test文件路径 -->
    <property name="TEST_FILE_PATH" value="d:/test.log" />
    <!-- pro文件路径 -->
    <property name="PRO_FILE_PATH" value="/opt/test/log" />

    <!-- 开发环境 -->
    <springProfile name="dev">
        <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <pattern>${PATTERN}</pattern>
            </encoder>
        </appender>
        <logger name="spring-boot" level="DEBUG" />
        <root level="DEBUG">
            <appender-ref ref="CONSOLE" />
        </root>
    </springProfile>

    <!-- 测试环境 -->
    <springProfile name="test">
        <!-- 每天产生一个文件 -->
        <appender name="TEST-FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!-- 文件路径 -->
            <file>${TEST_FILE_PATH}</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <!-- 文件名称 -->
                <fileNamePattern>${TEST_FILE_PATH}/info.%d{yyyy-MM-dd}.log</fileNamePattern>
                <!-- 文件最大保存历史数量 -->
                <MaxHistory>100</MaxHistory>
            </rollingPolicy>
            <layout class="ch.qos.logback.classic.PatternLayout">
                <pattern>${PATTERN}</pattern>
            </layout>
        </appender>
        <logger name="spring-boot" level="debug" />
        <root level="info">
            <appender-ref ref="CONSOLE" />
            <!--<appender-ref ref="TEST-FILE" />-->
        </root>
    </springProfile>

    <!-- 生产环境 -->
    <springProfile name="prod">
        <appender name="PROD_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>${PRO_FILE_PATH}</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${PRO_FILE_PATH}/warn.%d{yyyy-MM-dd}.log</fileNamePattern>
                <MaxHistory>100</MaxHistory>
            </rollingPolicy>
            <layout class="spring-boot">
                <pattern>${PATTERN}</pattern>
            </layout>
        </appender>
        <root level="warn">
            <appender-ref ref="CONSOLE" />
            <!--<appender-ref ref="PROD_FILE" />-->
        </root>
    </springProfile>
</configuration>

6、读取配置文件

1. 属性装配
   有两种方式：使用 @Value 注解和 Environment 对象。
   在 application.properties 中添加：

db.userName=root
db.password=root

读取配置代码：

@Configuration
public class WebConfiguartion {

    private static Logger LOGGER = LoggerFactory.getLogger(WebConfiguartion.class);

    /**
     * 通过注解@Value读取
     */
    @Value(value = "${ds.userName}")
    private String userName;

    /**
     * 通过Environment读取
     */
    @Autowired
    private Environment environment;

    public void show () {
        LOGGER.info("ds.userName : {}", this.userName);
        LOGGER.info("ds.password : {}", this.environment.getProperty("ds.password"));
    }
}

2. 对象装配
   封装属性对象类

@Component
@ConfigurationProperties(prefix = "db")
public class DataSourceProperties {

    private static Logger LOGGER = LoggerFactory.getLogger(DataSourceProperties.class);

    private String userName;
    private String password;

    public void show() {
        LOGGER.info("ds.userName : {}", this.userName);
        LOGGER.info("ds.password : {}", this.password);
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

然后调用show()方法就可以得到配置value

7、spring boot常用注解介绍

@Configuration                 # 作用于类上，相当于一个 xml 配置文件
@Bean                          # 作用于方法上，相当于 xml 配置中的 <bean>
@SpringBootApplication         # Spring Boot的核心注解，是一个组合注解，用于启动类上
@EnableAutoConfiguration       # 启用自动配置，允许加载第三方 Jar 包的配置
@ComponentScan                 # 默认扫描 @SpringBootApplication 所在类的同级目录以及它的子目录
@PropertySource                # 加载 properties 文件
@Value                         # 将配置文件的属性注入到 Bean 中特定的成员变量
@EnableConfigurationProperties # 开启一个特性，让配置文件的属性可以注入到 Bean 中，与 @ConfigurationProperties 结合使用
@ConfigurationProperties       # 关联配置文件中的属性到 Bean 中
@Import                        # 加载指定 Class 文件，其生命周期被 Spring 管理
@ImportResource                # 加载 xml 文件

8、项目打包

1. jar包
   通过 maven 执行 package 命令后，会生成 jar 包，且该 jar 包会内置了 tomcat 容器，因此我们可以通过 java -jar 就可以运行项目
2. war包
   让 SpringbootApplication 类继承 SpringBootServletInitializer 并重写 configure 方法，如下：

@SpringBootApplication
public class SpringbootApplication extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SpringbootApplication.class);
    }

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

修改 pom.xml 文件，将 jar 改成 war
然后移除内置的Tomcat

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- Servlet API -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>

打包成功后，将 war 包部署到 tomcat 容器中运行即可。