SpringBoot

Spring Boot

1.微服务

1.1什么是微服务架构

微服务是一种架构风格（可以对比mvc三层架构，mvvm前端架构对比），要求我们在开发一个应用的时候，这个应用必须构建成一系列小的服务组合。可以通过http的方式进行互通。其演变过程：

1.1.1单体应用架构

单体应用架构（all in one)是指，将一个应用中的所有应用服务都封装在一个应用中

好处：易于开发和测试，方便部署

缺点：修改任何一处都需要关掉服务器，重新打包和部署。不利于大型项目的维护和分工

1.1.2微服务架构

打破all in one的架构方式，每个工功能元素独立起来。独立的元素动态组合，需要哪一些功能元素就拿来组合，

简而言之，微服务架构样式[1]是一种将单个应用程序开发为一组小服务的方法，每个小服务都在自己的进程中运行并与轻量级机制（通常是HTTP资源API）进行通信。这些服务围绕业务功能构建，并且可以由全自动部署机制独立部署。这些服务的集中管理几乎没有，可以用不同的编程语言编写并使用不同的数据存储技术。

相关文献推荐：微服务论文（马丁·福勒） - 简书 (jianshu.com)

一个大型系统的微服务架构，就像一个复杂交织的神经网络，每个神经元就是一个功能元素，他们各自完成自己的功能，然后通过http相互请求调用，但是这种庞大的系统架构给部署和运维带来很大的难度，即spring带来了大型分布式服务的全套，全程产品

springboot构建一个个独立的微服务应用单元，帮我们快速构建一个应用
springcloud完成大型分布式网络服务调用，实现分布式
spring cloud data flow在分布式中间进行流式数据计算，批处理

组件是独立可替换和可升级的软件单元。

我们将库定义为链接到程序中并使用内存中函数调用进行调用的组件

而服务则是进程外组件，它们通过某种机制（例如Web服务请求或远程过程调用）进行通信。（这与许多OO程序中的服务对象的概念不同[3]。）

2.第一个Spring Boot程序

springboot提供快速生成的网站，官网下载后解压导入idea

同时idea也集成了该网站功能，直接使用idea创建一个springboot项目

也可生成一个空白的springboot项目，然后导入web包

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

在application.properties包里，基本配置可以更改端口号：

server.port=8081

2.1自动装配原理

springboot是通过main方法下的SpringApplication.run方法启动的,启动的时候他会调用refshContext方法,先刷新容器,然后根据解析注解或者解析配置文件的形式祖册bean,而它是通过启动类的SpringBootApplication注解进行开始解析的,他会根据EnableAutoConfiguration开启自动化配置,里面有个核心方法ImportSelect选择性的导入,根据loadFanctoryNames根据classpash路径以MATA-INF/spring.factorces下面以什么什么EnableAutoConfiguration开头的key去加载里面所有对应的自动化配置,他并不是把这一百二十多个自动化配置全部导入,在他每个自动化配置里面都有条件判断注解,先判断是否引入相互的jar包,再判断容器是否有bean再进行注入到bean容器

pom.xml

核心依赖都在父工程中

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.4</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

启动器

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

启动器：就是springboot的启动场景。如spring-boot-starter-web会自动导入web环境所有依赖
springboot会将所有功能场景，编程一个个启动器。需要什么功能，只需要找到所需要启动器即可

主程序（@SpringBootApplication 主程序类标志）

springboot所有的自动配置文件都是在启动的时候扫描并加载：

spring.factories所有的自动配置类都在这里，但是不一定生效，因为需要满足ConditionalOnClass（)里面所有的条件，其中就必须包括启动类，只有导入了相关的star启动器，这些自动装配的包才有效

SpringBoot在启动的时候，从类路径下/META-INF/spring.factories获取指定的值
将这些自动配置的类导入容器，自动配置类就会生效，帮我们进行自动配置
以前我们需要自动配置的东西，现在不需要了
整合javaEE，解决方案和自动配置的东西都在Spring-boot-autoconfigure下
它会把所有需要导入的组件，以类名的方式返回这些组件，这些组件就会被添加到容器
容器中也会存在非常多的XXXAutoConfigure的文件（@Bean），就是这个类给容器导入了这个场景所需要的所有组件并自动配置

2.2主程序
```
 SpringApplication.run（）
```

1.推断应用的类型是普通的项目还是web项目

2.查找并加载所有可用初始化器，设置到initializers属性中

3.找出所有的应用程序监听器，设置到listeners中

4.推断并设置main方法的定义类，找到运行的主类（加载主类）

3.配置文件

yaml是一种标记语言(对空格的要求十分严格），语法： k: v

# 普通的key-value
name: tzf

#对象
student:
  name: tzf
  age: 18
  
#行内写法
student: {name: tzf , age: 18}

#数组
pets:
  -cat
  -dog
  -pig
  
pets: [cat,dog,pig]

xxxconfigeration组件装配了大量的xxxpropertiesz自动装配类，我们在yaml的配置其实就是在给xxxpropertiesz自动装配类的属性赋值，以达到自动配置的效果。

另外我们可以通过在yaml配置debug=true在控制台输出查看哪些配置以及开启，哪些还未开启

还有就是并不是所有的xxxautoconfigeration自动装配都会起作用，因为这些自动装配类内部都有@ConditionalOneClass(xxx,xxx,xxx),只有满足@ConditionalOneClass这个注解里面所有条件，被注解的配置类才会起作用，而这些条件就包括一个个的start启动类

3.1个属性赋值的几种方式

1.使用@Value("...")注解

@Value("旺财")
    private String name;
    @Value("1")
    private Integer age;

2.使用yml配置文件对对象赋值

注意：实体类需要用到@ConfigurationProperties(prefix = "person"),与配置文件yaml里的对象相对应

Person

@Component
@Data
@AllArgsConstructor
@NoArgsConstructor
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> map;
    private List<Object> lists;
    private Dog dog;
}

yaml

person:
  name: tzf
  age: 18
  happy: true
  birth: 2022/10/14
  map: {k1: v1,k2: v2}
  lists:
    - cat
    - dag
    - girl
  dog:
    name: 旺财
    age: 1

测试类

@SpringBootTest
class Spring01HelloworldApplicationTests {
    @Autowired
    Person person;
    @Test
    void contextLoads() {
        System.out.println(person);
    }

}

3.使用.propertysource配置文件（了解，这里不做详细介绍）

3.2配置文件的优先级

1.file:./config/ (根目录下的config包下的配置文件)

2.file:./ （根目录下的配置文件）

3.classpath:/config/ （java/resource下的config下的配置文件）

4.classpath:/ （java/resource下的配置文件）

3.3springboot的多环境配置文件，可以选择激活哪一个配置文件

server:
  port: 8080
spring:
  profiles:
    active: test
---

server:
  port: 8081
spring:
  profiles: dev
---

server:
  port: 8082
spring:
  profiles: test
  
#最后测试的结果用的是8082端口号

下一个问题，配置文件能配那些设置？

其实xxx.properties或xxx.yml文件能配置的东西是固定，@ConfigurationProperties()与你写的配置文件绑定，其默认值都写在@xxxproperties里面，如果想修改默认值，按照对应配置规则去配置

精髓：

1、SpringBoot启动会加载大量的自动配置类

2、我们看我们需要的功能有没有在SpringBoot默认写好的自动配置类当中；

3、我们再来看这个自动配置类中到底配置了哪些组件；（只要我们要用的组件存在在其中，我们就不需要再手动配置了）

4、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们只需要在配置文件中指定这些属性的值即可；

xxxxAutoConfigurartion：自动配置类；给容器中添加组件

xxxxProperties:封装配置文件中相关属性；

3.4读取yaml数据方式

方式一：

使用@Value读取单个数据，属性名引用方式：${一级属性名.二级属性名……}

lesson: SpringBoot 

server: 

  port: 82 

enterprise: 

  name: itcast 

  age: 16 

  tel: 4006184000 

  subject:

        - Java 

        - 前端

        - 大数据

@RestController
@RequestMapping("/books")
public class BookController {
@Value("${lesson}")
private String lessonName;
@Value("${server.port}")
private int port;
@Value("${enterprise.subject[1]}")
private String[] subject_01;
}

baseDir: /usr/local/fire
center:
dataDir: ${baseDir}/data
tmpDir: ${baseDir}/tmp
logDir: ${baseDir}/log
msgDir: ${baseDir}/msgDir

方式二：

封装全部数据到Environment对象

lesson: SpringBoot 

server: 

  port: 82 

enterprise: 

  name: itcast 

  age: 16 

  tel: 4006184000 

  subject:

        - Java 

        - 前端

        - 大数据

@RestController
@RequestMapping("/books")
public class BookController {
     @Autowired
    private Environment env;
     @GetMapping("/{id}")
public String getById(@PathVariable Integer id){
    
   System.out.println(env.getProperty("lesson"));
    System.out.println(env.getProperty("enterprise.name"));
System.out.println(env.getProperty("enterprise.subject[0]"));
return "hello , spring boot!";
     }
}

方式四：

自定义对象封装指定数据的作用

datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
username: root
password: root

@Component
@ConfigurationProperties(prefix = "datasource")
public class DataSource {
private String driverClassName;
private String url;
private String userName;
private String password;
}

4.JSR303数据校验

松散绑定：即"ab"可以用“a-b"表示

JSR303数据校验：这个就是我们可以在字段是增加一层过滤器验证，可以保证数据的合法性

使用需要先添加依赖

<!-- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator -->
<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.0.16.Final</version>
</dependency>

类似于html页面的input的type属性，指定类型

<input type="text">

springboot中使用jsp303需要@Validated注解

Bean Validation 中内置的 constraint

Hibernate Validator 附加的 constraint

@Validated
public class Person {
    @Email(message = "邮件文件格式错误")
    private String email;//属性email必须符合邮件格 
}

静态资源导入：

1.在springboot中，我们可以使用一下方式处理静态资源

webjars localhost:8080/webjars/
public,static,/**,resources localhost:8080/

优先级：resources>static(默认)>public

5.Thymeleaf引擎模板

之前我们收到前端的html页面，会把它转换成jsp页面，jsp页面可以很轻松把后台数据显示到前端上面，并且实现交互，但是springboot项目是以jar包，不是以war包，并且我们使用的嵌入式的tomcat不支持jsp。然而纯静态页面无法实现交互，所以springboot推荐我们使用模板引擎，如freemarker，其实jsp也是一种模板引擎，以及springboot推荐我们使用的thymeleaf。

1.导入相关启动器依赖

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

2.创建templates包，将静态网页放在templates中

原因：约定大于配置，springboot的配置文件ThymeleafProperties表明文件的前缀和后缀

public static final String DEFAULT_PREFIX = "classpath:/templates/";
public static final String DEFAULT_SUFFIX = ".html";

首页面模式

<!DOCTYPE html>

<html xmlns:th="http://www.thymeleaf.org">

  <head>
    <title>Good Thymes Virtual Grocery</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <link rel="stylesheet" type="text/css" media="all" 
          href="../../css/gtvg.css" th:href="@{/css/gtvg.css}" />
  </head>

  <body>
  
    <p th:text="#{home.welcome}">Welcome to our grocery store!</p>
  
  </body>

</html>

3.语法表达式

具体参考官网：Tutorial: Using Thymeleaf

- Variable Expressions: ${...} 变量
- Selection Variable Expressions: *{...} 选择
- Message Expressions: #{...} 消息
- Link URL Expressions: @{...} URL
- Fragment Expressions: ~{...}

所有的html元素都被thymeleaf接管替代，格式为：th:元素名

例如：th:class="" th:style=""

<div th:text="${name}"></div>

取后端传来的参数‘name'的值，属性为text,使用时为：th:text=""

字符转义（可识别标签）：th:utext=""

遍历的两种方式

<div th:each="user:${users}" th:text="${user}"></div>

<div th:each="user:${users}">[[${user}]]</div>

6.拓展使用springMVC

springboot在自动配置的时候会用到很多组件，会首先看容器中有没有用户配置的文件（如果用户自己配置@Bean)，如果有优先使用用户配置文件，没有才会使用默认配置。有些配置存在多个，比如视图解析器，用户配置和默认配置可以结合使用。

扩展MVC使用即我们自己要编写一个@Configeration注解的类，并且类型为WebMvcConfigurer,还不能加@EnableWebMvc注解，如：

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
    //视图跳转
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/tzf").setViewName("success");
    }
}

注意：springboot中有很多的xxxConfiguration配置类帮助我们扩展配置，只要我们看到这个类型的类，就说明它在修改和扩展原来的配置功能。

7.整合jdbc

补充@Autowired与@Resource区别

@Autowired注解是Spring提供的，而@Resource注解是J2EE本身提供的
@Autowird注解默认通过byType方式注入，而@Resource注解默认通过byName方式注入
@Autowired注解注入的对象需要在IOC容器中存在，否则需要加上属性required=false，表示忽略当前要注入的bean，如果有直接注入，没有跳过，不会报错

yaml配置数据库DataSource：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=tru&characterEncoding=utf-8
    password: 123456
    username: root
    driver-class-name: com.mysql.jdbc.Driver


@RestController
public class JdbcController {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @RequestMapping("/userList")
    public List<Map<String,Object>> userList(){
        String sql="select * from user1";
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
        return maps;
    }

    @RequestMapping("/userAdd")
    public String addUser(){
        String sql="insert into user1 values(3,'aa','12345')";
        jdbcTemplate.update(sql);
        return "add-Success";
    }

    @RequestMapping("/userupdate/{id}")
    public String updateUser(@PathVariable("id")int id){
        String sql="update user1 set name = ?,pwd=? where id="+id;
        Object[] objects = new Object[2];
        objects[0]="tzf6";
        objects[1]="520";
        jdbcTemplate.update(sql,objects);
        return "add-Success";
    }
}

8.自定义数据源（DruidDataSource)

第一种自定义整合：

Druid是阿里开源平台数据库连接池的实现，结合了数据库线程池和日志监控

导包:

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.15</version>
</dependency>
<dependency>
     <groupId>log4j</groupId>
     <artifactId>log4j</artifactId>
     <version>1.2.17</version>
</dependency>

yaml配置data数据源为的druid

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8
    password: 123456
    username: root
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    #   数据源其他配置
    #初始化时建立物理连接的个数
    initial-size: 5
    #最小连接池数量
    min-idle: 5
    #最大连接池数量 maxIdle已经不再使用
    max-active: 20
    #获取连接时最大等待时间，单位毫秒
    max-wait: 60000
    #申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
    test-while-idle: true
    #既作为检测的间隔时间又作为testWhileIdel执行的依据
    time-between-eviction-runs-millis: 60000
    #销毁线程时检测当前连接的最后活动时间和当前时间差大于该值时，关闭当前连接
    min-evictable-idle-time-millis: 30000
    #用来检测连接是否有效的sql 必须是一个查询语句
    #mysql中为 select 'x'
    #oracle中为 select 1 from dual
    validation-query: select 'x'
    #申请连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
    test-on-borrow: false
    #归还连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
    test-on-return: false
    # 是否缓存preparedStatement
    pool-prepared-statements: true
#   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    #配置监拉统计挡成的filters. stat: 监控统计、Log4j:日志记录、waLL: 防御sqL注入
    #如果启用日志记录时报错java.lang.ClassNotFoundException: org.apache.log4j.Priority
    #则导入Log4j 依赖即时，Maven 地址: https://mvnrepository. com/artifact/log4j/log4
    filters: stat,wall,1og4j
    max-pool-prepared-statement-per-connection-size: 20
    use-global-data-source-stat: true
    connect-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

虽然我们配置了druid连接池的其他属性但是不会生效，因为默认使用的是java.sql.Datasource的类来获取属性的，有些属性datasource没有。如果想要配置生效需要手动创建Druid的配置文件

 * 描述：  Spring Boot 手动整合 Druid 连接池
 */
// @Deprecated
@Configuration
public class MyDataSourceConfig {

    /**
     * 配置 Druid 数据源。（Spring Boot 会在 IoC 容器自动读取类型为 DataSource 的对象。故这个 bean 注入后，即与Spring Boot整合好了）
     * @return DruidDataSource 数据源
     * @throws SQLException
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource",ignoreUnknownFields = false) // 读取配置文件中的数据源信息。Druid会以此建立数据库连接
    public DataSource dataSource() throws SQLException {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setFilters("stat"); // 开启
        return druidDataSource;
    }

    /**
     * （非必要）开启前台监控页面对应的 Servlet，并设置密码（通过 http://域名/druid/index.html 即可访问监控页面）
     * 此 Servlet 是由 Druid 提供的 StatViewServlet
     * @return
     */
    @Bean
    public ServletRegistrationBean<StatViewServlet> druidServlet(){
        ServletRegistrationBean<StatViewServlet> statViewServletServletRegistrationBean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
        statViewServletServletRegistrationBean.addInitParameter("loginUsername","root");
        statViewServletServletRegistrationBean.addInitParameter("loginPassword","131121");
        return statViewServletServletRegistrationBean;
    }

    /**
     * （非必要）配置Druid的Filter，用于记录 web 请求记录。
     * 此 Filter 是由 Druid 提供的 WebStatFilter
     * @return
     */
    @Bean
    public FilterRegistrationBean<WebStatFilter> druidFilter(){
        WebStatFilter webStatFilter = new WebStatFilter();
        FilterRegistrationBean<WebStatFilter> webStatFilterFilterRegistrationBean = new FilterRegistrationBean<>(webStatFilter);
        // 除以下路径的访问不记录，其它都会进行记录
        webStatFilterFilterRegistrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        // 记录 session 时，记录下 session 中记录的用户名
        webStatFilterFilterRegistrationBean.addInitParameter("principalSessionName","userName");
        return webStatFilterFilterRegistrationBean;
    }

}

第二种方法使用starter：

导资源包：

此时就不需要Druid的依赖了，starter中已经包含druid的包了

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.16</version>
</dependency>

配置数据源：

  datasource:
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8
    password: 123456
    username: root
    driver-class-name: com.mysql.jdbc.Driver
# 连接池配置：
    druid:
      initial-size: 2 # 初始化时建立物理连接的个数。默认0
      max-active: 10 # 最大连接池数量，默认8
      min-idle: 1 # 最小连接池数量
      max-wait: 2000 # 获取连接时最大等待时间，单位毫秒。
      pool-prepared-statements: false # 是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
      max-pool-prepared-statement-per-connection-size: -1 # 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
      # ……druid节点下的其它参数见官方文档：https://github.com/alibaba/druid/wiki/DruidDataSource%E9%85%8D%E7%BD%AE%E5%B1%9E%E6%80%A7%E5%88%97%E8%A1%A8

      # 启用Druid内置的Filter，会使用默认的配置。可自定义配置，见下方的各个filter节点。
      filters: stat,wall


      # StatViewServlet监控器。开启后，访问http://域名/druid/index.html
      stat-view-servlet:
        enabled: true # 开启 StatViewServlet，即开启监控功能
        login-username: daniel # 访问监控页面时登录的账号
        login-password: 1234 # 密码
        url-pattern: /druid/* # Servlet的映射地址，不填写默认为"/druid/*"。如填写其它地址，访问监控页面时，要使用相应的地址
        reset-enable: false # 是否允许重置数据（在页面的重置按钮）。（停用后，依然会有重置按钮，但重置后不会真的重置数据）
        allow: 192.168.1.2,192.168.1.1 # 监控页面访问白名单。默认为127.0.0.1。与黑名单一样，支持子网掩码，如128.242.127.1/24。多个ip用英文逗号分隔
        deny: 18.2.1.3 # 监控页面访问黑名单


      # 配置 WebStatFilter（StatFilter监控器中的Web模板）
      web-stat-filter:
        enabled: true # 开启 WebStatFilter，即开启监控功能中的 Web 监控功能
        url-pattern: /* # 映射地址，即统计指定地址的web请求
        exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*' # 不统计的web请求，如下是不统计静态资源及druid监控页面本身的请求
        session-stat-enable: true # 是否启用session统计
        session-stat-max-count: 1 # session统计的最大个数，默认是1000。当统计超过这个数，只统计最新的
        principal-session-name: userName # 所存用户信息的serssion参数名。Druid会依照此参数名读取相应session对应的用户名记录下来（在监控页面可看到）。如果指定参数不是基础数据类型，将会自动调用相应参数对象的toString方法来取值
        principal-cookie-name: userName # 与上类似，但这是通过Cookie名取到用户信息
        profile-enable: true # 监控单个url调用的sql列表（试了没生效，以后需要用再研究）

      filter:
        wall:
          enabled: true  # 开启SQL防火墙功能
          config:
            select-allow: true # 允许执行Select查询操作
            delete-allow: false # 不允许执行delete操作
            create-table-allow: false # 不允许创建表
            # 更多用法，参考官方文档：https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE-wallfilter

9.整合mybatis

整体工程预览：

1.导包：

<!--        此依赖不是springboot官方提供的-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

2.实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer id;
    private String name;
    private String ped;

}

3.mapper

@Mapper
@Repository
public interface UserMapper {

    List<User> userList();

    User queryUserById(int id);

    int add(User user);

    int update(User user);

    int delete(int id);
}

4.resource下面配置xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tzf.springboot03mybatis.mapper.UserMapper">
    <select id="userList" resultType="User">
        select * from user1
    </select>

    <select id="queryUserById" resultType="User">
        select * from user1 where id=#{id}
    </select>

    <update id="update" parameterType="User">
        update user1 set name=#{name},pwd=#{pwd} where id=#{id}
    </update>

    <insert id="add" parameterType="User">
        insert into user1(id,name,pwd) values(#{id},#{name},#{pwd})
    </insert>

    <delete id="delete" parameterType="int">
        delete from user1 where id=#{id}
    </delete>

</mapper>

5.yaml配置mybatis

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
#mybatis配置
mybatis:
#起别名
  type-aliases-package: com/tzf/springboot03mybatis/pojo
  #xml文件与mapper绑定
  mapper-locations: classpath:mybatis/mapper/*.xml
  #com\tzf\springboot03mybatis\pojo

6.controller层

@RestController
public class UserController {
    @Autowired(required = false)
    UserMapper userMapper;
// rest行为方法，get查询，post添加，put修改，delete删除
    @GetMapping("/userList")
    public List<User> userList(){
        List<User> userlist = userMapper.userList();
        for (User user:userlist) {
            System.out.println(user);
        }
        return userlist;
    }
    
}

rest行为方法get查询，post添加，put修改，delete删除

注意：

@PathVariablez（“xx”）注解，表示简单参数从路径中获取，xx是路径中的参数名字，与形参绑定
 @RequestBody参数量比较大，如实体类参数，使用该注解用json格式传参

10.springSecurity

安全验证

官方文档：

https://docs.spring.io/spring-security/site/docs/5.5.8/reference/html5

中文文档：

Introduction · Spring Boot 中文文档 (felord.cn)

(http://felord.cn/_doc/_springboot/2.1.5.RELEASE/_book/）

Spring Security 中文文档 :: Spring Security Reference (springdoc.cn)

1.导包

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

11.工程打包与运行

windows环境

可能会遇到的问题：

1.“没有主清单属性”问题，可能是没有引入springboot-maven打包插件

 <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

springboot打的jar包包含maven打的jar包所有内容，以及程序运行所依赖的环境（比如需要的所有jar包）

2.端口占用问题

linux环境

与windows环境基本一致，注意linux前提配置好jar包运行的换将，如SQL环境，jdk环境

12.临时属性

使用临时属性覆盖原有的属性，因此不同文件位置设置属性是有优先级的，优先级高的文件的属性值会会覆盖掉优先级低的属性值

在jar包运行环境下临时属性设置：

1．使用jar命令启动SpringBoot工程时可以使用临时属性替换配置件中的属性

java -jar springboot.jar --server.port=80

2．临时属性添加方式:java -jar工程名.jar --属性名=值
3．多个临时属性之间使用空格分隔
分
4．临时属性必须是当前boot工程支持的属性，否则设置无效

优先级详情：

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

在idea环境设置临时属性：

临时属性实则在启动类中作为args参数传入springboot：

@SpringBootApplication
public class Springboot06SsmApplication {

    public static void main(String[] args) {
        SpringApplication.run(Springboot06SsmApplication.class, args);
        //args="server.port=8081"
    }
}

如果将启动类中的args参数剔除，则不会有临时属性起作用,断开外部临时配置的入口。

如：

@SpringBootApplication
public class Springboot06SsmApplication {

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

同一种文件不同位置优先级：

项目工程/config/application.yml>项目工程/application.yml>resources/config/application.yml>resources/application.yml

不同文件同一位置优先级：

xx.properties>xx.ym>xx.yaml

SpringBoot中4级配置文件
1级: file : config/application.ym 【最高】
2级: file : application.yml
3级: classpath: config/application.yml

4级: classpath: application.yml【最低】

2.作用:
1级与2级留做系统打包后设置通用属性，1级常用于运维经理进行线上整体项目部署方案调控

3级与4级用于系统开发阶段设置通用属性，3级常用于项目经理进行整体项目属性调控

13.多环境开发

yaml版本

spring:
  profiles:
    active: dev


#生产环境
---
spring:
  profiles: dev
server:
  port: 8080

#开发环境
---
spring:
  profiles: tt      #格式过时
server:
  port: 8082
#测试环境
---
spring:
  config:
    activate:
      on-profile: zf  #新格式
server:
  port: 8083

properties版本：

与yaml相同，yaml现在也是使用冲突文件分开的形式，不再写在一个文件里了

多环境分组管理：

spring:
  profiles:
    active: dev #启动的是dev组而不是单独的某个文件
 #   include: devDB,devMVC 之前运用的功能
    group:
      "dev":devDB,devMVC
      "pro":proDB,proMVC
 #启动配置是dev文件为主，也包括devDB,devMVC文件，有冲突了按照dev文件配置执行，如果dev没有配置则最后文件执行的属性会覆盖前面文件（不包括主文件）冲突的属性

14.整合Redis

是一款key-value存储结构的内存集NoSQL数据库

启动服务器：

redis-server.exe redis.windows.conf

启动服务器之后窗口不要关，新打开一个窗口启动redis

redis-cli.exe -h 127.0.0.1 -p 6379

将Redis启动之后我们来用idea使用，注意此时的Redis服务不要关

首先将Redis相关的配置依赖导入

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

在yaml文件配置相关信息

spring:
  redis:
    host: localhost
    port: 6379

测试Redis：

@SpringBootTest
class Sptingboot07RedisApplicationTests {
    @Autowired(required = false)
    RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
    }

    @Test
    void set(){
//        每一种数据都有不同的操作对象，现获取操作对象然后再对数据进行相关操作
        ValueOperations valueOperations = redisTemplate.opsForValue();

        valueOperations.set("gtt","mylover");
    }

    @Test

    void get(){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object gtt = valueOperations.get("gtt");
        System.out.println(gtt);
    }

    @Test
    void hset()
    {
//        opsForHash,对hash数据操作对象
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.put("option","a1","aaa");
    }

    @Test
    void hget(){
        HashOperations hashOperations = redisTemplate.opsForHash();
        Object o = hashOperations.get("option", "a1");
        System.out.println(o);
    }
}

注意：

//    以对象操作的基本单元
    @Autowired(required = false)
    RedisTemplate redisTemplate;
//    以字符串操作的基本单元
    @Autowired(required = false)
    StringRedisTemplate stringRedisTemplate;

    @Test
    void get(){
//        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
//        System.out.println(ops.get("gtt"));
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object gtt = valueOperations.get("gtt");
        System.out.println(gtt);

Redis实现客户端切换（jedis)：

导包：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

配置：

spring:
  redis:
    host: localhost
    port: 6379
    client-type: jedis

jedis就是基于java语言的redis客户端，集成了redis的命令操作，提供了连接池管理。

lettcus与jedis区别:

springboot默认使用lettcus

jedis连接Redis服务器是直连模式，当多线程模式下使用jedis会存在线程安全问题，解决方案可以通过配置连接池使每个连接专用，这样整体性能就大受影响。
lettcus基于Netty框架进行与Redis服务器连接，底层设计中采用StatefulRedisConnection。StatefulRedisConnection自身是线程安全的，可以保障并发访问安全问题，所以一个连接可以被多线程复用。当然lettcus也支持多连接实例一起工作。

15.Mongodb

mysql不够快，redis速度快但是不能结构化，为了满足速度快且能够结构化特点，引入Mongodb存入经常修改的数据的变化

MongoDB是一个开源、高性能、无模式的文档型数据库。NoSQL数据库产品中的一种，是最像关系型数据库的非关系型数据库

iddea整合mongodb