【Spring Boot】简单入门

2020-11-14  本文已影响0人  abboo

1. 概述

1.1 什么是Spring Boot

一般把Spring Boot称为搭建程序的 脚手架 或者说是便捷搭建 基于Spring的工程 脚手架。其最主要作用就是帮助开发人员快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让开发人员关注，业务而非配置。

1.2 Spring Boot优点

java一直被人诟病的一点就是臃肿、麻烦。当我们还在辛苦的搭建项目时，可能Python程序员已经把功能写好了。

究其原因注意是两点：

Spring Boot 简化了基于Spring的应用开发，只需要“run”就能创建一个独立的、生产级别的Spring应用。

Spring Boot为Spring平台及第三方库提供开箱即用的设置（提供默认设置，存放默认配置的包就是启动器starter），这样我们就可以简单的开始。多数Spring Boot应用只需要很少的Spring配置。

我们可以使用Spring Boot创建java应用，并使用java –jar 启动它，就能得到一个生产级别的web工程。

1.3 Spring Boot

1.4 小结

Spring Boot是一个便捷搭建 基于spring工程的脚手架；作用是帮助开发人员快速搭建大型的spring 项目。简化工程的配置，依赖管理；实现开发人员把时间都集中在业务开发上。

2. Spring Boot入门

2.1 创建一个maven新项目并添加依赖

    <!--添加父工程坐标 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.5.RELEASE</version>
    </parent>
    <!--添加web启动器 -->
   <dependencies>  
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.3.5.RELEASE</version>
        </dependency>
    </dependencies>
    <!-- 管理jdk版本，不是必须-->
    <properties>
        <java.version>1.8</java.version>
    </properties>

2.2 新建application.java和controller

项目结构如下


注意：
稍后会提到Application.java是个启动类，名字不重要

启动类要controller上一级目录
因为controller目录跟启动类目录放在同一级，到时候url解析就会出现404错误了.

启动类加上@SpringBootApplication注解

/**
 * spring boot工程都有一个启动引导类，这是工程的入口类
 * 并在引导类上添加@SpringBootApplication
 */
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

controller类

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello(@RequestParam(value = "name", defaultValue = "World") String name) {
        return String.format("Hello %s!", name);
    }
}

点开hello函数旁边的小按钮



跳转到


可以看到这个是我们的url地址

然后运行Application类的main函数，地址栏输入http://localhost:8080/hello

快到起飞！！

错误示例：启动类不在controller的上一级目录


实现步骤：

  1. 创建工程；
  2. 添加依赖（启动器依赖，spring-boot-starter-web）；
  3. 创建启动类；
  4. 创建处理器Controller；
  5. 测试

2.3小结：

Spring Boot工程可以通过添加启动器依赖和创建启动引导类实现快速创建web工程。

spring-boot-starter-web默认的应用服务器端口是8080

3. java配置应用

在入门案例中，我们没有任何的配置，就可以实现一个SpringMVC的项目了，快速、高效！
但是有同学会有疑问，如果没有任何的xml，那么我们如果要配置一个Bean该怎么办？比如我们要配置一个数据库连接池，以前会这么配置：

<!--    加载外部properties-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="DriverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

现在改怎么做呢
在这之前我们先了解一下Spring的配置历史

3.1 sping配置历史

事实上，在Spring3.0开始，Spring官方就已经开始推荐使用java配置来代替传统的xml配置了，我们不妨来回顾一下
Spring的历史：

3.2 尝试java配置（注解配置方式）

java配置主要靠java类和一些注解，比较常用的注解有：

我们接下来用java配置来尝试实现连接池配置：

1. 在 pom.xml 文件中添加Druid连接池依赖如下

    <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.1</version>
        </dependency>

2. 创建数据库 test 然后在resources下创建jdbc.properties

直接从以前的文件中复制粘贴

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

3. 编写 JdbcConfig.java 如下

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {

    @Value("${jdbc.driver}")
    String driver;

    @Value("${jdbc.url}")
    String url;

    @Value("${jdbc.username}")
    String username;

    @Value("${jdbc.password}")
    String password;

    @Bean
    public DataSource dataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setDriverClassName(driver);
        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);
        return datasource;
    }
}

解读：

然后我们就可以在任意位置通过 @Autowired 注入DataSource了！

4. 在 HelloController 中注入DataSource进行测试，改造代码如下

@RestController
public class HelloController {
    @Autowired
    private DataSource dataSource;

    @GetMapping("/hello")
    public String hello(@RequestParam(value = "name", defaultValue = "World") String name) {
        System.out.println("Datasource = "+dataSource);
        return String.format("Hello %s!", name);
    }
}

在print处打上断点，返回到Application.java，debug运行main函数


5. 目录结构

6. 小结

需求：使用Java代码配置数据库连接池，并可以在处理器中注入并使用

步骤：

  1. 添加依赖；
  2. 创建数据库；
  3. 创建数据库连接参数的配置文件jdbc.properties；
  4. 创建配置类；
  5. 改造处理器类注入数据源并使用

3.3 spring boot 属性注入方式

在上面的案例中，我们实验了java配置方式。不过属性注入使用的是@Value注解。这种方式虽然可行，但是不够强大，因为它只能注入基本类型值。而且很麻烦，一个项配置一次。很多次的cv操作真是有够烦的。

在Spring Boot中，提供了一种新的属性注入方式，支持各种java基本数据类型及复杂类型的注入。

需求：将配置文件中的配置项读取到一个对象中；

实现：可以使用Spring Boot提供的注解@ConfigurationProperties，该注解可以将Spring Boot的配置文件（默认必须为application.properties或application.yml）中的配置项读取到一个对象中。

1. 新建JdbcProperties.java ，用于进行属性注入

/**
 * ConfigurationProperties 从application配置文件中读取配置项
 * prefix 表示 配置项的前缀
 * 配置项类中的类变量名必须要与 前缀之后的配置项名称保持 松散绑定（相同）
 */
@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {

    private String driver;

    private String url;

    private String username;

    private String password;
}

解读

此时会出现一个错误，下图中的红色背景标注

【注意】如果出现如下提示，项目也可以运行；

怎么消除？
如果要去掉上述的提示，则可以在 pom.xml 文件中添加如下依赖：

       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <!--不传递依赖-->
            <optional>true</optional>
        </dependency>

此时还是会有红色波浪线，因为我们还没有将该注解作为spring的组件

在次提醒：修改jdbc.properties名为application.properties

2. 将 JdbcConfig 类原来全部注释掉或删除，修改为如下内容：

@Configuration
//@PropertySource("classpath:jdbc.properties")
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {
    @Bean
    public DataSource dataSource(JdbcProperties jdbcProperties) {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setDriverClassName(jdbcProperties.getDriver());
        datasource.setUrl(jdbcProperties.getUrl());
        datasource.setUsername(jdbcProperties.getUsername());
        datasource.setPassword(jdbcProperties.getPassword());
        return datasource;
    }
}
  1. 通过 @EnableConfigurationProperties(JdbcProperties.class) 来声明要使用 JdbcProperties 这个类的对象
  2. 然后要使用配置的话；可以通过以下方式注入JdbcProperties：
    • @Autowired注入
    @Autowired private JdbcProperties prop;
    • 构造函数注入
    private JdbcProperties prop; 
public JdbcConfig(Jdbcproperties prop){ 
    this.prop = prop; 
}
    • 声明有@Bean的方法参数注入
    @Bean public Datasource dataSource(JdbcProperties prop){
     // ... 
}
    本例中，我们采用第三种方式。

3. 测试结果；与前面的测试一样的

4. 小结

  1. 创建配置项类JdbcProperties类，在该类名上面添加@ConfigurationProperties；
  2. 将jdbc.properties修改名称为application.properties；
  3. 将JdbcProperties对象注入到JdbcConfig；
  4. 测试
目录结构

大家会觉得这种方式似乎更麻烦了，事实上这种方式有更强大的功能，也是Spring Boot推荐的注入方式。与@Value对比关系：

image.png

优势：

3.4 更优雅的注入

事实上，如果一段属性只有一个Bean需要使用，我们无需将其注入到一个类（JdbcProperties，将该类上的所有注解去掉）中。而是直接在需要的地方声明即可；再次修改 JdbcConfig 类为如下代码：

@Configuration
//@PropertySource("classpath:jdbc.properties")
//@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {
    @Bean
    // 声明要注入的属性前缀，Spring Boot会自动把相关属性通过set方法注入到DataSource中
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource dataSource(JdbcProperties jdbcProperties) {
        return new DruidDataSource();
    }
}

再去JdbcProperties.java将注解注释掉

//@ConfigurationProperties(prefix = "jdbc")

我们直接把 @ConfigurationProperties(prefix = "jdbc") 声明在需要使用的 @Bean 的方法上，然后Spring Boot就会自动调用这个Bean（此处是DataSource）的set方法，然后完成注入。使用的前提是：该类必须有对应属性的set方法！

错误记录

debug启动类的时候报错，
Failed to bind properties under 'jdbc.driver' to java.sql.Driver:
解决方法: 将application.properties中的driver改为driverClassName，同时修改JdbcProperties.java的变量driver为driverClassName,运行成功！

3.5 yaml配置文件

配置文件除了可以使用application.properties类型，还可以使用后缀名为：.yml或者.yaml的类型，也就是：application.yml或者application.yaml
docker也使用这种格式的文件进行配置

基本格式：

jdbc:
  driverClassName: com.mysql.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/test
  username: root
  password: root

把application.properties修改为application.yml进行测试。

只是改了文件名，但是文件内容仍然是

jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

仍然成功运行！

yaml与properties配置文件除了展示形式不相同以外，其它功能和作用都是一样的；在项目中原路的读取方式不需要改变。

yml配置文件的特征：

  1. 树状层级结构展示配置项；
  2. 配置项之间如果有关系的话需要分行空两格；
  3. 配置项如果有值的话，那么需要在 :之后空一格再写配置项值；

将application.properties配置文件修改为application.yml的话：

jdbc:
  driverClassName: com.mysql.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/test
  username: root
  password: root

key:
  abc: cba
  def:
    - g
    - h
    - j

如果两个配置文件都有，会把两个文件的配置合并，如果有重复属性，以properties中的为准。
如果是配置数组、list、set等结构的内容，那么在yml文件中格式为：
key:
- value1
- value2

3.6 多个yaml配置文件

多个yml配置文件；在spring boot中是被允许的。这些配置文件的名称必须为application-***.yml，并且这些配置文件必须要在application.yml配置文件中激活之后才可以使用。

如果properties和yml配置文件同时存在在spring boot项目中；那么这两类配置文件都有效。在两个配置文件中如果存在同名的配置项的话会以properties文件的为主。

创建 application-github.yml 文件如下：

gitbug404:
  url: https://github.com/gitbug404

创建 application-jianshu.yml 文件如下：

abboo:
  url: https://www.jianshu.com/u/bb5286ec0fe5

在 application.yml 文件中添加如下配置：

jdbc:
  driverClassName: com.mysql.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/test
  username: root
  password: root

#激活配置文件；需要制定其他的配置文件名称
spring:
  profiles:
    active: github,jianshu

修改HelloController.java


多个文件名只需要写application-之后的名称，在多个文件之间使用,隔开。

小结

在多个配置文件时，需要将这些文件在application.yml文件中进行激活：

#激活配置文件;需要指定其它的配置文件名称
spring:
  profiles:
    active: github,jianshu

4. 自动配置原理

使用Spring Boot之后，一个整合了SpringMVC的WEB工程开发，变的无比简单，那些繁杂的配置都消失不见了，这是如何做到的？
一切魔力的开始，都是从我们的main函数来的，所以我们再次来看下启动类：

image.png

我们发现特别的地方有两个：

我们分别来研究这两个部分。

4.1 了解@SpringBootApplication

点击进入，查看源码：



这里重点的注解有3个：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

4.1.1 @SpringBootConfiguration

我们继续点击查看源码


通过这段我们可以看出，在这个注解上面，又有一个 @Configuration 注解。通过上面的注释阅读我们知道：这个注解的作用就是声明当前类是一个配置类，然后Spring会自动扫描到添加了 @Configuration 的类，并且读取其中的配置信息。而 @SpringBootConfiguration 是来声明当前类是SpringBoot应用的配置类，项目中只能有一个。所以一般我们无需自己添加。

4.1.2 @EnableAutoConfiguration

关于这个注解，官网上有一段说明：

The second class-level annotation is @EnableAutoConfiguration . This annotation tells Spring Boot to “guess” how you want to configure Spring, based on the jar dependencies that you have added. Since spring-boot-starter-web added Tomcat and Spring MVC, the auto-configuration assumes that you are developing a web application and sets up Spring accordingly.

简单翻译一下：

第二级的注解 @EnableAutoConfiguration ，告诉Spring Boot基于你所添加的依赖，去“猜测”你想要如何配置Spring。比如我们引入了 spring-boot-starter-web ，而这个启动器中帮我们添加了 tomcat 、 SpringMVC的依赖。此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了！

总结，Spring Boot内部对大量的第三方库或Spring内部库进行了默认配置，这些配置是否生效，取决于我们是否引入了对应库所需的依赖，如果有那么默认配置就会生效。

所以，我们使用SpringBoot构建一个项目，只需要引入所需框架的依赖，配置就可以交给SpringBoot处理了。除非你不希望使用SpringBoot的默认配置，它也提供了自定义配置的入口。

4.1.3 @ComponentScan

大概的意思：

配置组件扫描的指令。提供了类似与 <context:component-scan> 标签的作用
通过basePackageClasses或者basePackages属性来指定要扫描的包。如果没有指定这些属性，那么将从声明这个注解的类所在的包开始，扫描包及子包

而我们的@SpringBootApplication注解声明的类就是main函数所在的启动类，因此扫描的包是该类所在包及其子包。因此，一般启动类会放在一个比较前的包目录中。

4.2 默认配置原理

4.2.1 spring.factories

在SpringApplication类构建的时候，有这样一段初始化代码：


跟进去：


这里发现会通过loadFactoryNames尝试加载一些FactoryName，然后利用createSpringFactoriesInstances将这些加载到的类名进行实例化。
继续跟进loadFactoryNames方法：


发现此处会利用类加载器加载某个文件： FACTORIES_RESOURCE_LOCATION ，然后解析其内容。我们找到这个变量的声明：


可以发现，其地址是： META-INF/spring.factories ，我们知道，ClassLoader默认是从classpath下读取文件，因此，SpringBoot会在初始化的时候，加载所有classpath:META-INF/spring.factories文件，包括jar包当中的。

而在Spring的一个依赖包：spring-boot-autoconfigure中，就有这样的文件：
连按两下Shift键 搜索spring.factories


以后我们引入的任何第三方启动器，只要实现自动配置，也都会有类似文件。

记住这个依赖包spring-boot-autoconfigure，大有用处！！！

4.2.2 默认配置类

我们打开刚才的spring.factories文件：



可以发现以EnableAutoConfiguration接口为key的一系列配置，key所对应的值，就是所有的自动配置类，可以在当前的jar包中找到这些自动配置类：



非常多，几乎涵盖了现在主流的开源框架，例如：
redis

jms
amqp
jdbc
jackson
mongodb
jpa
solr
elasticsearch
... 等等
我们来看一个我们熟悉的，例如SpringMVC，查看mvc 的自动配置类：



打开WebMvcAutoConfiguration

我们看到这个类上的4个注解：

4.2.3 默认配置属性

另外，这些默认配置的属性来自哪里呢？



我们看到，这里通过@EnableAutoConfiguration注解引入了两个属性：WebMvcProperties和ResourceProperties。这不正是SpringBoot的属性注入玩法嘛。
我们查看这两个属性类：
先看WebMvcProperties


WebMvcProperties
WebMvcProperties的View

找到了内部资源视图解析器的prefix和suffix属性。

而ResourceProperties中主要定义了静态资源（.js,.html,.css等)的路径：

可以看到，classpath有这么多个，spring boot加载资源文件会从这些文件夹找，一般我们把css/html之类的文件都放在static里面。
如果我们要覆盖这些默认属性，只需要在application.properties中定义与其前缀prefix和字段名一致的属性即可。

4.3 小结

如果有一天，我们遇到个没学过的框架，而这个框架整合到了sprinig boot，怎么去取做？一般而言，我们使用框架，只需要修改配置就好了，那怎么知道配置项呢，当我们遇到需要修改的组件的配置项流程为：


以redis为例
idea中打开autoconfigure这个包，找到data->redis->RedisProperties


反正找到Properties结尾的类可以看到以下

这些就是配置参数，我们要修改，就在配置文件（properties或者yml）修改就好了，我们看到这个prefix关键字，我们要修改url就如 
spring.redis.url = xxx

总结

SpringBoot为我们提供了默认配置，而默认配置生效的步骤：

1）启动器
所以，我们如果不想配置，只需要引入依赖即可，而依赖版本我们也不用操心，因为只要引入了SpringBoot提供的stater（启动器），就会自动管理依赖及版本了。
因此，玩SpringBoot的第一件事情，就是找启动器，SpringBoot提供了大量的默认启动器
2）全局配置
另外，SpringBoot的默认配置，都会读取默认属性，而这些属性可以通过自定义 application.properties 文件来进行覆盖。这样虽然使用的还是默认配置，但是配置中的值改成了我们自定义的。
因此，玩SpringBoot的第二件事情，就是通过 application.properties 来覆盖默认属性值，形成自定义配置。我们需要知道SpringBoot的默认属性key，非常多，可以再idea中自动提示

属性文件支持两种格式，application.properties和application.yml

如果properties和yml文件都存在，如果有重叠属性，默认以Properties优先。

上一篇下一篇

猜你喜欢

热点阅读