9.热部署

9.1手动启动热部署

笔记小结

1.开启开发者工具后启用热部署

2.使用构建项目操作启动热部署（Ctrl+F9）

3.热部署仅仅加载当前开发者自定义开发的资源，不加载jar资源

1. 开启开发者工具

   添加pom.xml依赖

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

2. 激活热部署：Ctrl + F9进行编译

• 关于热部署

  • 重启（Restart）：自定义开发代码，包含类、页面、配置文件等，加载位置restart类加载器
  • 重载（ReLoad）：jar包，加载位置base类加载器

  重启和重载是两个不同的概念
  

9.2自动启动热部署

笔记小结

设置自动构建用于自动热部署

• 设置自动构建项目

• Settings(设置自动构建项目)

找到idea中的setting，并勾选自动构建项目按钮

• Rejistry（使编辑器运行时自动构建）

注意：此版本为idea2022。

补充：idea2020设置为 alt+ctrl+shift+/

• 激活方式：Idea失去焦点5秒后启动热部署

9.3热部署范围配置

1.默认不触发重启的目录列表

• /META-INF/maven
• /META-INF/resources
• /resources
• /static
• /public
• /templates

2.自定义不参与重启排除项(也就是，自定义配置不参与热重启)

  devtools:
    restart:
      exclude: public/**,static/**,config/application.yml

9.4关闭热部署

• 属性加载优先顺序

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

若项目中设置热部署后失效，可能是因为别的高优先级的属性覆盖了该属性

• 设置高优先级属性禁用热部署

  public static void main(String[] args) {
      System.setProperty("spring.devtools.restart.enabled", "false"); 	         SpringApplication.run(SSMPApplication.class);
  }
  

10.配置高级

笔记小结

1.@ConfigurationProperties

2.宽松绑定/松散绑定

3.常用计量单位绑定

4.数据校验

10.1@ConfigurationProperties✳

笔记小结

@ConfigurationProperties可以为第三方bean绑定属性

• 使用@ConfigurationProperties为第三方bean绑定属性

  @Bean
  @ConfigurationProperties(prefix = "datasource")
  //第三方bean定义
  public DruidDataSource druidDataSource() {
      DruidDataSource dds = new DruidDataSource();
      return dds;
  }
  

  绑定第三方Bean需要通过new方法的方式

  application.yml

  #定义第三方bean获取
  datasource:
    driverClassName: com.mysql.jdbc.Driver
  

• 解除使用@ConfigurationProperties注释警告

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

获取：

public static void main(String[] args) {
    ConfigurableApplicationContext run = SpringApplication.run(Springboot13ConfigurationApplication.class, args);
    //获取自定义bean
    ServerConfig bean = run.getBean(ServerConfig.class);
    System.out.println(bean);
    //获取第三方bean
    DruidDataSource bean1 = run.getBean(DruidDataSource.class);
    System.out.println(bean1.getDriverClassName());
}

10.2@EnableConfigurationProperties

• @EnableConfigurationProperties注解可以将使用@ConfigurationProperties注解对应的类加入Spring容器

  @SpringBootApplication
  @EnableConfigurationProperties(ServerConfig.class)
  public class DemoApplication {
  }
  

  //@Component
  @Data
  @ConfigurationProperties(prefix = "servers")
  public class ServerConfig {
  }
  

  注意：

  @EnableConfigurationProperties与@Component不能同时使用。@EnableConfigurationProperties注解，可以直接将开启的类变为@Componet而被spring容器管理，可以少书写一个@Componet步骤，并且同时可以开启对@ConfigurationProperties注解的使用

  补充:

  @EnableConfigurationProperties 是一个注解，它的作用是开启对 @ConfigurationProperties 注解配置属性类的支持。它通常被用于配置类上，表示这个配置类需要被注册到 Spring 容器中，并且需要通过 @ConfigurationProperties 注解来绑定配置文件中的属性。

  @ConfigurationProperties 也是一个注解，它的作用是将配置文件中的属性值绑定到一个 JavaBean 对象中。它通常被用于在一个配置类中定义属性，并通过 @EnableConfigurationProperties 注解开启对这个配置类的支持。

  @EnableConfigurationProperties 是用于开启对 @ConfigurationProperties 注解配置属性类的支持，而 @ConfigurationProperties 则是用于将配置文件中的属性值绑定到一个 JavaBean 对象中。

10.3宽松绑定/松散绑定

笔记小结

1.@ConfigurationProperties绑定属性支持属性名宽松绑定

2.@Value注解不支持松散绑定

3.绑定前缀命名命名规则

• @ConfigurationProperties绑定属性支持属性名宽松绑定

  1.application.yml

注意：宽松绑定不支持注解**@Value引**用单个属性的方式

补充：常用的方式为中划线模式

2.@ConfigurationProperties位置

@Bean
@ConfigurationProperties(prefix = "datasource")
public DruidDataSource dataSource(){
    DruidDataSource ds = new DruidDataSource();
    return ds;
}

绑定前缀名命名规范：仅能使用纯小写字母、数字、下划线作为合法的字符

否则报错

10.4常用计量单位绑定

• JDK8支持的时间与空间计量单位

  //jdk8提供的新的数据类型
  //时间
  @DurationUnit(ChronoUnit.HOURS)
  private Duration serverTimeout;
  //空间
  @DataSizeUnit(DataUnit.MEGABYTES)
  private DataSize dataSize;
  

  补充：在application.yml中，DataSize类型在使用时可以用单位的方式进行表示 例如 datasize:10MB，但单位不能与注解同时使用

• 常量单位坐标可点击next提示进行查看

  

10.5数据校验

笔记小结

1. 导入JSR303与Hibernate校验框架坐标
2. 使用**@Validated**注解启用校验功能
3. 使用具体校验规则规范数据校验格式

参考链接：(38条消息) 如何使用JSR 303 进行后台数据校验？_菜鸟—程序员的博客-CSDN博客

开启Bean数据校验

• 添加JSR303规范坐标与Hibernate校验框架对应坐标

  步骤一：添加pom.xml中的坐标

  <!--导入JSR303规范-->
  <dependency>
      <groupId>javax.validation</groupId>
      <artifactId>validation-api</artifactId>
  </dependency>
  <!--使用Hibernate框架提供的校验器做实现类-->
  <dependency>
      <groupId>org.hibernate.validator</groupId>
      <artifactId>hibernate-validator</artifactId>
  </dependency>
  

  JSR303规范，是专门用于做数据规范的

  补充：validation相当于一套接口规范。hibernate用来做实现类

  可在Maven Repository: validation (mvnrepository.com)仓库中进行搜索坐标

  

  

  步骤二：开启对当前bean的属性注入校验

  @Component
  @Data
  @ConfigurationProperties(prefix = "servers")
  //开启对当前bean的属性注入校验
  @Validated
  public class ServerConfig {
     ……
  }
  

  为Bean添加**@Validated注解**

  Bean可以为实体类

  步骤三：设置具体的规则

  @Max(value = 8888, message = "最大值不能超过8888")
  private int port;
  

  补充，若省去步骤三，也就是说，没有设置具体的规则，那么在会报错。因为定义了JSR303规范但未使用，因此需要Hibernate校验框架进行完成接口的实现类

  报错内容：

  

  此时可添加Hibernate校验器。

  示例结果

  

11.测试

笔记小结

本节测试分为Controller层的测试与Service层测试

1.加载测试专用属性

• 加载本次测试小范围的配置

2.加载测试专用配置

• 加载测试专用的配置类

3.Web环境模拟测试

• 如何在测试类中启动虚拟的web环境
• 如何在测试类中发起虚拟的web请求调用
• 如何在测试类中发完虚拟的web请求调用后设定匹配的条件

4.数据层测试回滚

• 使用**@Rollback联合@Transactional**进行细微控制

5.测试用例数据设定

• 使用随机值进行测试

11.1加载测试专用属性

笔记小结

加载测试临时属性应用于小范围测试环境

• 在启动测试环境时可以通过properties参数设置测试环境专用的属性

  @SpringBootTest(properties = {"test.prop=testValue1"})
  public class PropertiesAndArgsTest {
      @Value("${test.prop}")
      private String msg;
      @Test    
      void testProperties(){ 
          System.out.println(msg);    
      }
  }
  

  优势：比多环境开发中的测试环境影响范围更小，仅对当前测试类有效

• 在启动测试环境时可以通过args参数设置测试环境专用的传入参数

  @SpringBootTest(args = {"--test.arg=testValue2"})
  public class PropertiesAndArgsTest {
      @Value("${test.arg}")
      private String msg;
      @Test
      void testArgs(){
          System.out.println(msg);
      }
  }
  

示例：

//properties属性可以为当前测试用例添加临时的属性配置
//@SpringBootTest(properties = {"test.prop=success1"})
//args属性可以为当前测试用力添加临时的命令行参数
@SpringBootTest(args = {"--test.prop=success2"})
public class PropertiesAndArgsTest {
    @Value("${test.prop}")
    private String msg;

    @Test
    void testProperties() {
        System.out.println(msg);
    }
}

arg配置的是使用命令行的方式进行添加属性，因此需要添加 –

例如：

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

11.2加载测试专用配置

笔记小结

加载测试范围配置应用于小范围测试环境

• 使用@Import注解加载当前测试类专用的配置

  @SpringBootTest
  @Import(MsgConfig.class)
  public class ConfigurationTest {
      @Autowired
      private String msg;
      @Test
      void testConfiguration(){
          System.out.println(msg);
      }
  }
  

补充：@Import导入配置

示例：

步骤一：添加测试bean

在test目录下创建config/MsgConfig类

@Configuration
public class MsgConfig {
    @Bean
    public String getMsg() {
        return "test bean";
    }
}

此时添加@Bean中仅为测试时使用，实际开发中不这样用。

步骤二：导入配置

@SpringBootTest
@Import({MsgConfig.class})
public class ConfigurationTest {

    @Autowired
    private String msg;

    @Test
    void testConfiguration() {
        System.out.println(msg);
    }
}

使用@Import进行配置的导入,若导入多个配置类时，需要用逗号分隔

11.3Web环境模拟测试

1.模拟端口

模拟web环境启动测试，启动时随机端口

//1.模拟端口
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class WebTest {
    @Test
    void testRandomPort () {
    }
}

在springboot注解中添加webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT。

​ 模拟端口中，有四种启动模式 ，RANDOM_PORT会随机生成端口，NONE不能启动Web服务，DEFINED_PORT当自定义端口时则使用，同时也是默认值。

补充：若遇到测试类启动报错，留意pom.xml文件中是否添加依赖

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

2.虚拟请求测试

模拟web环境请求测试，请求时访问/books目录

//1.模拟端口
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
//2.开启虚拟请求测试
@AutoConfigureMockMvc
public class WebTest {
    @Test
        //3.1注入虚拟MVC调用对象
    void testWeb(@Autowired MockMvc mvc) throws Exception {
        //3.2创建虚拟请求，当前访问/books
        MockHttpServletRequestBuilder mockHttpServletRequestBuilder = MockMvcRequestBuilders.get("/books");
        //3.3执行请求
        mvc.perform(mockHttpServletRequestBuilder);
    }
}

虚拟请求测试时可在方法中注入MockMvc，并且调用MockMvcRequestBuilders.get方法获取请求的路径，再有MockMvc来执行调用

• 虚拟请求状态匹配

@Test
//3.1注入虚拟MVC调用对象
void testStatus(@Autowired MockMvc mvc) throws Exception {
    //3.2创建虚拟请求，当前访问/books
    MockHttpServletRequestBuilder mockHttpServletRequestBuilder = MockMvcRequestBuilders.get("/books");
    //3.3执行请求
    ResultActions actions = mvc.perform(mockHttpServletRequestBuilder);
    //3.4匹配执行状态（是否预期值）
    //3.4.1定义执行状态匹配器
    StatusResultMatchers status = MockMvcResultMatchers.status();
    //3.4.2定义预期执行状态
    ResultMatcher ok = status.isOk();
    //3.5.3使用本次真实执行结果与预期结果进行比对
    actions.andExpect(ok);
}

执行请求后可定义执行状态匹配器 MockMvcResultMatchers.status()来对预期的执行状态status.isOk()进行对比actions.andExpect();

测试报错显示

• 虚拟请求响应体匹配

  @Test
  //3.1注入虚拟MVC调用对象
  void testBody(@Autowired MockMvc mvc) throws Exception {
      //3.2创建虚拟请求，当前访问/books
      MockHttpServletRequestBuilder mockHttpServletRequestBuilder = MockMvcRequestBuilders.get("/books");
      //3.3执行请求
      ResultActions actions = mvc.perform(mockHttpServletRequestBuilder);
      //3.4匹配执行状态（是否预期值）
      //3.4.1定义执行状态匹配器
      ContentResultMatchers content = MockMvcResultMatchers.content();
      //3.4.2定义预期执行状态
      ResultMatcher result = content.string("springboot");
      //3.5.3使用本次真实执行结果与预期结果进行比对
      actions.andExpect(result);
  }
  

  执行请求后可定义执行状态匹配器 MockMvcResultMatchers.content()来对预期的执行状态content.string()进行对比actions.andExpect();

• 虚拟请求响应体（json）匹配

  @Test
  //3.1注入虚拟MVC调用对象
  void testJson(@Autowired MockMvc mvc) throws Exception {
      //3.2创建虚拟请求，当前访问/books
      MockHttpServletRequestBuilder mockHttpServletRequestBuilder = MockMvcRequestBuilders.get("/books");
      //3.3执行请求
      ResultActions actions = mvc.perform(mockHttpServletRequestBuilder);
      //3.4匹配执行状态（是否预期值）
      //3.4.1定义执行状态匹配器
      ContentResultMatchers content = MockMvcResultMatchers.content();
      //3.4.2定义预期执行状态
      ResultMatcher result = content.json("{\"id\":1,\"type\":\"美女\",\"name\":\"玥玥\",\"description\":\"大美女只为你着迷\"}");
      //3.5.3使用本次真实执行结果与预期结果进行比对
      actions.andExpect(result);
  }
  

  执行请求后可定义执行状态匹配器 MockMvcResultMatchers.content()来对预期的执行状态content.json()进行对比actions.andExpect();

  • 虚拟请求响应头匹配

  @Test
  //3.1注入虚拟MVC调用对象
  void testHead(@Autowired MockMvc mvc) throws Exception {
      //3.2创建虚拟请求，当前访问/books
      MockHttpServletRequestBuilder mockHttpServletRequestBuilder = MockMvcRequestBuilders.get("/books");
      //3.3执行请求
      ResultActions actions = mvc.perform(mockHttpServletRequestBuilder);
      //3.4匹配执行状态（是否预期值）
      //3.4.1定义执行状态匹配器
      HeaderResultMatchers header = MockMvcResultMatchers.header();
      //3.4.2定义预期执行状态
      ResultMatcher contentType = header.string("Content-Type", "application/json");
      //3.5.3使用本次真实执行结果与预期结果进行比对
      actions.andExpect(contentType);
  }
  

执行请求后可定义执行状态匹配器 MockMvcResultMatchers.header()来对预期的执行状态header.string()进行对比actions.andExpect();

示例：

一般情况下响应的测试

@Test
void testGetById(@Autowired MockMvc mvc) throws Exception {
    MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/books");
    ResultActions actions = mvc.perform(builder);

    //测试响应状态
    StatusResultMatchers status = MockMvcResultMatchers.status();
    ResultMatcher ok = status.isOk();
    actions.andExpect(ok);

    //测试响应头
    HeaderResultMatchers header = MockMvcResultMatchers.header();
    ResultMatcher string = header.string("Content-Type", "application/json");
    actions.andExpect(string);

    //测试响应体
    ContentResultMatchers content = MockMvcResultMatchers.content();
    ResultMatcher json = content.json("{\"id\":1,\"type\":\"美女\",\"name\":\"玥玥\",\"description\":\"大美女只为你着迷\"}");
    actions.andExpect(json);
}

11.4业务层测试回滚

笔记小结

测试用例回滚事务

• 为测试用例添加事务，SpringBoot会对测试用例对应的事务提交操作进行回滚

  @SpringBootTest
  @Transactional
  public class DaoTest {
      @Autowired
      private BookService bookService;
  }
  

• 如果想在测试用例中提交事务，可以通过@Rollback注解设置

  @SpringBootTest
  @Transactional
  @Rollback(false)
  public class DaoTest {
  }
  
  

示例：

/*
 * 测试业务层的方法时需要开启@Transactional注解并与@Rollback(value = true）连用，可以阻止测试数据的回滚操作。（换句话说，也就是数据库不会自动新增消息）
 * */
@SpringBootTest
@Transactional
@Rollback(value = true)
public class DaoTest {

    @Autowired
    private IBookService service;

    @Test
    void testSave() {
        Book book = new Book();
        book.setType("meinv fd ");
        book.setName("yueyue");
        book.setDescription("dameinvzhiweinizhaomi");
        service.saveBook(book);
    }
}

11.5测试用例数据设定

测试用例数据通常采用随机值进行测试，使用SpringBoot提供的随机数为其赋值

在application.yml文件下

testcase:
  book:
    id: ${random.int} # 随机整数
    id2: ${random.int(10)} # 10以内随机数
    type: ${random.int(10,20)} # 10到20随机数
    uuid: ${random.uuid}   # 随机uuid
    name: ${random.value} # 随机字符串,MD5字符串,32位
    publishTime: ${random.long} # 随机整数(long范围)

• ${random.int}表示随机整数
• ${random.int(10)}表示10以内的随机数
• ${random.int(10,20)}表示10到20的随机数
• 其中()可以是任意字符，例如[]，!!均可

示例：

在

在test的testCase/domain下创建BookCase

@Component
@Data
@ConfigurationProperties(prefix = "testcase.book")
public class BookCase {
    private int id;
    private int id2;
    private int type;
    private String uuid;
    private String name;
    private long publishTime;
}

在test下创建testCaseTest

@SpringBootTest
public class testCaseTest {
    @Autowired
    private BookCase bookCase;

    @Test
    void testCase() {
        System.out.println(bookCase);
    }
}

12.数据层解决方案

关系型数据库的解决方案

现有数据层解决方案技术选型

Druid + MyBatis-Plus + MySQL

• 数据源：DruidDataSource
• 持久化技术：MyBatis-Plus / MyBatis
• 数据库：MySQL

12.1SQL

笔记小结

• 数据源配置（Hikari）

  • SpringBoot内置3款数据源可供选择

    • HikariCP（默认）

    • Tomcat提供DataSource

    • Commons DBCP

• 持久化技术（JdbcTemplate）

  • SpringBoot内置JdbcTemplate持久化解决方案
  • 使用JdbcTemplate需要导入spring-boot-starter-jdbc

• 数据库（H2）

  • H2内嵌式数据库启动方式
  • H2数据库线上运行时请务必关闭

12.1.1数据源配置

笔记小结

1.SpringBoot内置3款数据源可供选择

HikariCP（默认）

Tomcat提供DataSource

Commons DBCP

格式一：

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
    username: root
    password: qweasdzxc
    type: com.alibaba.druid.pool.DruidDataSource

配置type的方式实现druid的配置

格式二：

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

druid配置标准写法

1. SpringBoot提供了3种内嵌的数据源对象供开发者选择

   • HikariCP:默认内置数据源对象

   • Tomcat提供DataSource:HikariCP不可用的情况下，且在web环境中，将使用tomcat服务器配置的数据源对象

   • Commons DBCP:Hikari不可用，tomcat数据源也不可用，将使用dbcp数据源

2. 通用配置无法设置具体的数据源配置信息，仅提供基本的连接相关配置，如需配置，在下一级配置中设置具体设定

   #hikari数据源
   spring:
     datasource:
       url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
       driver-class-name: com.mysql.cj.jdbc.Driver
       username: root
       password: qweasdzxc
       #最大连接池
       hikari:
         maximum-pool-size: 50
   

12.1.2持久化技术配置

笔记小结

1.SpringBoot内置JdbcTemplate持久化解决方案

2.使用JdbcTemplate需要导入spring-boot-starter-jdbc

内置持久化解决方案——JdbcTemplate

1.Springboot15SqlApplicationTests

 @Test
    void testJdbc(@Autowired JdbcTemplate jdbcTemplate) {
        String sql = "select * from tb_book ";
//        jdbcTemplate的query参数1为sql语句，参数2为对返回的参数进行封装
        List<Book> query = jdbcTemplate.query(sql, new RowMapper<Book>() {
            @Override
            public Book mapRow(ResultSet rs, int rowNum) throws SQLException {
                Book temp = new Book();
                temp.setId(rs.getInt("id"));
                temp.setName(rs.getString("name"));
                temp.setType(rs.getString("type"));
                temp.setDescription(rs.getString("description"));
                return temp;
            }
        });
        System.out.println(query);
    }

2.pom.xml

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

3.application.yml

spring:
  jdbc:
    template:
      query-timeout: -1   # 查询超时时间
      max-rows: 500       # 最大行数
      fetch-size: -1      # 缓存行数

JdbcTemplate配置：使用默认的持久化技术也可通过application.yml进行配置

12.1.3数据库配置

笔记小结

1.H2内嵌式数据库启动方式

2.H2数据库线上运行时请务必关闭

SpringBoot提供了3种内嵌数据库供开发者选择，提高开发测试效率

• H2
• HSQL
• Derby

内嵌数据库（H2）

1. 导入xml坐标

   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-jpa</artifactId>
   </dependency>
   <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
       <scope>runtime</scope>
   </dependency>
   

2. 设置当前项目为web工程，并配置H2管理控制台参数

   spring:
     h2: #h2数据库
       console: #控制台模式
         enabled: true #可用
         path: /h2 #访问地址名
   server:
     port: 8080
   

   访问用户名sa，默认密码123456

   

3. 设置访问数据源

   server:
     port: 80
   spring:
     datasource:
       #driver-class-name: org.h2.Driver
       url: jdbc:h2:~/test
       username: sa
       password: 123456
     h2:
       console:
         path: /h2
         enabled: true
   

   注意：

   初次创建H2数据库时需要配置datasource数据源（初始化完成后可取消数据源配置）,否则会出现如下报错

   

   再次重启项目即可连接

   

   SpringBoot可以根据url地址自动识别数据库种类，在保障驱动类存在的情况下，可以省略配置driver-class-name

4. 操作数据库（创建表）

   create table tbl_book (id int,name varchar,type varchar,description varchar)
   

   点击运行

   

5. 插入数据，测试

   insert into tbl_book values(1,'springboot1','springboot1','springboot1')
   

   插入后进行查询

   select * from tbl_book
   

   

6. 实现测试

   注意：H2数据库只能建立一个连接。因此测试时需要关闭服务器

12.2NoSQL

笔记小结

1.Redis

2.Mongodb

3.ElasticSearch

市面上常见的NoSQL解决方案

• Redis✳
• Mongo✳
• ES
• Solr

12.2.1Redis

Redis优点，响应速度够快。Redis缺点，不支持结构化数据。

笔记小结

1.Redis安装（Windows版）

2.Redis基本操作

1. Redis是一款key-value存储结构的内存级NoSQL数据库

   • 支持多种数据存储格式

   • 支持持久化

   • 支持集群

2. Redis下载（ Windows版）

   • https://github.com/tporadowski/redis/releases

3. Redis安装与启动（ Windows版）

   • Windows解压安装或一键式安装

   • 服务端启动命令

     redis-server.exe redis.windows.conf
     

     启动时需要加载redis在windows下的配置文件redis.windows.conf

   • 客户端启动命令

     redis-cli.exe
     

12.2.1.1Redis安装与启动

安装示例：

安装完后会产生如下文件

启动示例：

1.启动服务端：

需要添加conf配置项

redis-server.exe redis.windows.conf

若未添加配置项，报错：

2.启动客户端

需要解决此版本的redis在windows下的启动bug

若启动了redis的服务端，但并未出现Running in standalone mode的提示字样，则需要打开客户端进行shutdown操作，如下所示

通过cmd打开客户端

redis-cli.exe

执行如下命令，如图

shutdown

3.启动服务端

redis-server.exe redis.windows.conf

重启后成功。

12.2.1.2Redis基本操作

Redis是一款key-value存储结构的内存级NoSQL数据库，因此常用get，set，hset，hget方式进行数据操作

设置key

• 普通方式

  set name yueyue
  

  

• 哈希方式

  hset ka a1 aaa
  

  

获取key

• 普通方式

  get name
  

  

• 哈希方式

  hget ka a1
  

  

查询所有key

keys *

删除所有key

/删除当前数据库中的所有Key
flushdb
//删除所有数据库中的key
flushall

12.2.3SpringBoot整合Redis

笔记小结

基本操作

1. 导入redis对应的starter
2. 配置
3. 提供操作Redis接口对象RedisTemplate
   • ops*：获取各种数据类型操作接口

接口对象

1. RedisTemplate
2. StringRedisTemplate（常用）

客户端选择

• lettuce（默认）
• jedis

12.2.3.1基本操作

1.导入SpringBoot整合Redis坐标

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

2.配置Redis（采用默认配置）

spring:
  redis:
    host: localhost # 127.0.0.1
    port: 6379

主机：localhost（默认）
端口：6379（默认）

RedisTemplate提供操作各种数据存储类型的接口API

3.客户端：RedisTemplate

@SpringBootTest
class Springboot16NosqlApplicationTests {
    @Test
    void set(@Autowired RedisTemplate redisTemplate) {
        ValueOperations ops = redisTemplate.opsForValue();
        ops.set("testKey","testValue");
    }
    @Test
    void get(@Autowired RedisTemplate redisTemplate) {
        ValueOperations ops = redisTemplate.opsForValue();
        Object val = ops.get("testKey");
        System.out.println(val);
    }
    
    @Test
    void hset(@Autowired RedisTemplate redisTemplate) {
        HashOperations opsH = redisTemplate.opsForHash();
        opsH.put("testKeyH","testFieldH","testValueH");
    }
    @Test
    void hget(@Autowired RedisTemplate redisTemplate) {
        HashOperations opsH = redisTemplate.opsForHash();
        Object valH = opsH.get("testKeyH", "testFieldH");
        System.out.println(valH);
    }
}

补充：

HashOperations和ValueOperations区别

HashOperations和ValueOperations是Spring Framework提供的两种常见的Redis操作接口，它们的主要区别在于：

1. HashOperations用于操作Redis中的Hash类型数据，可以对一个Redis键存储多个字段和值，适用于存储结构化数据。
2. ValueOperations用于操作Redis中的String类型数据，可以对一个Redis键存储单个值，适用于存储非结构化数据。

具体来说，HashOperations提供了一系列的操作方法，例如put（设置一个字段和值）、get（获取一个字段的值）、delete（删除一个或多个字段）等，可以方便地对Redis中的Hash类型数据进行读写操作。而ValueOperations则提供了一些类似于set、get、increment等操作方法，用于对Redis中的String类型数据进行读写操作。

在实际使用中，需要根据具体的业务需求和数据类型选择合适的操作接口。如果需要存储结构化数据，应该使用HashOperations；如果只需要存储单个值，可以使用ValueOperations。

12.2.3.2接口对象

笔记小结

1.RedisTemplate

2.StringRedisTemplate（常用）

客户端：RedisTemplate以对象作为key和value，内部对数据进行序列化

@SpringBootTest
class Springboot16NosqlApplicationTests {
    @Test
    void set(@Autowired RedisTemplate redisTemplate) {
        ValueOperations ops = redisTemplate.opsForValue();
        ops.set("testKey","testValue");
    }
    @Test
    void get(@Autowired RedisTemplate redisTemplate) {
        ValueOperations ops = redisTemplate.opsForValue();
        Object val = ops.get("testKey");
        System.out.println(val);
    }
}

客户端：StringRedisTemplate以字符串作为key和value，与Redis客户端操作等效

@SpringBootTest
class Springboot16NosqlApplicationTests {
    @Test
    void set(@Autowired StringRedisTemplate redisTemplate) {
        ValueOperations ops = redisTemplate.opsForValue();
        ops.set("testKey","testValue");
    }
    @Test
    void get(@Autowired StringRedisTemplate redisTemplate) {
        ValueOperations ops = redisTemplate.opsForValue();
        Object val = ops.get("testKey");
        System.out.println(val);
    }
}

StringRedisTemplate是常用的接口对象，与Redis客户端操作等效。如果是用RedisTemplate接口对象，那么则会出现Redis客户端读取不成功现象

12.2.3.3客户端选择

笔记小结

• lettuce（默认）
• jedis

jedis

1.导入maven

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

2.配置客户端

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

client-type选择jedis。lettuce为默认值

3.配置客户端专用属性

spring:
  redis:
    port: 6379
   host: localhost # 127.0.0.1
    client-type: jedis
    jedis:
      pool:
        max-active: 16
#    lettuce:
#      pool:
#        max-active: 16

补充：

lettcus与jedis区别

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

12.2.2Mongodb

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

1.Mongodb应用场景

淘宝用户数据

• 存储位置：数据库
• 特征：永久性存储，修改频度极低

游戏装备数据、游戏道具数据

• 存储位置：数据库、Mongodb
• 特征：永久性存储与临时存储相结合、修改频度较高

直播数据、打赏数据、粉丝数据

• 存储位置：数据库、Mongodb
• 特征：永久性存储与临时存储相结合，修改频度极高

物联网数据

• 存储位置：Mongodb
• 特征：临时存储，修改频度飞速

其他数据……

12.2.2.1MongoDB安装与启动

笔记小结

1.Mongodb安装、启动

2.可视化客户端Robo 3T安装与连接

Windows版Mongo下载

• https://www.mongodb.com/try/download

• 解压缩后设置数据目录

• 

• 

Windows版Mongo启动

• 服务端启动

  mongod --dbpath=..\data\db
  

  注意：初次使用时需要启动一次，再次重启

  

• 客户端启动

  mongo --host=127.0.0.1 --port=27017
  

  注意：启动客户端时需要等待服务器完全启动成功后再次启动，否则会出现连接不上的状态

  

补充：若在安装时出现问题，Windows版Mongo安装问题及解决方案

步骤一：下载对应的dll文件（通过互联网搜索即可）
步骤二：拷贝到windows安装路径下的system32目录中
步骤三：执行命令注册对应dll文件

regsvr32 vcruntime140_1.dll

12.2.2.2MongoDB基本操作

笔记小结

Mongodb基础CRUD

• 新增

db.集合名称.insert/save/insertOne(文档)

#例如
db.Book.save({"name":"yueyue2"})

• 删除

db.集合名称.remove(条件)

#例如
db.Book.remove({"name":"yueyue"})

• 修改

db.集合名称.update(条件，{操作种类:{文档}})

#例如
db.Book.update({"name":"yueyue2"},{$set:{"name":"jiege"}})
db.Book.update({"name":"yueyue2"},{$set:{"type":"gril"}})

• 查询

db.集合名称.finde(条件)

#例如
db.Book.find()
db.Book.find({"name":"jiege"})

补充：

基础查询

• 查询全部：db.集合.find();
• 查第一条：db.集合.findOne()
• 查询指定数量文档：db.集合.find().limit(10) //查10条文档
• 跳过指定数量文档：db.集合.find().skip(20) //跳过20条文档
• 统计：db.集合.count()
• 排序：db.集合.sort({age:1}) //按age升序排序
• 投影：db.集合名称.find(条件,{name:1,age:1}) //仅保留name与age域

条件查询

• 基本格式：db.集合.find({条件})
• 模糊查询：db.集合.find({域名:/正则表达式/}) //等同SQL中的like，比like强大，可以执行正则所有规则
• 条件比较运算：db.集合.find({域名:{$gt:值}}) //等同SQL中的数值比较操作，例如：name>18
• 包含查询：db.集合.find({域名:{$in:[值1，值2]}}) //等同于SQL中的in
• 条件连接查询：db.集合.find({$and:[{条件1},{条件2}]}) //等同于SQL中的and、or

12.2.2.3SpringBoot整合MongoDB

笔记小结

SpringBoot整合Mongodb

1. 导入Mongodb对应的starter
2. 配置mongodb访问uri
3. 提供操作Mongodb接口对象MongoTemplate

1.导入Mongodb驱动坐标

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

2.配置客户端

spring:
  data:
    mongodb:
      uri: mongodb://localhost/itheima

3.客户端读写Mongodb

@Test
void testSave(@Autowired MongoTemplate mongoTemplate){
    Book book = new Book();
    book.setId(1);
    book.setType("springboot");
    book.setName("springboot");
    book.setDescription("springboot");
    mongoTemplate.save(book);
}
@Test
void testFind(@Autowired MongoTemplate mongoTemplate){
    List<Book> all = mongoTemplate.findAll(Book.class);
    System.out.println(all);
}

12.2.3ElasticSearch（ES）

笔记小结

1.ES应用场景

2.ES相关概念

ES应用场景

​ Elasticsearch是一个分布式全文搜索引擎，某宝常用

ES相关概念

• 索引
• 倒排索引
• 创建文档
• 使用文档

12.2.3.1ES安装与启动

Windows版ES下载

• https://www.elastic.co/cn/downloads/elasticsearch

Windows版ES安装与启动

• 运行 elasticsearch.bat

  当访问浏览器页面出现一下字符表示启动成功

  http://localhost:9200/
  

  

12.2.3.2ES基本操作

笔记小结

1.索引操作

2.IK分词器安装

3.设置索引创建规则（应用）

12.2.3.2.1索引

1.创建/查询/删除索引

PUT	http://localhost:9200/books

此时使用postman进行创建测试

GET	http://localhost:9200/books

DELETE	http://localhost:9200/books

2.IK分词器

• 下载：https://github.com/medcl/elasticsearch-analysis-ik/releases

3.创建索引并指定规则

{
    "mappings":{
        "properties":{
            "id":{
                "type":"keyword"
            },
            "name":{
                "type":"text",
                "analyzer":"ik_max_word",
                "copy_to":"all"
            },
            "type":{
                "type":"keyword"
            },
            "description":{
                "type":"text",
                "analyzer":"ik_max_word",
                "copy_to":"all"
            },
            "all":{
                "type":"text",
                "analyzer":"ik_max_word"
            }
        }
    }
}

注意：配置项"analyzer":"ik_max_word"不要打错

“analyzer”:“ik_max_word”,表示配置ik分词器

“copy_to”:“all”，表示拷贝至all索引项

12.2.3.2.2文档

1.创建文档

创建文档三种方式

POST	http://localhost:9200/books/_doc		#使用系统生成id
POST	http://localhost:9200/books/_create/1		#使用指定id，
POST	http://localhost:9200/books/_doc/1		#使用指定id，不存在创建，存在更新（版本递增）

body部分

{
"name":"springboot",
"type":"springboot",
"description":"springboot"
}

注意：body部分 “name”等json的key值前面的空格需要删除，或者用 ······ 进行填充

否则报错：

“reason”: "Unexpected character (’ ’ (code 160)): was expecting double-quote to start field name\n

2.删除文档

DELETE	http://localhost:9200/books/_doc/1

3.修改文档

• 修改文档（全量修改）

PUT	http://localhost:9200/books/_doc/1

​ body部分

{
    "name":"springboot",
    "type":"springboot",
    "description":"springboot"
}

全部修改是指将原有的所有属性直接覆盖

• 修改文档（部分修改）

POST	http://localhost:9200/books/_update/1

​ body部分

{
    "doc":{
        "name":"springboot"
    }
}

部分修改是指将原有的指定属性进行覆盖

4.查询文档

• 常规查询

GET	http://localhost:9200/books/_doc/1		 #查询单个文档 		
GET	http://localhost:9200/books/_search		 #查询全部文档

• 条件查询

GET	http://localhost:9200/books/_search?q=name:springboot

12.2.3.3SpringBoot整合ElasticSearch（ES）

12.2.3.3.1方式一

1.导入驱动坐标

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

2.配置

spring:
  elasticsearch:
    rest:
      uris: http://localhost:9200

3.客户端整合第三方技术

@SpringBootTest
class Springboot18EsApplicationTests {
    @Autowired
    private ElasticsearchRestTemplate template;
}

12.2.3.3.2方式二(现已不可用)

1.导入驱动坐标

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>

2.配置（无）

补充：

SpringBoot平台并没有跟随ES的更新速度进行同步更新，ES提供了High Level Client操作ES

3.客户端

@Autowired
RestHighLevelClient client;

@BeforeEach
void setUp() {
    this.client = new RestHighLevelClient(RestClient.builder(HttpHost.create("http://localhost:9200")));
}

@AfterEach
void tearDown() throws IOException {
    this.client.close();
}

@Test
void test() throws IOException {
    //客户端操作
    CreateIndexRequest request = new CreateIndexRequest("books");
    //获取操作索引的客户端对象，调用创建索引操作
    client.indices().create(request, RequestOptions.DEFAULT);
}

@BeforeEach注解。它用于表示应在当前类中的每个@Test方法之前执行注解方法。

@AfterEach注解。它用于表示应在当前类中的每个@Test方法之后执行注解方法。

12.2.3.3.3添加文档

添加文档

//添加文档
@Test
void testCreateDoc() throws IOException {
    Book book = bookDao.selectById(1);
    IndexRequest request = new IndexRequest("books").id(book.getId().toString());
    String json = JSON.toJSONString(book);
    request.source(json,XContentType.JSON);
    client.index(request, RequestOptions.DEFAULT);
}

参考资料https://www.bilibili.com/video/BV15b4y1a7yG/?p=105&spm_id_from=pageDriver

批量添加文档

//批量添加文档
@Test
void testCreateDocAll() throws IOException {
    List<Book> bookList = bookDao.selectList(null);
    BulkRequest bulk = new BulkRequest();
    for (Book book : bookList) {
        IndexRequest request = new IndexRequest("books").id(book.getId().toString());
        String json = JSON.toJSONString(book);
        request.source(json,XContentType.JSON);
        bulk.add(request);
    }
    client.bulk(bulk,RequestOptions.DEFAULT);
}

12.2.3.3.4查询文档

按id查询文档

@Test
void testGet() throws IOException {
    GetRequest request = new GetRequest("books","1");
    GetResponse response = client.get(request, RequestOptions.DEFAULT);
    String json = response.getSourceAsString();
    System.out.println(json);
}

按条件查询文档

@Test
void testSearch() throws IOException {
    SearchRequest request = new SearchRequest("books");
    SearchSourceBuilder builder = new SearchSourceBuilder();
    builder.query(QueryBuilders.termQuery("all",“java"));
    request.source(builder);
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    SearchHits hits = response.getHits();
    for (SearchHit hit : hits) {
        String source = hit.getSourceAsString();
        Book book = JSON.parseObject(source, Book.class);
        System.out.println(book);
    }
}

参考资料https://www.bilibili.com/video/BV15b4y1a7yG/?p=106&spm_id_from=pageDriver

13.整合第三方技术

13.1缓存

笔记小结

1.spring-cache

• simple
• ehcache
• redis
• memcached

2.jetcache

3.j2cache

​ 缓存是一种介于数据永久存储介质与数据应用之间的数据临时存储介质

作用：

• 使用缓存可以有效的减少低速数据读取过程的次数（例如磁盘IO），提高系统性能
• 缓存不仅可以用于提高永久性存储介质的数据读取效率，还可以提供临时的数据存储空间

减少了数据库的压力

示例

@Service
public class MsgServiceImpl implements IMsgService {
    //定义代码缓存
    private HashMap<String, String> cache = new HashMap<>();

    @Override
    public String get(String tel) {
        //截取后6位作为验证码
        String code = tel.substring(tel.length() - 6);
        cache.put(tel, code);
        return code;
    }

    @Override
    public Boolean check(String tel, String code) {
        String queryCode = cache.get(tel);
        return queryCode.equals(code);
    }
}

当获取验证码时，将电话后6位返回，并保存到内存中。当校验验证码时，再取出内存中的6位验证码即可比对成功。优点：省去了存入数据库的频繁读写；缺点：会导致内存占用过大，而崩溃

SpringBoot提供了缓存技术，方便缓存使用

• 启用缓存
• 设置进入缓存的数据
• 设置读取缓存的数据

1.导入缓存技术对应的starter

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

2.启用缓存

@SpringBootApplication
@EnableCaching
public class Springboot19CacheApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot19CacheApplication.class, args);
    }
}

在启类的位置设置@EnableCaching注解

3.设置当前操作的结果数据进入缓存

@Cacheable(value="cacheSpace",key="#id")
public Book getById(Integer id) {
    return bookDao.selectById(id);
}

在实现类的相应的方法上添加@Cacheable注解

示例：

SpringBoot19CacheApplication

SpringBootApplication
//启动缓存
@EnableCaching
public class Springboot19CacheApplication {

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

}

BookServiceImpl

@Service
public class BookServiceImpl implements IBookService {

    @Autowired
    private BookDao bookDao;

    //如果当前缓存中没有本次要查询的数据，则进行查询，否则直接从缓存中获取数据返回
//    private HashMap<Integer, Book> cache = new HashMap<>();

    //    @Override
//    public Book getById(Integer id) {
//        Book book = cache.get(id);
//        if (book == null) {
//            Book queryBook = bookDao.selectById(id);
//            cache.put(id, queryBook);
//            return queryBook;
//        }
//        return book;
//    }
    
    @Override
    @Cacheable(value = "cacheSpace", key = "#id")
    public Book getById(Integer id) {
        return bookDao.selectById(id);
    }
}

SpringBoot提供的缓存技术除了提供默认的缓存方案，还可以对其他缓存技术进行整合，统一接口，方便缓存技术的开发与管理

• Generic
• JCache
• Ehcache
• Hazelcast
• Infinispan
• Couchbase
• Redis
• Caffeine
• Simple（默认）
• memcached

13.1.1案例展示——手机验证码

13.1.1.1手机验证码获取

需求

• 输入手机号获取验证码，组织文档以短信形式发送给用户（页面模拟）
• 输入手机号和验证码验证结果

需求分析

• 提供controller，传入手机号，业务层通过手机号计算出独有的6位验证码数据，存入缓存后返回此数据
• 提供controller，传入手机号与验证码，业务层通过手机号从缓存中读取验证码与输入验证码进行比对，返回比对结果

1.导入缓存技术对应的starter

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

在pom.xml文件中添加依赖

2.启用缓存

@SpringBootApplication
@EnableCaching
public class Springboot19CacheApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot19CacheApplication.class, args);
    }
}

在启类的位置设置**@EnableCaching**注解

3.domain类

package com.example.domain;

import lombok.Data;

@Data
public class SMSCode {
    private String tel;
    private String code;
}

因为手机验证码需要得到手机与响应的验证码，此时创建SMSCode对象，对值进行封装

4.工具类

CodeUtil验证码校验类

@Component
public class CodeUtil {

    /**
     * 获取随机验证码
     * @param tel 手机号
     * @return 验证码
     */
    public String generator(String tel) {
        //hashCode() 方法用于返回字符串的哈希码,哈希码通过相应计算得来。
        int hashCode = tel.hashCode();
        //定义加密数字
        int encryption = 20040213;
        //一层加密
        long result = hashCode ^ encryption;
        //获取当前时间
        long nowTime = System.currentTimeMillis();
        //二层加密
        result = result ^ nowTime;
        String temp = String.valueOf(result);
        return temp.substring(temp.length() - 6);
    }
}

添加@Component注解是为了让spring boot对CodeUtil进行管理

4.业务层接口

public interface ISMSCodeService {
    /**
     * 传入手机号获取验证码，存入缓存
     *
     * @param tel
     * @return
     */
    String sendCodeToSMS(String tel);

    /**
     * 传入手机号与验证码，校验匹配是否成功
     *
     * @param smsCode
     * @return
     */
    boolean checkCode(SMSCode smsCode);
}

5.业务层实现

@Service
public class SMSCodeServiceImpl implements ISMSCodeService {
    @Autowired
    CodeUtil codeUtil;

    @Override
    //@Cacheable(value = "smsCache", key = "#tel")
    @CachePut(value = "smsCache", key = "#tel")
    public String sendCodeToSMS(String tel) {
        return codeUtil.generator(tel);
    }

    @Override
    public boolean checkCode(SMSCode smsCode) {
        return false;
    }
}

注意使用 @CachePut注解，而并不是@Cacheable

@CachePut:将tel作为key,将返回值作为value

checkCode暂时没有编写

6.控制层

@RestController
@RequestMapping("/sms")
public class SMSCodeController {

    @Autowired
    SMSCodeServiceImpl service;

    @GetMapping("/{tel}")
    public String getCode(@PathVariable String tel) {
        return service.sendCodeToSMS(tel);
    }

    @PostMapping
    public boolean checkCode(SMSCode smsCode) {
        return service.checkCode(smsCode);
    }
}

checkCode暂时没有编写

13.1.1.2手机验证码校验

1.工具类

   /**
     * 取出缓存中的验证码
     *
     * @param tel 电话号码
     * @return 如果电话号码相匹配则返回value
     * 当使用了@Cacheable注解，在返回时填入null即可。若缓存中key有对应的值则返回，无则返回null
     * 当使用了@Cacheable注解，需要被springboot的容器管理才能生效
     */
    @Cacheable(value = "smsCache", key = "#tel")
    public String get(String tel) {
        return null;
    }

CodeUtil的补充

2.业务层实现补充

@Override
public boolean checkCode(SMSCode smsCode) {
    String code = smsCode.getCode();
    String checkCode = codeUtil.get(smsCode.getTel());
    return code.equals(checkCode);
}

13.1.2缓存供应商变更：Ehcache

笔记小结

1.导入maven坐标

2.进行yml文件配置

3.提供ehcache配置文件

13.1.2.1实现步骤：

1.加入Ehcache坐标（缓存供应商实现）

<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

因为springboot整合了ehcache，因此可以不用指定坐标的版本

2.缓存设定为使用Ehcache

spring:
  cache:
    type: ehcache

主要配置cache的type为ehcache

若需要修改默认的配置文件名，需要添加ehcache的config来进行修改

ehcache:
config: ehcache.xml

3.提供ehcache配置文件ehcache.xml

在resource下添加此文件

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--默认缓存策略 -->
    <!-- external：是否永久存在，设置为true则不会被清除，此时与timeout冲突，通常设置为false-->
    <!-- diskPersistent：是否启用磁盘持久化-->
    <!-- maxElementsInMemory：最大缓存数量-->
    <!-- overflowToDisk：超过最大缓存数量是否持久化到磁盘-->
    <!-- timeToIdleSeconds：最大不活动间隔，设置过长缓存容易溢出，设置过短无效果-->
    <!-- timeToLiveSeconds：最大存活时间-->
    <!-- memoryStoreEvictionPolicy：缓存清除策略-->
    <defaultCache
            eternal="false"
            diskPersistent="false"
            maxElementsInMemory="1000"
            overflowToDisk="false"
            timeToIdleSeconds="60"
            timeToLiveSeconds="60"
            memoryStoreEvictionPolicy="LRU" />
    <!--smsCode配置的ehcache -->
    <cache
            name="smsCode"
            eternal="false"
            diskPersistent="false"
            maxElementsInMemory="1000"
            overflowToDisk="false"
            timeToIdleSeconds="10"
            timeToLiveSeconds="10"
            memoryStoreEvictionPolicy="LRU" />
</ehcache>

当需要使用多组配置时，只需要添加多组即可，它们之间用name进行区分

注意文件名需要指定为ehcache.xml，若需要变更，则要修改yml配置

13.1.3缓存供应商变更：Redis(重点)

笔记小结

1.导入maven坐标

2.进行yml文件配置

13.1.3.1实现步骤：

1.加入Redis坐标（缓存供应商实现）

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

2.配置Redis服务器，缓存设定为使用Redis

spring:
  redis:
    host: localhost
    port: 6379
  cache:
    type: redis

3.设置Redis相关配置

spring:
  redis:
    host: localhost
    port: 6379
  cache:
    type: redis
    redis:
      use-key-prefix: true      # 是否使用前缀名（系统定义前缀名）
      key-prefix: sms_          # 追加自定义前缀名
      time-to-live: 10s         # 有效时长
      cache-null-values: false  # 是否允许存储空值

当use-key-prefix的值设置为False时，key-prefix自动失效。time-to-live设置Redis中key和Value的存活时间

注意，需要配置host主机与port端口

13.1.3.2示例：

1.配置坐标

在pom.xml文件中

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

2.配置连接

spring:
  cache:
    type: redis
    redis:
      time-to-live: 10s
  redis:
    host: localhost
    port: 6379

3.业务层接口类

在service/impl/的SMSCodeServiceImpl中

    @Override
    @CachePut(value = "smsCache", key = "#tel")
    public String sendCodeToSMS(String tel) {
        return codeUtil.generator(tel);
    }

    @Override
    public boolean checkCode(SMSCode smsCode) {
        String code = smsCode.getCode();
        String checkCode = codeUtil.get(smsCode.getTel());
        return code.equals(checkCode);
    }

/*ehcache、redis、simple用法 */的调用方法是一样的

@Component
public class CodeUtil {

    /**
     * 获取随机验证码
     *
     * @param tel 手机号
     * @return 验证码
     */
    public String generator(String tel) {
        //hashCode() 方法用于返回字符串的哈希码,哈希码通过相应计算得来。
        int hashCode = tel.hashCode();
        //定义加密数字
        int encryption = 20040213;
        //一层加密
        long result = hashCode ^ encryption;
        //获取当前时间
        long nowTime = System.currentTimeMillis();
        //二层加密
        result = result ^ nowTime;
        String temp = String.valueOf(result);
        return temp.substring(temp.length() - 6);
    }

    /**
     * 取出缓存中的验证码
     *
     * @param tel 电话号码
     * @return 如果电话号码相匹配则返回value
     * 当使用了@Cacheable注解，在返回时填入null即可。若缓存中key有对应的值则返回，无则返回null
     * 当使用了@Cacheable注解，需要被springboot的容器管理才能生效
     */
    @Cacheable(value = "smsCache", key = "#tel")
    public String get(String tel) {
        return null;
    }
}

注意：此处 @CachePut(value = “smsCache”, key = “#tel”)和@Cacheable(value = “smsCache”, key = “#tel”)的value前缀需要保持一致，否则，在redis中将不能找出相应的value值

13.1.4缓存供应商变更：Memcached

笔记小结

1. memcached下载与安装
2. memcached启动与退出
3. xmemcached客户端加载方式（bean初始化）
4. xmemcached客户端使用方式（set & get）

下载memcached

• 地址：https://www.runoob.com/memcached/window-install-memcached.html

安装memcached

• 使用管理员身份运行cmd指令

  

• 安装

  memcached.exe -d install
  

运行memcached

• 启动服务

  memcached.exe -d start
  

  

• 停止服务

  memcached.exe -d stop
  

  

  可在windows资源管理器界面进行查看

  

memcached客户端选择

• Memcached Client for Java：最早期客户端，稳定可靠，用户群广
• SpyMemcached：效率更高
• Xmemcached：并发处理更好

SpringBoot未提供对memcached的整合，需要使用硬编码方式实现客户端初始化管理

13.1.4.1实现步骤：

1.加入Xmemcache坐标（缓存供应商实现）

<dependency>
    <groupId>com.googlecode.xmemcached</groupId>
    <artifactId>xmemcached</artifactId>
    <version>2.4.7</version>
</dependency>

2.配置memcached服务器必要属性

memcached:
    # memcached服务器地址
    servers: localhost:11211
    # 连接池的数量
    poolSize: 10
    # 设置默认操作超时
    opTimeout: 3000

3.创建读取属性配置信息类，加载配置

@Component
@ConfigurationProperties(prefix = "memcached")
@Data
public class XMemcachedProperties {
    private String servers;
    private Integer poolSize;
    private Long opTimeout;
}

自定义配置属性信息类，在基础配置中有详细记载

@Component为了定义XMemcachedProperties变为springboot管控的bean

@ConfigurationProperties(prefix = “memcached”)是为了读取application.yml文件的配置

4.创建客户端配置类

@Configuration
public class XMemcachedConfig {
    @Autowired
    private XMemcachedProperties xMemcachedProperties;
    @Bean
    public MemcachedClient getMemcachedClinet() throws IOException {
        MemcachedClientBuilder builder = new XMemcachedClientBuilder(xMemcachedProperties.getServers());
        MemcachedClient memcachedClient = builder.build();
        return memcachedClient;
    }
}

5.配置memcached属性

@Service
public class SMSCodeServiceMemcacheImpl implements SMSCodeService {
    @Autowired
    CodeUtil codeUtil;
    //使用自定义配置的XMemcached的配置技术
    @Autowired
    MemcachedClient memcachedClient;
    @Override
    public String sendCodeToSMS(String tel) {
        String code = codeUtil.generator(tel);
        try {
            //设置memcachedClient存入的值
            memcachedClient.set(tel, 10, code);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return code;
    }
}

使用 memcachedClient.set(tele,0,code);进行设置，参数分别为对应的key关键字，timeout超时时间，value值

6.配置memcached属性

@Service
public class SMSCodeServiceMemcacheImpl implements SMSCodeService {
    @Autowired
    CodeUtil codeUtil;
    //使用自定义配置的XMemcached的配置技术
    @Autowired
    MemcachedClient memcachedClient;
    @Override
    public boolean checkCode(CodeMsg codeMsg) {
        String code = null;
        try {
            //获取memcachedClient存入的值
            code = memcachedClient.get(codeMsg.getTele()).toString();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return codeMsg.getCode().equals(value);
    }

}

注意：此时需要用.tostring()方法，因为memcachedClient.get(codeMsg.getTele())返回的是一个对象

13.1.4.2示例：

1.加入Xmemcache坐标（缓存供应商实现）

修改pom.xml

<dependency>
    <groupId>com.googlecode.xmemcached</groupId>
    <artifactId>xmemcached</artifactId>
    <version>2.4.7</version>
</dependency>

2.配置memcached服务器必要属性

配置application.yml文件

memcached:
    # memcached服务器地址
    servers: localhost:11211
    # 连接池的数量
    poolSize: 10
    # 设置默认操作超时
    opTimeout: 3000

3.创建读取属性配置信息类，加载配置

创建config/XMemcachedProperties类

@Component
@ConfigurationProperties(prefix = "memcached")
@Data
public class XMemcachedProperties {
    private String servers;
    private Integer poolSize;
    private Long opTimeout;
}

4.创建客户端配置类

创建config/xMemcachedProperties类

@Configuration
public class XMemcachedConfig {

    @Autowired
    XMemcachedProperties xMemcachedProperties;

    @Bean
    public MemcachedClient getMemcachedClient() throws IOException {
        //创建创建memcachedClient的builder对象
        MemcachedClientBuilder builder = new XMemcachedClientBuilder(xMemcachedProperties.getServers());
        //设置最大连接池个数
        builder.setConnectionPoolSize(xMemcachedProperties.getPoolSize());
        //设置超时时间
        builder.setOpTimeout(xMemcachedProperties.getOpTimeout());
        //创建memcachedClient对象
        MemcachedClient memcachedClient = builder.build();
        return memcachedClient;
    }
}

5.在代码中整合

修改service/impl包下的SMSCodeServiceImpl类

@Service
public class SMSCodeServiceImpl implements ISMSCodeService {
    @Autowired
    CodeUtil codeUtil;

    //使用自定义配置的XMemcached的配置技术
    @Autowired
    MemcachedClient memcachedClient;

    @Override
    public String sendCodeToSMS(String tel) {
        String code = codeUtil.generator(tel);
        try {
            //设置memcachedClient存入的值
            memcachedClient.set(tel, 10, code);
        } catch (TimeoutException e) {
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (MemcachedException e) {
            throw new RuntimeException(e);
        }
        return code;
    }

    @Override
    public boolean checkCode(SMSCode smsCode) {
        String code;
        try {
            //获取memcachedClient存入的值
            code = memcachedClient.get(smsCode.getTel()).toString();
        } catch (TimeoutException e) {
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (MemcachedException e) {
            throw new RuntimeException(e);
        }
        return smsCode.getCode().equals(code);
    }
}

13.1.5缓存供应商变更：jetcache（重点）

13.1.5.1启用配置注解

笔记小结

1.jetcache简介

2.jetcache远程缓存使用方式

3.jetcache本地缓存使用方式

• jetCache对SpringCache进行了封装，在原有功能基础上实现了多级缓存、缓存统计、自动刷新、异步调用、数据报表等功能

• jetCache设定了本地缓存与远程缓存的多级缓存解决方案

  • 本地缓存（local）

    • LinkedHashMap

    • Caffeine

  • 远程缓存（remote）

    • Redis

    • Tair

13.1.5.1.1实现步骤：

1.加入jetcache坐标

<dependency>
    <groupId>com.alicp.jetcache</groupId>
    <artifactId>jetcache-starter-redis</artifactId>
    <version>2.6.7</version>
</dependency>

注意：经测试，当版本控制在2.6.7时，不会发生springboot2.7.x与jetcache的版本冲突导致的循环报错

2.配置远程缓存必要属性

jetcache:
  remote:
    default:
      type: redis
      host: localhost
      port: 6379
      poolConfig:
        maxTotal: 50
    sms:
      type: redis
      host: localhost
      port: 6379
      poolConfig:
        maxTotal: 50

注意： poolConfig是必须要配置，否则会报错

3.配置本地缓存必要属性

jetcache:
  local:
    default:
      type: linkedhashmap
      keyConvertor: fastjson

配置本地缓存有两个必要的属性，分别是type与keyConvertor

本地缓存的类型有两种，其中一种是linkedhashmap

本地缓存需要配置keyConvertor(fastjson可以将对象转换为json格式的字符串)，为了让存入本地的key转换为字符串，当key存为object时，会加大本地索引key的难度

完整示例：

jetcache:
  statIntervalMinutes: 15
  areaInCacheName: false
  local:
    default:
      type: linkedhashmap
      keyConvertor: fastjson
      limit: 100
  remote:
    default:
      host: localhost
      port: 6379
      type: redis
      keyConvertor: fastjson
      valueEncoder: java
      valueDecoder: java
      poolConfig:
        minIdle: 5
        maxIdle: 20
        maxTotal: 50

补充：配置属性说明

3.开启jetcache注解支持

@SpringBootApplication
@EnableCreateCacheAnnotation
public class Springboot19CacheApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot19CacheApplication.class, args);
    }
}

使用**@EnableCreateCacheAnnotation**，表示使用注解开启创建缓存

4.声明缓存对象

@Service
public class SMSCodeServiceImpl implements SMSCodeService {
    @Autowired
    private CodeUtils codeUtils;
    @CreateCache(area = "default", name = "smsCache_", expire = 3600, timeUnit = TimeUnit.SECONDS, cacheType = CacheType.REMOTE)
    private Cache<String, String> jetSMSCache;
}

@CreateCache：area表示哪一组配置，name表示key的前缀。expire表示超时时间设置。timeUnit通常与expire连用，表示超时设置的时间单位，默认值为秒数。cacheType表示缓存的读取类型为本地，远程都能读取到

注意Cache<String,String>导包，import com.alicp.jetcache.Cache;

5.操作缓存

@Service
public class SMSCodeServiceImpl implements SMSCodeService {
    @Override
    public String sendCodeToSMS(String tele) {
        String code = this.codeUtils.generator(tele);
        jetSMSCache.put(tele,code);
        return code;
    }
    @Override
    public boolean checkCode(CodeMsg codeMsg) {
        String value = jetSMSCache.get(codeMsg.getTele());
        return codeMsg.getCode().equals(value);
    }
}

jetSMSCache.put(tele,code);

jetSMSCache.get(codeMsg.getTele());

即可获取或者key对应的值

13.1.5.1.2示例：

1.加入jetcache坐标

<dependency>
    <groupId>com.alicp.jetcache</groupId>
    <artifactId>jetcache-starter-redis</artifactId>
    <version>2.6.7</version>
</dependency>

2.添加application.yml配置

#jetcache
jetcache:
  #远程方案
  remote:
    default:
      type: redis
      host: localhost
      port: 6379
      poolConfig:
        maxTotal: 50
#  #本地方案
#  local:
#    default:
#      type: linkedhashmap
#      keyConvertor: fastjson

3.Springboot20JetcacheApplication

@SpringBootApplication
//jetcache启用缓存的主开关
@EnableCreateCacheAnnotation
public class Springboot20JetcacheApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot20JetcacheApplication.class, args);
    }
}

4.业务成的实现类

@Service
public class SMSCodeServiceImpl implements ISMSCodeService {
    @Autowired
    CodeUtil codeUtil;

    @CreateCache(area = "default", name = "smsCache_", expire = 3600, timeUnit = TimeUnit.SECONDS)
    private Cache<String, String> jetSMSCache;

    @Override
    public String sendCodeToSMS(String tel) {
        String code = codeUtil.generator(tel);
        jetSMSCache.put(tel, code);
        return code;
    }

    @Override
    public boolean checkCode(SMSCode smsCode) {
        String code = jetSMSCache.get(smsCode.getTel());
        return smsCode.getCode().equals(code);
    }
}

补充：

CodeUtil.class

@Component
public class CodeUtil {

    /**
     * 获取随机验证码
     *
     * @param tel 手机号
     * @return 验证码
     */
    public String generator(String tel) {
        //hashCode() 方法用于返回字符串的哈希码,哈希码通过相应计算得来。
        int hashCode = tel.hashCode();
        //定义加密数字
        int encryption = 20040213;
        //一层加密
        long result = hashCode ^ encryption;
        //获取当前时间
        long nowTime = System.currentTimeMillis();
        //二层加密
        result = result ^ nowTime;
        String temp = String.valueOf(result);
        return temp.substring(temp.length() - 6);
    }

    /**
     * 取出缓存中的验证码
     *
     * @param tel 电话号码
     * @return 如果电话号码相匹配则返回value
     * 当使用了@Cacheable注解，在返回时填入null即可。若缓存中key有对应的值则返回，无则返回null
     * 当使用了@Cacheable注解，需要被springboot的容器管理才能生效
     */
    @Cacheable(value = "smsCache", key = "#tel")
    public String get(String tel) {
        return null;
    }
}

13.1.5.2启用方法注解

笔记小结

jetcache方法注解使用方式

13.1.5.2.1实现步骤：

1.在启动类上添加注解

Springboot20JetcacheApplication

@SpringBootApplication
//jetcache启用缓存的主开关
@EnableCreateCacheAnnotation
@EnableMethodCache(basePackages = "com.example")
public class Springboot20JetcacheApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot20JetcacheApplication.class, args);
    }
}

注意

@EnableCreateCacheAnnotation
@EnableMethodCache(basePackages = “com.example”)(注意，方法注解，需要添加此注解)
两个注解需要联合使用，basePackages为启动方法缓存的包名，支持数组写法

2.使用方法注解操作缓存

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;

    @Cached(name = "smsCache_", key = "#id", expire = 3600)
    @CacheRefresh(refresh = 10,timeUnit = TimeUnit.SECONDS)
    public Book getById(Integer id) {
        return bookDao.selectById(id);
    }


    @CacheUpdate(name = "smsCache_", key = "#book.id", value = "#book")
    public boolean update(Book book) {
        return bookDao.updateById(book) > 0;
    }

    @CacheInvalidate(name = "smsCache_", key = "#id")
    public boolean delete(Integer id) {
        return bookDao.deleteById(id) > 0;
    }
}

当主系统与子系统让数据发生变化时，建议使用 @CacheRefresh(refresh = 10,timeUnit = TimeUnit.SECONDS)注解，让内存中的数据保持同步（系统会根据预定的时间，自动向数据库进行查询）

使用 **@CacheUpdate(**name = “smsCache_”, key = “#book.id”, value = “#book”)与， @CacheInvalidate(name = “smsCache_”, key = “#id”)是为了让缓存中的数据保持同步的更新或者删除

补充：若查询缓存中不存在的数据，系统会自动向数据库进行检索查询

3.缓存对象必须保障可序列化

@Data
public class Book implements Serializable {
}

jetcache:
  remote:
    default:
      type: redis
      keyConvertor: fastjson
      valueEncoder: java
      valueDecoder: java

keyConvertor: fastjson，将存入redis的key值，转换成字符串
valueEncoder: java，将进去的值转换为java对象
valueDecoder: java，将出来的值也转换为java对象

否则报错

4.查看缓存统计报告

jetcache:
  statIntervalMinutes: 15

在yml配置上添加即可

13.1.6缓存供应商变更：j2cache

• j2cache是一个缓存整合框架，可以提供缓存的整合方案，使各种缓存搭配使用，自身不提供缓存功能
• 基于 ehcache + redis 进行整合

13.1.6.1实现步骤：

1.加入j2cache坐标，加入整合缓存的坐标

<dependency>
    <groupId>net.oschina.j2cache</groupId>
    <artifactId>j2cache-spring-boot2-starter</artifactId>
    <version>2.8.0-release</version>
</dependency>
<dependency>
    <groupId>net.oschina.j2cache</groupId>
    <artifactId>j2cache-core</artifactId>
    <version>2.8.4-release</version>
</dependency>
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

j2cache-spring-boot2-starter与 j2cache-core为j2cache框架的核心坐标，ehcache是缓存

2.配置使用j2cache（application.yml）

j2cache:
  config-location: j2cache.properties

3.配置一级缓存与二级缓存以及一级缓存数据到二级缓存的发送方式（j2cache.properties）

# 配置1级缓存
j2cache.L1.provider_class = ehcache
ehcache.configXml = ehcache.xml

# 配置1级缓存数据到2级缓存的广播方式：可以使用redis提供的消息订阅模式，也可以使用jgroups多播实现
j2cache.broadcast = net.oschina.j2cache.cache.support.redis.SpringRedisPubSubPolicy

# 配置2级缓存
j2cache.L2.provider_class = net.oschina.j2cache.cache.support.redis.SpringRedisProvider
j2cache.L2.config_section = redis
redis.hosts = localhost:6379

j2cache.broadcast = net.oschina.j2cache.cache.support.redis.SpringRedisPubSubPolicy,是将缓存数据的推送方式定为 发布与订阅

j2cache.L2.provider_class = net.oschina.j2cache.cache.support.redis.SpringRedisProvider,是用的内置的redis技术进行缓存

补充：若想要得到更多的缓存配置，则可以查看核心库的jar包文件做参考

4.配置ehcache.xml文件(ehcache.xml)

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--默认缓存策略 -->
    <!-- external：是否永久存在，设置为true则不会被清除，此时与timeout冲突，通常设置为false-->
    <!-- diskPersistent：是否启用磁盘持久化-->
    <!-- maxElementsInMemory：最大缓存数量-->
    <!-- overflowToDisk：超过最大缓存数量是否持久化到磁盘-->
    <!-- timeToIdleSeconds：最大不活动间隔，设置过长缓存容易溢出，设置过短无效果-->
    <!-- timeToLiveSeconds：最大存活时间-->
    <!-- memoryStoreEvictionPolicy：缓存清除策略-->

    <defaultCache
            eternal="false"
            diskPersistent="false"
            maxElementsInMemory="1000"
            overflowToDisk="false"
            timeToIdleSeconds="60"
            timeToLiveSeconds="60"
            memoryStoreEvictionPolicy="LRU"/>
</ehcache>

配置文件可从maven包里面进行查找

5.设置使用缓存

@Service
public class SMSCodeServiceImpl implements SMSCodeService {
    @Autowired
    private CodeUtils codeUtils;
    @Autowired
    private CacheChannel cacheChannel;
}

定义CacheChannel缓存频道

@Service
public class SMSCodeServiceImpl implements SMSCodeService {
    @Override
    public String sendCodeToSMS(String tele) {
        String code = codeUtils.generator(tele);
        cacheChannel.set("sms",tele,code);
        return code;
    }
    @Override
    public boolean checkCode(SMSCode smsCode) {
        String code = cacheChannel.get("sms",smsCode.getTele()).asString();
        return smsCode.getCode().equals(code);
    }
}

通过频道进行set和get即可使用

as 运算符类似于强制转换，不同的是，当转换失败时，运算符将产生null值，而不是引发异常。

因此asString是强制转换，异常为空，与toString进行区别开来

13.1.6.2示例：

1.加入坐标

<!--j2cache-->
<dependency>
    <groupId>net.oschina.j2cache</groupId>
    <artifactId>j2cache-spring-boot2-starter</artifactId>
    <version>2.8.0-release</version>
</dependency>
<dependency>
    <groupId>net.oschina.j2cache</groupId>
    <artifactId>j2cache-core</artifactId>
    <version>2.8.4-release</version>
</dependency>
<!--ehcache-->
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

2.配置使用j2cache文件（application.yml）

j2cache:
  config-location: j2cache.properties

3.配置使用j2cache缓存（j2cache.properties）

# 配置1级缓存
j2cache.L1.provider_class=ehcache
ehcache.configXml=ehcache.xml
# 配置2级缓存
j2cache.L2.provider_class=net.oschina.j2cache.cache.support.redis.SpringRedisProvider
j2cache.L2.config_section=redis
redis.hosts=localhost:6379
# 配置1级缓存数据到2级缓存的广播方式：可以使用redis提供的消息订阅模式，也可以使用jgroups多播实现(1级缓存如何达到2级缓存)
j2cache.broadcast=net.oschina.j2cache.cache.support.redis.SpringRedisPubSubPolicy

4.配置使用j2cache的ehcache方案（ehcache.xml）

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--默认缓存策略 -->
    <!-- external：是否永久存在，设置为true则不会被清除，此时与timeout冲突，通常设置为false-->
    <!-- diskPersistent：是否启用磁盘持久化-->
    <!-- maxElementsInMemory：最大缓存数量-->
    <!-- overflowToDisk：超过最大缓存数量是否持久化到磁盘-->
    <!-- timeToIdleSeconds：最大不活动间隔，设置过长缓存容易溢出，设置过短无效果-->
    <!-- timeToLiveSeconds：最大存活时间-->
    <!-- memoryStoreEvictionPolicy：缓存清除策略-->

    <defaultCache
            eternal="false"
            diskPersistent="false"
            maxElementsInMemory="1000"
            overflowToDisk="false"
            timeToIdleSeconds="60"
            timeToLiveSeconds="60"
            memoryStoreEvictionPolicy="LRU"/>
</ehcache>

5.业务成实现类

@Service
public class SMSCodeServiceImpl implements ISMSCodeService {
    @Autowired
    CodeUtil codeUtil;

    @Autowired
    CacheChannel cacheChannel;

    @Override
    public String sendCodeToSMS(String tel) {
        String code = codeUtil.generator(tel);
        cacheChannel.set("sms", tel, code);
        return code;
    }

    @Override
    public boolean checkCode(SMSCode smsCode) {
        String code = cacheChannel.get("sms",smsCode.getTel()).asString();
        return smsCode.getCode().equals(code);
    }
}

13.2任务

普通定时

public class TimerTaskApp {

    public static void main(String[] args) {
        Timer timer = new Timer();
        //task是个抽象类，因此可以直接new
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Timer is running……");
            }
        };
        //每间隔两秒就执行一下timer对象
        timer.schedule(task, 0, 2000);
    }
}

不规范，因此就有人做了定时任务技术

定时任务是企业级应用中的常见操作

• 年度报表
• 缓存统计报告
• … …

市面上流行的定时任务技术

• Quartz
• Spring Task

相关概念

• 工作（Job）：用于定义具体执行的工作
• 工作明细（JobDetail）：用于描述定时工作相关的信息
• 触发器（Trigger）：用于描述触发工作的规则，通常使用cron表达式定义调度规则
• 调度器（Scheduler）：描述了工作明细与触发器的对应关系

13.2.1Quartz

笔记小结

SpringBoot整合Quartz

• 工作（Job）
• 工作明细（JobDetail）
• 触发器（Trigger）
• 调度器（Scheduler）

13.2.1.1实现步骤：

1.导入SpringBoot整合quartz的坐标

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

2.定义具体要执行的任务，继承****QuartzJobBean

public class QuartzTaskBean extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        System.out.println("quartz job run... ");
    }
}

注意，此处并不定义类为springboot管控的类，而是跟普通java对象一样继承QuartzJobBean

定义具体要执行的任务，继承QuartzJobBean

当工作明细指定了此工作时，就会自动执行**executeInternal()**方法

3.定义工作明细与触发器，并绑定对应关系

@Configuration
public class QuartzConfig {
    //工作明细
    @Bean
    public JobDetail printJobDetail(){
        return JobBuilder.newJob(QuartzTaskBean.class).storeDurably().build();
    }
    //触发器
    @Bean
    public Trigger printJobTrigger() {
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/3 * * * * ?");
        return TriggerBuilder.newTrigger().forJob(printJobDetail())
            .withSchedule(cronScheduleBuilder).build();
    }
}

newJob指定需要让那个job进行工作

storeDurably让具体的工作进行实例化存储

withSchedule添加定时计划

forJob指定工作明细

13.2.2Spring Task✳

笔记小结

Spring Task

• @EnableScheduling
• @Scheduled

13.2.2.1实现步骤：

1.开启定时任务功能

@SpringBootApplication
//开启定时任务
@EnableScheduling
public class Springboot22TaskApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot22TaskApplication.class, args);
    }
}

在启动类上添加**@EnableScheduling注解**，表示启动定时任务

2.设置定时执行的任务，并设定执行周期

@Component
public class ScheduledBean {
    @Scheduled(cron = "0/5 * * * * ?")
    public void printLog(){
        System.out.println(Thread.currentThread().getName()+":run...");
    }
}

定义为springboot管控的对象，与Quartz做区别

添加 @Scheduled(cron = “0/5 * * * * ?”)，填入相应的cron表达式即可

“0/5 * * * * ?”，表示每5秒执行一次

3.定时任务相关配置(可省略)

spring:
  task:
    scheduling:
      # 任务调度线程池大小 默认 1
      pool:
        size: 1
      # 调度线程名称前缀 默认 scheduling-
      thread-name-prefix: ssm_
      shutdown:
        # 线程池关闭时等待所有任务完成
        await-termination: false
        # 调度线程关闭前最大等待时间，确保最后一定关闭
        await-termination-period: 10s

thread-name-prefix配置线程名称前缀，可通过Thread.currentThread().getName()进行获取

13.2.2.2示例：

1.启动类

@SpringBootApplication
//开启定时任务
@EnableScheduling
public class Springboot22TaskApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot22TaskApplication.class, args);
    }
}

2.配置类

创建config/ScheduledBean类

@Component
public class ScheduledBean {

    @Scheduled(cron = "0/5 * * * * ?")
    public void printLog() {
        System.out.println("Schedule is running……");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pi7LMQoG-1678687150053)(SpringBoot2.assets/image-20230209162804808.png)]

3.额外配置(application.yml)

spring:
  task:
    scheduling:
      # 任务调度线程池大小 默认 1
      pool:
        size: 1
      # 调度线程名称前缀 默认 scheduling-
      thread-name-prefix: ssm_
      shutdown:
        # 线程池关闭时等待所有任务完成
        await-termination: false
        # 调度线程关闭前最大等待时间，确保最后一定关闭
        await-termination-period: 10s

13.3邮件

笔记小结

SpringBoot整合JavaMail发送简单邮件

13.3.1SpringBoot整合JavaMail

• SMTP（Simple Mail Transfer Protocol）：简单邮件传输协议，用于发送电子邮件的传输协议
• POP3（Post Office Protocol - Version 3）：用于接收电子邮件的标准协议
• IMAP（Internet Mail Access Protocol）：互联网消息协议，是POP3的替代协议

13.3.1.1实现步骤：

1.导入SpringBoot整合JavaMail的坐标

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

2.配置JavaMail

spring:
  mail:
   # 邮件供应商，smtp代表发送，qq.com表示使用qq邮件
    host: smtp.qq.com
    username: *********@qq.com
    password: *********

配置授权信息

记得在邮件中开启相应服务

此时的passsword不是你账户的密码，是开启服务后相应的值

3.开启发送任务功能—简单邮件

@Service
public class SendMailServiceImpl implements SendMailService {
    //定义一个邮件寄送者
    @Autowired
    private JavaMailSender javaMailSender;
    private String from = "********@qq.com";	 // 发送人
    private String to = "********@126.com";	 // 接收人
    private String subject = "测试邮件";		 // 邮件主题
    private String text = "测试邮件正文";	 	// 邮件内容
    @Override
    public void sendMail() {
        SimpleMailMessage mailMessage = new SimpleMailMessage();
        //设置发送人
        //mailMessage.setFrom(from+"(小甜甜)");
        mailMessage.setFrom(from);
        //设置接收人
        mailMessage.setTo(to);
        //设置邮件主题
        mailMessage.setSubject(subject);
        //设置邮件内容
        mailMessage.setText(text);
        //发送邮件
        javaMailSender.send(mailMessage);
    }
}

注意：配置在application.yml文件中的配置信息的username需要与发送人一直，否则会报错：

补充：若在设置 //**mailMessage.setFrom(from+“(小甜甜)”);**添加名称，那么发送邮件时，会替代相关发送人信息

3.开启发送任务功能—复杂邮件

@Service
public class SendMailServiceImpl2 implements ISendMailService {

    @Autowired
    JavaMailSender javaMailSender;

    // 发送人
    private String from = "[email protected]";
    // 接收人
    private String to = "[email protected]";
    // 邮件主题
    private String subject = "测试邮件";
    // 邮件内容
    private String text = "测试邮件正文";
    //html标签
    private String htmlTest = "<a href='https://www.baidu.com/'>百度一下</a>";

    /**
     * 发送邮件
     */
    @Override
    public void sendMail() {
        try {
            MimeMessage mimeMessage = javaMailSender.createMimeMessage();
            //创建helper对象---若需要多个附件，则需要设置第二个multipart参数为true
            MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
            //设置发送人
            helper.setFrom(from);
            //设置接收人
            helper.setTo(to);
            //设置邮件主题
            helper.setSubject(subject);
            //设置邮件内容---若需要让页面解析html，则需要设置第二个html参数为true
            helper.setText(text + htmlTest, true);
            //设置附件---添加附件，需要使用FIle进行读取本地的相关资源
            File file = new File("E:\\Documents\\Learn\\SpringBoot\\springboot_23_mail\\src\\main\\resources\\static\\微信图片_20230209221711.jpg");
            //将attachmentFilename的名字加上后缀，可在浏览器中直接预览
            helper.addAttachment("大美女.png", file);
            File file1 = new File("E:\\Documents\\Learn\\SpringBoot\\springboot_23_mail\\target\\springboot_23_mail-0.0.1-SNAPSHOT.jar");
            helper.addAttachment(file1.getName(), file1);
            //发送邮件
            javaMailSender.send(mimeMessage);
        } catch (MessagingException e) {
            throw new RuntimeException(e);
        }
    }
}

4.调用功能

@SpringBootTest
class Springboot23MailApplicationTests {

    @Autowired
    ISendMailService service;
    @Test
    void contextLoads() {
        service.sendMail();
    }

}

在test中直接进行调用

13.3.1.2示例：

1.导入坐标

在pom.xml文件中

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

2.配置JavaMail

在application.yml文件中

spring:
  mail:
   # 邮件供应商，smtp代表发送，qq.com表示使用qq邮件
    host: smtp.qq.com
    username: *********@qq.com
    password: *********

3.开启发送任务功能

@Service
public class SendMailServiceImpl implements SendMailService {
    //定义一个邮件寄送者
    @Autowired
    private JavaMailSender javaMailSender;
    private String from = "********@qq.com";	 // 发送人
    private String to = "********@126.com";	 // 接收人
    private String subject = "测试邮件";		 // 邮件主题
    private String text = "测试邮件正文";	 	// 邮件内容
    @Override
    public void sendMail() {
        SimpleMailMessage mailMessage = new SimpleMailMessage();
        //设置发送人
        //mailMessage.setFrom(from+"(小甜甜)");
        mailMessage.setFrom(from);
        //设置接收人
        mailMessage.setTo(to);
        //设置邮件主题
        mailMessage.setSubject(subject);
        //设置邮件内容
        mailMessage.setText(text);
        //发送邮件
        javaMailSender.send(mailMessage);
    }
}

4.测试

在Springboot23MailApplicationTests.java文件中

@SpringBootTest
class Springboot23MailApplicationTests {

    @Autowired
    ISendMailService service;

    @Test
    void contextLoads() {
        service.sendMail();
    }