SpringBoot学习笔记一：基础内容

SpringBoot基础内容

SpringBoot概述

SpringBoot：SpringBoot提供了一种快速使用Spring的方式，基于约定优于配置的思想，可以让开发人员不必在配置与业务逻辑之间进行切换，大大提高了开发效率。

Spring缺点

1. 配置繁琐

   虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。
   所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但它要求的回报也不少。

2. 依赖繁琐

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

SpringBoot功能

1. 自动配置

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

2. 起步依赖：依赖传递

   起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。
   简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

3. 辅助功能

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

   注：SpringBoot提供嵌入式服务器，默认Tomcat，所以web应用无需打成war包，打成jar包即可。

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

SpringBoot快速入门

需求

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

实现步骤

1. 创建Maven项目
2. 导入SpringBoot起步依赖
3. 定义Controller
4. 编写引导类
5. 启动测试

2、pom.xml

  <!--  SpringBoot工程需要继承的父工程-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.0</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <dependencies>
    <!--    web开发起步依赖-->
    <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>

3、HelloController.java

@RestController
public class HelloController {

  @RequestMapping("/hello")
  public String hello(){
    return "hello springboot";
  }

}

4、引导类HelloApplication.java

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

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

}

总结

1. SpringBoot在创建项目时，使用jar的打包方式。
2. SpringBoot的引导类，是项目入口，运行main方法就可以启动项目。
3. 使用SpringBoot和Spring构建的项目，业务代码编写方式完全一样。

SpringBoot项目快速构建

选择Spring Initializr

resources文件夹中目录结构

• static：保存所有的静态资源：js/css/images等

  • 可以通过浏览器地址栏直接访问

  • 在该文件夹下创建index.html，该页面会被默认为访问的首页。即在地址栏中输入http://localhost:8080可以直接访问该页面，不用其他配置。

  • 如果该文件夹下还有其他静态文件夹，需要在application.properties中配置

    • spring.mvc.static-path-pattern=/static/**  否则该文件下的静态文件不能被引用或者访问
      

• templates：保存所有的模板页面：（Springboot默认jar包使用嵌入式Tomcat，默认不支持JSP页面）；可以使用模板引擎

  • #配置模板引擎
              spring.thymeleaf.prefix=classpath:/templates/
              spring.mvc.view.prefix=classpath:/templates/
              spring.mvc.view.suffix=.html（注：此处填写自己页面对应的后缀名，我的是html页面）
    

• application.properties

SpringBoot起步依赖原理分析

1) spring-boot-starter-parent

2)spring-boot-starter-web

小结

• 在spring-boot-starter-parent中定义了各种技术的版本信息，组合了一套最优搭配的技术版本。
• 在各种starter中，定义了完成该功能需要的坐标合集，其中大部分版本信息来自于父工程。
• 我们的工程继承parent，引入starter后，通过依赖传递，就可以简单方便获得需要的jar包，并且不会存在版本冲突等问题。

SpringBoot配置

配置文件分类

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

• properties

  server.port=8080
  

• yml:

  server:
  	port: 8080
  	path: /index.html
  

• SpringBoot提供了2种配置文件类型：properties和yml/yaml

• 默认配置文件名称：application

• 在同一级目录下优先级为：properties > yml > yaml

YAML

YAML文件是以数据为核心的，比传统的xml方式更加简洁。YAML文件的扩展名可以使用.yml或者.yaml。

YAML基本语法

• 大小写敏感
• 数据值前边必须有空格，作为分隔符
• 使用缩进表示层级关系
• 缩进时不允许使用Tab键，只允许使用空格（各个系统Tab对应的空格数目可能不同，导致层次混乱）
• 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
• # 表示注释

YAML数据格式

• 对象（map）：键值对的集合

  person:
    name: zhangsan
  # 行内写法
  person: {name: zhangsan}
  

• 数组：

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

• 纯量：单个的、不可再分的值

  msg1: 'hello \n world'  # 单引号忽略转义字符，原样输出
  msg2: "hello \n world"  # 双引号识别转义字符，转义输出
  

YAML参数引用

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

配置文件中可以使用随机数

${random.value}
${random.int}
${random.int(10)}
${random.value}

小结

1. 配置文件类型
   • properties：和以前一样
   • yml/yaml：注意空格
2. yaml：简洁，以数据为核心
   • 基本语法
     • 大小写敏感
     • 数据值前边必须有空格，作为分隔符
     • 使用空格缩进表示层级关系，相同缩进表示同一级
   • 数据格式
     • 对象
     • 数组：使用 “-” 表示数组每个元素
     • 纯量
   • 参数引用
     • ${key}

读取配置文件内容

1. @Value
2. Environment
3. @ConfigurationProperties

@Value方式

  @Value("${name}")	//键值对  private String name;  @Value("${person.name}")	//键值对  private String name2;  @Value("${address[0]}")	//数组  private String address1;  @Value("${msg1}")		//单引号纯量  private String msg1;  @Value("${msg2}")		//双引号纯量  private String msg2;

Environment方式

  @Autowired  private Environment env;    System.out.println(env.getProperty("person.name"));  System.out.println(env.getProperty("address[0]"));

@ConfigurationProperties

@Component@ConfigurationProperties(prefix = "person")public class Person {  private String name;  private int age;	...}

注：@Value获取值和@ConfigurationProperties获取值比较

	@ConfigurationProperties	@Value
功能	批量注入配置文件中的属性	单个指定
松散语法	支持	不支持
SpEL	不支持	支持
JSR303数据校验	支持	不支持

添加@ConfigurationProperties和@Validated注解，支持校验功能。比如@Email,@NotBlank

@PropertySource指定注入配置文件

@PropertySource只对properties文件生效，对yml/yaml不生效

@PropertySource(value = {"classpath:person.properties"})

SpringBoot推荐给容器中添加组件的方式：全注解方式

@Configurationpublic class MyAppConfig {  //将方法的返回值添加到容器中，容器中该组件默认的id就是方法名  @Bean  public Person person() {    return new Person();  }  }

profile

我们在开发Spring Boot应用时，通常同一套程序会被安装到不同环境，比如：开发、测试、生产等。其中数据库地址、服务器端口等等配置都不同，如果每次打包时，都要修改配置文件，那么非常麻烦。profile功能就是来进行动态配置切换的。

1. profile配置方式
   • 多profile文件方式
   • yml多文档方式
2. profile激活方式
   • 配置文件
   • 虚拟机参数
   • 命令行参数

多profiles文件方式

application-devapplication-proapplication-test

在application.properties中激活profiles

spring.profiles.active=dev

yml多文档方式

---server:  port: 8082spring:  profiles: dev---server:  port: 8082spring:  profiles: dev

虚拟机参数激活

VM options：

-Dspring.profiles.active=dev

命令行参数激活

Program arguments:

--spring.profiles.active=dev

profile-小结

1. profile是用来完成不同环境下，配置动态切换功能的。
2. profile配置方式
   • 多profile文件方式：提供多个配置文件，每个代表一种环境。
     • application-dev.properties/yml 开发环境
     • application-test.properties/yml 测试环境
     • application-pro.properties/yml 生产环境
   • yml多文档方式：
     • 在yml中使用 — 分隔不同配置
3. profile激活方式
   • 配置文件： 在配置文件中配置：spring.profiles.active=dev
   • 虚拟机参数：在VM options 指定：-Dspring.profiles.active=dev
   • 命令行参数：java –jar xxx.jar --spring.profiles.active=dev

内部配置加载顺序

Springboot程序启动时，会从以下位置加载配置文件：

1. file:./config/：当前项目下的/config目录下
2. file:./ ：当前项目的根目录
3. classpath:/config/：classpath的/config目录
4. classpath:/ ：classpath的根目录

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

外部配置加载顺序

外部命令行配置 > 内部配置

SpringBoot整合其他框架

SpringBoot整合JUnit

1. 搭建SpringBoot工程
2. 引入starter-test起步依赖
3. 编写测试类
4. 添加测试相关注解
   • @RunWith(SpringRunner.class)
   • @SpringBootTest(classes=启动类.class)
5. 编写测试方法

注：SpringBoot的高级版本使用junit5进行单元测试，无需RunWith注解即可进行测试。应该是2.0及以上版本都是如此，至少2.4.0是如此。

SpringBoot整合redis

1. 搭建SpringBoot工程
2. 引入redis起步依赖
3. 配置redis相关属性
4. 注入RedisTemplate模板
5. 编写测试方法，测试

@Autowiredprivate RedisTemplate redisTemplate;@Testpublic void setTest() {  redisTemplate.boundValueOps("name").set("tom");}@Testpublic void getTest() {  Object name = redisTemplate.boundValueOps("name").get();  System.out.println("name = " + name);}

SpringBoot整合MyBatis

1. 搭建SpringBoot工程
2. 引入MyBatis起步依赖，添加mysql驱动
3. 编写DataSource和MyBatis相关配置
4. 定义表和实体类
5. 编写dao和mapper文件/纯注解开发
6. 测试

第二步：

添加 MyBatis Framework 和 MySQL Driver

第三步：

# dataSourcespring:  datasource:    url: jdbc:mysql://127.0.0.1:3306/test?serverTimezone=GMT%2B8    username: root    password: root    driver-class-name: com.mysql.cj.jdbc.Driver

整合Driud数据源

1、引入druid依赖

2、更新配置文件

spring:  datasource:    url: jdbc:mysql://127.0.0.1:3306/test?serverTimezone=GMT%2B8    username: root    password: root    driver-class-name: com.mysql.cj.jdbc.Driver    type: com.alibaba.druid.pool.DruidDataSource

druid详细配置

# 数据源配置spring:    datasource:        type: com.alibaba.druid.pool.DruidDataSource        driverClassName: com.mysql.cj.jdbc.Driver        druid:            # 主库数据源            master:                url: jdbc:mysql://localhost:3306/ry?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8                username: root                password: root            # 从库数据源            slave:                # 从数据源开关/默认关闭                enabled: false                url:                 username:                 password:             # 初始连接数            initialSize: 5            # 最小连接池数量            minIdle: 10            # 最大连接池数量            maxActive: 20            # 配置获取连接等待超时的时间            maxWait: 60000            # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒            timeBetweenEvictionRunsMillis: 60000            # 配置一个连接在池中最小生存的时间，单位是毫秒            minEvictableIdleTimeMillis: 300000            # 配置一个连接在池中最大生存的时间，单位是毫秒            maxEvictableIdleTimeMillis: 900000            # 配置检测连接是否有效            validationQuery: SELECT 1 FROM DUAL            testWhileIdle: true            testOnBorrow: false            testOnReturn: false            webStatFilter:                 enabled: true            statViewServlet:                enabled: true                # 设置白名单，不填则允许所有访问                allow:                url-pattern: /druid/*                # 控制台管理用户名和密码                login-username: ruoyi                login-password: 123456            filter:                stat:                    enabled: true                    # 慢SQL记录                    log-slow-sql: true                    slow-sql-millis: 1000                    merge-sql: true                wall:                    config:                        multi-statement-allow: true

通过注解开发，不需要配置MyBatis

第五步

@Mapper@Repositorypublic interface UserMapper {  @Select("select * from userinfo")  List<User> findAll();}

第六步：测试

@SpringBootTestclass SpringbootMybatisApplicationTests { @Autowired private UserMapper userMapper; @Test void findAllTest() {  List<User> list = userMapper.findAll();  System.out.println(list); }}

Xml方式开发

@Mapper@Repositorypublic interface UserXmlMapper {    List<User> findAll();  }

UserMapper.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.example.springbootmybatis.mapper.UserXmlMapper">  <select id="findAll" resultType="user">    select * from userinfo  </select></mapper>

application.yml配置MyBatis信息

# mybatismybatis:  mapper-locations: classpath:mapper/*Mapper.xml  # mapper映射文件路径  type-aliases-package: com.example.springbootmybatis.domain# config-location:  # 指定核心配置文件

SpringBoot JPA方式

1. 引入spring-boot-starter-data-jpa
2. 配置文件打印SQL语句
3. 创建Entity标注JPA注解
4. 创建Repository接口继承JpaRepository
5. 测试

Spring Data

Spring Data项目的目的是为了简化构建基于Spring框架应用的数据访问技术，包括非关系数据库、关系型数据库、云数据服务等。

整合SpingData JPA

JPA ：ORM(Object Relational Mapping)

1、编写一个实体类（Bean）和数据表进行映射，并且配置好映射关系

//使用JPA注解配置映射关系@Entity //告诉jpa这是一个实体类（和数据表映射的类）@Table(name = "userinfo") //@Table来指定和哪个数据表对应；如果省略默认是类小写public class User {  @Id  @GeneratedValue(strategy = GenerationType.IDENTITY) //自增主键  private Integer userId;  @Column(name = "username", length = 50) //这是和数据表对应的一个列  private String username;  @Column //省略默认列名就是属性  private String password;

2、编写一个Dao接口来操作实体类对应的数据表

//继承JpaRepository来完成对数据库的操作public interface UserRepository extends JpaRepository<User, Integer> {}

3、基本配置

spring:  datasource:    url: jdbc:mysql://127.0.0.1:3306/test?serverTimezone=GMT%2B8    username: root    password: root    driver-class-name: com.mysql.cj.jdbc.Driver    type: com.alibaba.druid.pool.DruidDataSource  jpa:    hibernate:      # 更新或者创建数据表结构      ddl-auto: update    # 控制台打印sql    show-sql: true

4、测试

@Testvoid getUserTest() {  User user = userRepository.findById(1).get();  System.out.println(user);}

JPA多表查询

@OneToMany、@ManyToOne

以Author（作者类）、Book(书籍类)为例

Author.java

package com.example.demo;import javax.persistence.*;import java.util.List;@Entitypublic class Author {    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    private int Id;    private String name;    private int age;    @OneToMany( mappedBy = "author" )//作者与书 是一对多的关系，mappedBy 指的是通过  book表中的author字段来映射，mappedBy一般用来设置为关联表的外键字段，这里Book实体中的外键字段为author，则设置为author,设置为别的字段没法进行连接查询    private List<Book> books;    public void setId(int id) {        Id = id;    }    public void setName(String name) {        this.name = name;    }    public void setAge(int age) {        this.age = age;    }    public void setBooks(List<Book> books) {        this.books = books;    }    public int getId() {        return Id;    }    public String getName() {        return name;    }    public int getAge() {        return age;    }    public List<Book> getBooks() {        return books;    }}

Book.java

package com.example.demo;import javax.persistence.*;@Entitypublic class Book {    @javax.persistence.Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    private int Id;    private String name;    private float price;    @JoinColumn    @ManyToOne(cascade = CascadeType.ALL)    //book与作者是多对一的关系，JoinColumn用来加入外键，Cacade 用来级联，CascadeType.Remove 指级联删除，被关联表元祖删除，关联表的对应元祖也会被删除，这里book是关联表，通过外键字段author(在数据库中为author_id外键）关联author表，author是被关联表    // 同样 CascadeType.Persist则是级联存储，其他几个 对应他们的本身单词意思    //CascadType.ALL 则包含了所有级联操作    private Author author;    public void setId(int id) {        Id = id;    }    public void setName(String name) {        this.name = name;    }    public void setPrice(float price) {        this.price = price;    }    public void setAuthor(Author author) {        this.author = author;    }    public int getId() {        return Id;    }    public String getName() {        return name;    }    public float getPrice() {        return price;    }    public Author getAuthor() {        return author;    }}

BookRepository.java

package com.example.demo;import org.springframework.data.repository.CrudRepository;public interface AuthorRepository extends CrudRepository<Author,Integer> {}

AuthorRepository.java

package com.example.demo;import org.springframework.data.repository.CrudRepository;public interface BookRepository extends CrudRepository<Book,Integer> {}