SpringBoot基础

SpringBoot概述

##Spring的缺点分析

1.配置是重量级的。所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。

2.项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。

SpringBoot提供了一种快速使用Spring的方式，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率

SpringBoot功能

1） 自动配置

Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是SpringBoot自动完成的。

2） 起步依赖

起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。

简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

3） 辅助功能

提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。

内置tomcat、jetty、undertow等web服务器

actuator健康检查工具

注意：Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。

SpringBoot快速入门(手动)

需求：搭建SpringBoot工程，定义HelloController.hello()方法，返回”Hello SpringBoot!”。

实现步骤：

①创建Maven项目

②导入SpringBoot起步依赖

<!--springboot工程需要继承的父工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
    </parent>

    <dependencies>
        <!--web开发的起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

③定义Controller

@EnableAutoConfiguration //不在web类中添加此注解的话,可能会启动报错.https://blog.csdn.net/Pei_hua100/article/details/102455223 如果是通过Ider快速创建SpringBoot工程,则WEB类不需要这个注解
@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello(){
        return " hello Spring Boot !";
    }
}

④编写引导类

/**
 * 引导类。 SpringBoot项目的入口
 */
@SpringBootApplication
public class HelloApplication {

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

⑤启动测试

内置了tomcat，默认启动端口为8080

一.快速构建SpringBoot工程(自动)

*start.spring.io 改成 https://start.aliyun.com*

这是因为阿里云的源服务器位于国内,提供的


原理上是从https://start.spring.io/或https://start.aliyun.com下载压缩好的zip包，然后解压成项目代码

二.SpringBoot配置-配置文件分类

大致用法

SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用 Resources目录下的application.properties或者application.yml（application.yaml）进行配置。

这里我们推荐使用yaml格式的配置文件,因为yaml的配置语法更加规范和便于理解.

1. 默认配置文件名称：application
2. 在同一级目录下优先级为：properties>yml > yaml

例如：配置内置Tomcat的端口

OR properties大致用法

# 会被springBoot自动引用的配置语法(因为server.port是用于设置tomcat端口的)
server.port=8080

# 不会被自动引用的配置语法,多用于我们自己的业务逻辑里头
name=zhangsan

OR yml大致用法

# 会被springBoot自动引用的配置语法(因为server.port是用于设置tomcat端口的)
server: 
	port: 8080
	
# 不会被自动引用的配置语法,多用于我们自己的业务逻辑里头
# 此处为键值对数据,在yaml配置格式中的键值对语法下,数据值前面(即冒号':'后面)需要有空格
	name: zhangsan

三.SpringBoot配置

一.yaml数据定义格式

对象(map)：键值对的集合。

person:  
   name: zhangsan
   age: 18
# 行内写法
person: {name: zhangsan,age: 18}

数组：一组按次序排列的值

address:
  - beijing
  - shanghai
# 行内写法
address: [beijing,shanghai]

纯量(常量)：单个的、不可再分,改变的值.在即使当作成员变量引用后进行赋值,也无效

msg1: 'hello \n world'  # 单引忽略转义字符
msg2: "hello \n world"  # 双引识别转义字符

参数引用

(在yaml配置文件中,某个参数引用其它参数)

name: lisi 
person2: 
	name: lisi
person:
  name: ${person2.name} # 引用上边定义的name值

二.在java中获取配置文件的数据

@Value

   #获取普通配置
   @Value("${name}")
    private String name;
    #获取对象属性
    @Value("${person.name}")
    private String name2;
   	#获取数组
    @Value("${address[0]}")
    private String address1;
  	#获取纯量
    @Value("${msg1}")
    private String msg1;

Evironment(不推荐)

@Autowired
 private Environment env;

System.out.println(env.getProperty("person.name"));

 System.out.println(env.getProperty("address[0]"));

三.将配置文件的数据封装到实体类

OR 封装普通数据到实体类

实体类示例:

@Component //表示该类被Spring所识别,可以引用.
@ConfigurationProperties //表示SpringBoot可以将yaml中的配置信息封装到这里头,加入该注解后,ider会工具栏下方会出现一个红条,这不影响运行
public class PojoTest {

    private String name;
    private String[] ranking;
    private String constant;

    @Override
    public String toString() {
        return "PojoTest{" +
                "name='" + name + '\'' +
                ", ranking=" + Arrays.toString(ranking) +
                ", constant='" + constant + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String[] getRanking() {
        return ranking;
    }

    public void setRanking(String[] ranking) {
        this.ranking = ranking;
    }

    public String getConstant() {
        return constant;
    }

    public void setConstant(String constant) {
        this.constant = constant;
    }
}

OR 封装配置文件中的对象到实体类

准备:pom中添加配置注解生成器

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-configuration-processor</artifactId>
	<optional>true</optional>
</dependency>

可以在配置文件中，直接使用编写的配置对象，出现提示。

实体类示例:

@Component //表示该类被Spring所识别,可以引用.
@ConfigurationProperties(prefix = "serverInfoOfObject") //表示SpringBoot可以将yaml中的配置信息封装到这里头,加入该注解后,ider会工具栏下方会出现一个红条,这不影响运行
                                                            //  prefix属性用于将配置文件中的指定对象封装到实体类中,属性值为yaml配置中的对象名
public class PojoTestOfObject {
    private String serverAddress;
    private String port;
    private String protocol;

    public String getServerAddress() {
        return serverAddress;
    }

    public void setServerAddress(String serverAddress) {
        this.serverAddress = serverAddress;
    }

    public String getPort() {
        return port;
    }

    public void setPort(String port) {
        this.port = port;
    }

    public String getProtocol() {
        return protocol;
    }

    public void setProtocol(String protocol) {
        this.protocol = protocol;
    }
}

SpringBoot多文档配置

概念

profile是用来完成不同环境下，配置动态切换功能的。比如我们有三个数据库,一个是开发用的,一个是测试用的,一个是上线用的.那么我们可以创建多个配置文件,在不同时机切换到对应的配置文件.

步骤一.进行多文档配置

OR.多个实体文件配置方式

提供多个配置文件，每个代表一种环境。

​ application-dev.properties/yml 开发环境(DEV)

​ application-test.properties/yml 测试环境(FAT)

​ application-pro.properties/yml 生产环境(PRO|PROD)

OR.Yaml内部多文档配置方式

在yml中使用 — 分隔不同配置

YAML 文件可以由一或多个文档组成（也即相对独立的组织结构组成），
文档间使用**“—”**（三个横线）在每文档开始作为分隔符。
同时，文档也可以使用“…”（三个点号）作为结束符（可选）。

步骤二.启动多文档配置

OR.IDEA多文档启动方式

注意：通过如果是通过idea启动，且是在唯一一个yaml文件下有多个配置的，那么就需要在Run/Debug Configurations窗口中根据yaml里头的配置数量来复制出相应数量的SpringBoot程序，从而逐个设置启动参数。
下列两种idea的多配置启动方式，都是以此举例的。

OR.设置VM options参数

在VM options参数中配置：-Dspring.profiles.active=配置文件名的任意部分

OR.设置Program arguments参数

在Program arguments参数中配置：spring.profiles.active=配置文件名的任意部分

OR.Shell命令启动方式

• 命令行参数方式：java –jar xxx.jar --spring.profiles.active=配置文件名的任意部分

• 直接用Windows PowerShell命令行激活

最终配置文件会被打包到jar包中，所以使用虚拟机参数/命令行参数相对比较合理

启动jar包命令：

java - jar -Dspring.profiles.active=配置文件名的任意部分 xxx.jar

java –jar xxx.jar --spring.profiles.active=配置文件名的任意部分

SpringBoot配置-项目内部配置文件加载顺序(了解)

加载顺序为上文的排列顺序，高优先级配置的属性会生效

• file:./config/：当前项目下的/config目录下
• file:./ ：当前项目的根目录
• classpath:/config/：classpath的/config目录
• classpath:/ ：classpath的根目录

多个文件都会加载，只是重复的内容会按上面的顺序覆盖

SpringBoot配置-项目外部配置加载顺序(了解)

外部配置文件的使用是为了对能不文件的配合

1.命令行

java -jar app.jar --name="Spring“ --server.port=9000

2.指定配置文件位置

 java -jar myproject.jar --spring.config.location=/usr/local/config/application.properties

3.外部不带profile的properties文件

    classpath:/config/application.properties
    classpath:/application.properties

文档: https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config

四.SpringBoot整合框架

OR SpringBoot整合Junit

1. 搭建SpringBoot工程
2. 引入starter-test起步依赖

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

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

3. 编写测试类

/**
 * 测试类
 */

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootJunitApplication.class )
public class UserServiceTest {

    @Test
    public void test(){
        System.out.println(111);
    }
}

4.测试

测试代码要在引导类的主包或者子包中

OR SpringBoot整合Mybaits

注意:在SpringBoot下,Dao的xml配置文件不需要同Dao类的路径一致.只是需要在application.yml(或application.properties)配置文件中指定该Dao的xml配置文件路径即可(需要指定xml文件名,可以使用*作为通配符)

①搭建SpringBoot工程

②引入mybatis起步依赖，添加mysql驱动

<dependencies>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.27</version>
            <!--<scope>runtime</scope>-->
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

③编写DataSource和MyBatis相关配置

application.yml

# datasource
spring:
  datasource:
    url: jdbc:mysql:///springboot
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver


# mybatis
mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml # mapper映射文件路径
  type-aliases-package: com.itheima.springbootmybatis.domain

  # config-location:  # 指定mybatis的核心配置文件

④定义表和实体类

public class User {
    private int id;
    private String username;
    private String password;


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

⑤编写dao和mapper文件/纯注解开发

编写dao

@Mapper
//@Repository
public interface UserXmlMapper {

    public List<User> findAll();
}

mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.springbootmybatis.mapper.UserXmlMapper">
    <select id="findAll" resultType="user">
        select * from t_user
    </select>
</mapper>

纯注解开发(可选)

@Mapper
@Repository
public interface UserMapper {

    @Select("select * from t_user")
    public List<User> findAll();
}

⑥测试

OR SpringBoot整合redis

注意:SpringBoot在整合Redis时,所引用的Redis依赖并非为此前常用的Jedis.
而是lettuce

①搭建SpringBoot工程

②引入redis起步依赖

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

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

③配置redis相关属性

spring:
  redis:
    host: 127.0.0.1 # redis的主机ip
    port: 6379

④注入RedisTemplate模板

⑤编写测试方法，测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootRedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testSet() {
        //存入数据
        redisTemplate.boundValueOps("name").set("zhangsan");
    }

    @Test
    public void testGet() {
        //获取数据
        Object name = redisTemplate.boundValueOps("name").get();
        System.out.println(name);
    }

}