SpringBoot基础入门

一、SpringBoot简介

1.Spring框架的优缺点：

优点：

• 轻量级框架
• 和其他框架整合简单
• IOC控制反转
• AOP面向切面编程
• 声明式事务

缺点：

• 配置繁琐，虽然框架是轻量级框架，但是需要配置的内容太多
• 依赖管理复杂，spring和不同jar包之间的版本冲突很多，而且spring等各个框架带来的循环依赖导致依赖的管理复杂

2.SpringBoot概述

SpringBoot是什么？

​ SpringBoot是spring公司团队开发的另一款轻量级框架，他是基于spring4.0设计的，它继承了spring框架原有的优秀特性，还通过简化配置进一步简化了spring应用的整个搭建和开发过程，而且他还解决了依赖之间的版本冲突问题；

SpringBoot做了什么事？

1. 简化配置
2. 解决混乱的依赖管理

而SpringBoot让这一切成为过去！Spring Boot 简化了基于Spring的应用开发，只需要“run”就能创建一个独立的、生产级别的Spring应用。Spring Boot为Spring平台及第三方库提供开箱即用的设置（提供默认设置，存放默认配置的包就是启动器starter），这样我们就可以简单的开始。多数Spring Boot应用只需要很少的Spring配置。

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

SpringBoot的特点：

• 创建独立的Spring引用
• 直接嵌入Web服务器，如tomcat、jetty、undertow等，不需要去部署war包
• 提供固定的启动器依赖去简化组件配置，实现开箱即用
• 自动配置Spring和其他有需要的第三方依赖
• 无需xml配置
• 提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标，健康检测、外部化配置等。

总结：

​ SpringBoot，就是为了更快的搭建程序而生的，它简化程序开发，提高开发效率，在这一点不仅上延续了spring框架，还优化spring框架配置繁琐、依赖管理混乱的缺点；

二、SpringBoot的配置

概述：

​ 在SpringBoot中，有两种配置方式，以实properties配置文件配置，还有一种事yml配置文件配置，当然yml配置更简单，配好的结构看起来更好看，所以我们一般会选择yml配置；当然两种配置一起使用也是可以的，如果两个配置文件都配置了同一项内容的话，properties配置文件的内容会覆盖yml文件的内容；

1.properties配置

配置方式：

​ 在resources目录下创建application.properties文件，在里面编写对应的配置即可，但是要注意不要修改文件名，否则会导致springboot无法自动加载配置文件中的内容，导致配置内容失效；

​ 当你导入SpringBoot相关的包之后，你编写相关内容的时候，IDEA会有对应的提示，所以不需要担心记不住，这里知道怎么配置即可；

使用案例：

#设置Springboot的banner关闭
spring.main.banner-mode=off

#配置tomcat端口
server.port=9090
#配置tomcat
server.servlet.context-path=/spring-boot

#配置rabbitmq
spring.rabbitmq.host=127.0.0.123

2.yml配置(推荐)

什么是yml配置文件：

• YML文件的扩展名可以使用.yml或者.yaml
• YML文件格式是YAML(YAML Aint Markup Language)编写的文件格式，YAML是一种层级树键值对格式文件，并且容易被人类阅读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入，比如： C/C++, Ruby, Python, Java, Perl, C#, PHP等。YML文件是以数据为核心的，比传统的xml方式更加简洁。

配置方式：

​ yml的配置方式和properties的配置方式一样，而且文件名也必须是application开头的，例如application.yml；而yml比properties最大的好处就是配置简单，而且配置的内容看起来层次结构清晰；

配置规则：

1. 在配置键值对的时候，冒号后面必须根一个空格，后面再加对应的值
2. 根据缩进进行层级关系管理，也就是父没有缩进，他的儿子要有缩进(空格或者tab)，以此类推
3. 如果要表示数组需要再前面添加 - 加空格在加对应的值

配置案例：

#自定义字符串
my:
  username: jack
  password: jack love rose
 
#对象
user:
  age: 20
  sex: 男

#自定义数组
address:
  - 中山
  - 广州
  - 广东
  - 广西
  - 湖南
  - 湖北

#对象数组
list:
  - username: root
    password: 123
    sex: 男
  - username: rose
    password: 456
    sex: 女

三、SpringBoot的使用

1.SpringBoot简单入门程序

步骤：

1.配置springboot父工程，用来锁定springboot启动器的版本

2.导入springboot的启动器(和jar包类似，但是内部版本控制已经帮你做好了)

3.编写启动类

4.启动springboot程序

注意：不需要添加配置文件！不需要添加配置文件！不需要添加配置文件！

配置springboot父工程：

虽然说这一步可有可无，一方面是为了版本锁定，另一方面也是告诉别人这是一个springboot项目

    
    
    <parent>
        <artifactId>spring-boot-starter-parentartifactId>
        <groupId>org.springframework.bootgroupId>
        <version>2.1.6.RELEASEversion>
    parent>

导入springboot的启动器：

导入下面这个依赖，就相当于spring和springmvc已经集成好了

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

编写启动类：

package com.ps;

import tk.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/*@SpringBootConfiguration 等价于 @Configuration,将当前类作为spring配置类
@EnableAutoConfiguration 自动配置注解，即自动扫描你的配置文件以及springboot内部的配置文件等
@ComponentScan 指定包扫描路径，默认是当前类所在的包及其子包
*/

//默认配置的包扫描是这个同级包以及其子包，所以这个启动类最好放在外面
@SpringBootApplication//等价于上面三个注解
public class Application {
     

    public static void main(String[] args) {
     
        //启动类启动整个程序
        SpringApplication.run(Application.class, args);
    }
}

运行截图：

当你看着这个情况，并且没有报错的时候，恭喜你，你已经学会一半的springboot了

如果看到我们的内容不太一样，那么不用着急继续看下去

2.SpringBoot编写入门Web程序

做完上面的配置之后，我们离web程序就差一个控制器了，那么接下来我们就来编写控制器再去测试一下

控制器的编写：

package com.ps.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.sql.SQLException;

@Controller
public class Hello {
     

    @RequestMapping("/find")
    @ResponseBody
    public String hello() throws SQLException {
     
        return "hello first spring boot";
    }
}

再次启动启动类，并打开网页测试：

当你发现可以访问并使用的时候，恭喜你，springboot的web程序你已经学会一半了

3.SpringBoot配置Banner和热部署

3.1 配置Banner：

​ 之前有心细的小伙伴已经发现，我给出的properties配置文件中，有配置banner的一项，那么banner到底是什么呢？

​ 其实banner就是下面这个玩意；

​ 那么为什么要配置它的，其实我一开始也是抗拒的，知道我配置之后：

​ 看到你是不是心动了呢？那么到底怎么配置呢？其实很简单：

创建banner.txt文件

填充一些内容：

${AnsiColor.BRIGHT_YELLOW}

//                          _ooOoo_                               //
//                         o8888888o                              //
//                         88" . "88                              //
//                         (| ^_^ |)                              //
//                         O\  =  /O                              //
//                      ____/`---'\____                           //
//                    .'  \\|     |//  `.                         //
//                   /  \\|||  :  |||//  \                        //
//                  /  _||||| -:- |||||-  \                       //
//                  |   | \\\  -  /// |   |                       //
//                  | \_|  ''\---/''  |   |                       //
//                  \  .-\__  `-`  ___/-. /                       //
//                ___`. .'  /--.--\  `. . ___                     //
//              ."" '<  `.___\_<|>_/___.'  >'"".                  //
//            | | :  `- \`.;`\ _ /`;.`/ - ` : | |                 //
//            \  \ `-.   \_ __\ /__ _/   .-` /  /                 //
//      ========`-.____`-.___\_____/___.-`____.-'========         //
//                           `=---='                              //
//      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        //
//             佛祖保佑          永无BUG         永不修改             //

${AnsiColor.BRIGHT_GREEN}
Spring Boot Version: ${spring-boot.version}${spring-boot.formattedversion}

再次启动的时候，你就会发现奇迹，当然如果没有出现，不要着急，记得使用maven clean一下就好了

那么这个东西去那里找呢？我也给你找好了:点这里

3.2 热部署

步骤：

1.导入热部署依赖，你没看错就是需要导入

2.idea配置compiler

3.配置允许自动编译

4.重启idea

导入热部署依赖：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-devtoolsartifactId>
dependency>

配置compiler：

配置允许自动编译：

重启测试效果

4.SpringBoot起步依赖

什么是springboot的起步依赖？

​ 就是配置的springboot的父工程：spring-boot-starter-parentn；当时我说，他主要是为了依赖锁定，那么它究竟锁定了那些依赖呢？

我们点进去看一下：

看到这里你发现了没有，其实springboot的版本锁定没有什么大不了的，只是它帮你试错了，并且把稳定的版本添加了进去而已，而且它的版本你也可以改，只不过在设置全局参数的时候要和默认的参数一样，不然不会生效，这里还看到了springboot对插件的版本也进行了锁定

SpingBoot起步依赖的作用总结：

1.定义项目构建全局属性

2.锁定依赖版本

3.锁定插件版本

5.SpringBoot启动器和自动配置

5.1 启动器

Springboot的启动器是springboot官方提供的启动器，相当于官方提供的jar包，只不过这个jar包中添加了很多配置，完成度更高而已；

5.2 自动配置

​ 这个其实没什么好说的，只不过是它框架内部帮我们创建一个初始的配置文件，所以很多东西我们不需要去配置了，换句话说就是他把那些不常用的，不常修改的几乎都帮我们配置了，而我们只需要关心业务即可，而知道它的自动配置文件在哪里，配置了那些参数，这些才是更重要的！

​ 如果之前看细心的话，就会发现，之前的我就已经写了@SpringBootApplication注解的相关内容，那么接下来我们就去找到它的配置类都在哪儿；

那么接下来就去找那个自动配置类的包

那么这两个应该就是redis相关的了，那么我们就先来看着两个

小结：

@SpringBootApplication注解的作用？

1. 当前启动类也是一个配置类
2. 组件扫描(默认扫描启动类的包名)
3. 启用自动配置

Spring Boot自动配置原理?

1. 当运行SpringApplication.run()方法时，它会用SpringFactoriesLoader.loadSpringFactories()方法加载META-INF/spring.factories来创建spring容器。
  spring-boot-autoconfigure-2.1.6.RELEASE.jar!\META-INF\spring.factories
  
2. 会读取org.springframework.boot.autoconfigure.EnableAutoConfiguration这个对应的value，这些value都是自动配置类(跟框架整合的java类，整合的代码是已经写好的)。

3. 这些自动配置类如果要有效(创建成bean)，那就需要把对应的启动器依赖进来(整合该框架的依赖jar都有了，而且还有一个默认的属性类.XxxProperties.java)

4. 我们如果要配置属性覆盖它的默认属性的话，就需要在application.properties或application.yml文件中配置就可以。

Spring Boot启动器的作用？

1. 把整合一个或者多个框架所需要的依赖jar包全部依赖进来。
2. 自动配置类就起效(自动完成spring整合该框架)
3. 也提供了默认的属性类

Spring Boot配置属性步骤?

1. 找到整合该框架的默认属性类(spring-boot-autoconfigure-2.1.6.RELEASE.jar)
2. 在application.properties或application.yml文件中进行配置

Spring Boot默认会加载哪两个配置文件？

1. application.properties
2. application.yml

Spring Boot开发两个重点?

1. 找整合该框架对应的启动器
2. 配置自己的属性覆盖它默认的属性

6.SpringBoot读取配置文件内容

6.1 使用@ConfigurationProperties注入(可以是任何数据类型)

使用案例：

#自定义字符串
my:
  username: jack
  password: jack love rose

package com.pkx.controller;

import com.pkx.pojo.User;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Arrays;
import java.util.List;

/** 第一种方式: 注入属性 */
@RestController
@ConfigurationProperties(prefix = "my")
public class PropController1 {
     

    private String username;
    private String password;

    @GetMapping("/test1")
    public String test1(){
     
        System.out.println("======test1=======");
        System.out.println("host = " + host);
        System.out.println("port = " + port);
        System.out.println("user = " + user);
        System.out.println("address = " + Arrays.toString(address));
        System.out.println("users = " + users);
        return "test1方法，访问成功！";
    }

    /** 注入的属性必须提供setter方法 */
    public void setUsername(String username) {
     
        this.username = username;
    }
    public void setPassword(int passowrd) {
     
        this.passowrd = passowrd;
    }
}

6.2 使用@Value注入(只能注入基本数据类型和String)

使用案例：

package com.ps.controller;


import com.ps.pojo.UserOne;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class JdbcMySql2 {
     

    //不需要set方法就可以注入
    @Value("${my.username}")
    private String username;

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

    @RequestMapping("/my2")
    public String sysOut() {
     
        System.out.println(username);
        System.out.println(password);
        System.out.println(user);
        return "";
    }

}

6.3 将要读取的内容定义成一个属性类

​ 也就是将那些属性封装成一个类对象，在把这个对象交给IOC容器创建，这样就可以直接通过这个类对象来访问了

使用案例：

@Component //创建bean对象，并把对象放到IOC容器中，使用的时候直接通过get方法获取即可
@ConfigurationProperties(prefix = "my") //配置属性
public class MySqlProperties {
     

    private String username;

    private String password;
}