Spring Boot-01 初识Spring Boot

Kathy66·

已于 2022-12-01 09:32:03 修改

阅读量748

点赞数

分类专栏： SpringBoot 文章标签： Spring Boot

于 2019-03-19 19:01:00 首次发布

本文链接：https://blog.csdn.net/weixin_43094361/article/details/88670028

版权

SpringBoot 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、Spring Boot简介

1、为什么学习Spring Boot

传统SSM或SSH项目：需要编写很多配置文件，而且存在Jar冲突问题，整合起来较繁琐。
传统项目打包方式：打包成一个war包放入到tomcat webapps目录下进行执行（外部tomcat方式）。

2、Spring Boot简介

SpringBoot是一个快速开发框架，能够帮助我们快速整合第三方框架，
完全采用注解化，简化XML配置，内置嵌入Http服务器（Tomcat、Jetty），
默认嵌入tomcat服务器，最终以Java应用程序进行执行。
SpringBoot框架的核心就是自动配置，只要存在相应的jar包，Spring就帮我们自动配置。如果默认配置不能满足需求，还可以替换掉自动配置类，使用自己的配置。
快速整合第三方框架原理：通过Maven依赖关系继承的方式实现，SpringBoot已经将常用的依赖封装好，只需引入SpringBoot依赖即可。

3、Spring Boot 特性（优点）

（1）为基于 Spring 的开发提供更快的入门体验
（2）开箱即用，没有代码生成，也无需 XML 配置。同时也可以修改默认值来满足特定的需求。
（3）提供了一些大型项目中常见的非功能特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。
（4）Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。
（5）嵌入的 Tomcat，无需部署 WAR 文件

二、创建第一个Spring Boot工程

在IDEA中可以使用Maven创建Spring Boot工程，也可以使用Spring Initializr创建工程。此处使用第二种方式创建。

步骤如下：
File------->New------->Project
在这里插入图片描述
此页面不做更改，下一步

勾选Web后，创建好的工程中pom.xml会为我们自动导入Web工程所需要的依赖，无需再手动导入。

在这里插入图片描述
成功创建后，整个项目结构如图。

自动生成的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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.demo.springboot</groupId>
    <artifactId>springboot-01</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-01</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <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>
            </plugin>
        </plugins>
    </build>

</project>

接下来创建一个简单的控制器类：

TestController.java

package com.demo.springboot.springboot01;

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

@RestController
public class TestController {

    @RequestMapping(value="/hello",method = RequestMethod.GET)
    public String say(){
        return "Hello Spring Boot!";
    }
}

创建Spring Boot工程后会自动生成一个启动类，只需运行这个类即可启动。

package com.demo.springboot.springboot01;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Springboot01Application {

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

启动Springboot01Application.java，控制台输出以下信息则表示启动成功

在这里插入图片描述

在浏览器地址栏或Postman工具中输入URL，测试是否成功
在这里插入图片描述
到这里，第一个Spring Boot应用已经创建好了，整个过程没有编写任何的配置文件或属性文件，由于Spring Boot内嵌Tomcat，所以不需要手动部署Tomcat服务器，只需执行Application启动类即可。

三、Spring Boot工程的启动方式

Application类main方法启动
执行命令mvn spring-boot: run 进行启动
mvn clean install/package 将项目打包
cd 到target目录
执行命令 java -jar 项目.jar

注：使用第三种方式需要加入依赖spring-boot-maven-plugin生成可执行的jar

四、Spring Boot中的注解

1、RestController注解
SpringMVC4.0.3提供，该注解表示该类中的所有方法都返回json格式，等同于 @Controller+@ResponseBody

例：

	@RestController
	public class TestController{
		//省略
	}

2、@SpringBootApplication注解

例：

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

@SpringBootApplication是一个复合注解，包括

@ComponentScan
@SpringBootConfiguration
@EnableAutoConfiguration

3、@SpringBootConfiguration注解

@SpringBootConfiguration 继承自 @Configuration ，二者功能也一致，标注当前类是配置类，并会将当前类内声明的一个或多个以@Bean注解标记的方法实例纳入到spring容器中，并且实例名就是方法名。

例：

	//@Bean标签表示让spring帮我们管理
	@Bean
    public SomeBean someBean(){
        	return new SomeBean();
    }

4、@EnableAutoConfiguration 注解

@EnableAutoConfiguration 作用是启动自动配置，简单说就是SpringBoot根据你添加的jar包来配置你项目的默认配置；比如根据 spring-boot-starter-web，来判断你的项目里是否添加了 webmvc 和 tomcat，就会自动的帮你配置Web项目中所需要的默认配置。

5、@ComponentScan 注解

扫描当前包及其子包下被@Component、@Controller、@Service、@Repository注解标记的类并纳入到spring容器中进行管理。等同于xml配置文件中的<context:component-scan>标签。

五、Spring Boot实现热部署

1、什么是热部署

Spring为开发者提供了一个名为 spring-boot-devtools 的模块来使SpringBoot应用支持热部署，提高开发者的开发效率，无需手动重启SpringBoot应用。

2、devtools原理

devtools使用了两个ClassLoader，一个ClassLoader加载那些不会改变的类（第三方jar），另一个ClassLoader加载会改变的类，称为restartClassLoader，这样在有
代码更改的时候，原来的restartClassLoader被丢弃，重新创建一个restartClassLoader，由于加载的类相比较少，所以实现了较快的重启时间。

3、使用需要添加以下配置
修改pom.xml文件

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>
    <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>
                <fork>true</fork>
            </configuration>
        </plugin>
    </plugins>
</build>

说明：

devtools可以实现页面热部署： 即页面修改后会立即生效，这个可以直接在
application.properties（下个部分会对该文件进行讲解）文件中配置spring.thymeleaf.cache=false来实现。
实现类文件热部署： 类文件修改后不会立即生效。
实现对属性文件热部署： 即devtools会监听classpath下的文件变动，并且会立即重启应用（保存时触发）。
配置devtools后再修改Java文件后也就支持了热启动，此种方式属于项目重启（速度比较快的项目重启），会清空session中的值。
默认情况下 /META-INF/maven，/META-INF/resources， /resources，/static ，/templates，/public这些文件夹下的文件修改不会使应用重启，但是会重新加载（devtools内嵌了一个LiveReload server，当资源发生改变时，浏览器刷新。）

六、SpringBoot属性配置文件详解

SpringBoot 配置文件默认为 application.properties ，但现在的趋势是使用yml，它是类似于标准通用标记语言的子集XML的数据描述语言，语法比XML简单很多。

1、自定义属性与加载

我们把之前项目中的配置文件application.properties改成application.yml

application.yml如下

test:
  user:
    username : zhangsan
    age : 18
toString: the age of ${test.user.username} is ${test.user.age}

#properties文件的写法
test.user.username=zhangsan
test.user.age=18
test.user.toString=the age of  ${test.user.username} is ${test.user.age}

属性类 PropertiesConfig .java

package com.demo.springboot.springboot01;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class PropertiesConfig {

    @Value("${test.user.username}")
    private String username;

    @Value("${test.user.age}")
    private String age;

    @Value("${test.user.toString}")
    private String toString;
	
	//省略getter/setter
}

TestController.java

package com.demo.springboot.springboot01;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    @Autowired
    private PropertiesConfig propertiesConfig;

    @RequestMapping(value = "test", method = RequestMethod.GET)
    public String test(){
        //return propertiesConfig.getUsername() + ":" + propertiesConfig.getAge();
        return propertiesConfig.getToString();
    }
}

运行结果如下：
在这里插入图片描述
说明：

Value注解： Spring 3支持@Value注解的方式获取properties文件中的配置值，大简化了读取配置文件的代码。

2、自定义属性注入bean

将上面application.yml文件中的test.user注入到User对象里，注意这里的prefix指定的是test.user，对应配置文件中的结构。

User.java

package com.demo.springboot.springboot01;

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

@Component
@ConfigurationProperties(prefix = "test.user")
public class User {
    
    private String username;
    private int age;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

TestController.java

package com.demo.springboot.springboot01;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    @Autowired
    private User user;

    @RequestMapping(value = "test2", method = RequestMethod.GET)
    public String test2(){
        return user.getUsername() + ":" + user.getAge();
    }
}

运行结果：
在这里插入图片描述
说明：

@ConfigurationProperties注解
Spring Boot可使用注解的方式将自定义的properties文件映射到实体Bean中，使用@ConfigurationProperties+@Component或者@Bean即可实现。

3、自定义额外的配置文件

若不想把一些配置写在application.yml/properties文件中，可以新建其他配置文件。
例：新建了一个test.yml文件，那么注入对象时，采用如下配置

	@Configuration
	@PropertySource(value = "classpath:test.yml")
	@ConfigurationProperties(prefix = "test.user")

4、多个环境配置文件

我们都知道线上环境总是和开发环境的配置信息有些区别，所以有时候我们需要有多个配置文件，那么如何在不同环境下选择不同的配置文件？
创建不同环境的配置文件格式：application-{profile}.properties ，其中 {profile} 对应环境标识，例如：

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

如何使用：
在application.yml中加入

	spring:
  	      profiles:
    	          active: dev

注：因为主入口是application.yml，这里指定配置文件为dev，即启用application-dev.yml文件。

5、官方支持默认配置文件属性

官方支持属性

6、属性加载优先级

（1）在命令行中传入的参数；
（2）SPRING_APPLICATION_JSON中的属性：SPRING_APPLICATION_JSON是以JSON格式配置在系统环境变量中内容。
（3）java:comp/env中的JNDI属性；
（4）Java的系统属性，可以通过System.getProperties()获得内容；
（5）操作系统的环境变量；
（6）通过random.*配置的随机属性；
（7）位于当前应用jar 包之外，针对不同{profile}环境的配置文件内容，例如 application-{profile}.properties或是YAML定义的配置文件。
（8）位于当前应用jar 包之内，针对不同{profile}环境的配置文件内容，例如 application-{profile}.properties或是YAML定义的配置文件。
（9）位于当前应用jar包之外的application.properties和YAML配置内容。
（10）位于当前应用jar包之内的application.properties和YAML配置内容。
（11）在@Configuration注解修改的类中，通过@PropertySource注解定义的属性。
（12）应用默认属性，使用SpringApplication.setDefaultProperties定义的内容。

注：优先级按上面的顺序由高到低，数字越小优先级越高。

7、配置文件优先级

SpringBoot配置文件可以使用yml格式和properties格式。
分别的默认命名为：application.yml、application.properties 。
官网都是以yml作为参考，层级结构更清晰的一种配置文件。

SpringBoot配置文件默认可以放到以下目录中，下面五种可以自动读取到：

（1）项目根目录下
（2）项目根目录中config目录下
（3）项目的resources目录下
（4）项目resources目录中config目录下
（5）也可以指定目录 ***/config

如果在不同的目录中存在多个配置文件，它的读取顺序是：

（1）config/application.properties（项目根目录中config目录下）
（ 2）config/application.yml-（
（3）application.properties（项目根目录下）
（4）application.yml
（5）resources/config/application.properties
（项目resources目录中config目录下）
（6）resources/config/application.yml
（7）resources/application.properties（项目的resources目录下）
（8）resources/application.yml

说明：
（1）优先级按上面的顺序由高到低，数字越小优先级越高。

（2）如果同一个目录下，有application.yml也有application.properties，默认先读取application.properties文件。

（3）若不在同一个目录下，则根据配置文件所在目录加载顺序加载。
例如：
application.yml在项目根目录中config目录下，
application.properties在resources/application.properties（项目的resources目录下），则application.yml文件优先。

（4）如果同一个配置属性，在多个配置文件都配置了，默认使用第1次读取到的，后面读取的不覆盖前面读取到的。

（5）创建SpringBoot项目时，一般的配置文件放置在“项目的resources目录下 "。

（6）优先级高的配置文件中存在和优先级低的配置文件相同属性时，取优先级高配置文件的；不冲突的时候，优先级低的配置文件属性同样会被加载，而不是只加载优先级高的配置文件属性。

8、小结