SpringBoot + Vue + ElementUI 實現后台管理系統模板 -- 后端篇（二）：整合 Redis（常用工具類、緩存）、整合郵件發送功能

本文轉載自查看原文 2020-06-19 16:15 1636 后台管理系統模板

（1）相關博文地址：

SpringBoot + Vue + ElementUI 實現后台管理系統模板 -- 前端篇（一）：搭建基本環境：https://www.cnblogs.com/l-y-h/p/12930895.html
SpringBoot + Vue + ElementUI 實現后台管理系統模板 -- 前端篇（二）：引入 element-ui 定義基本頁面顯示：https://www.cnblogs.com/l-y-h/p/12935300.html
SpringBoot + Vue + ElementUI 實現后台管理系統模板 -- 前端篇（三）：引入 js-cookie、axios、mock 封裝請求處理以及返回結果：https://www.cnblogs.com/l-y-h/p/12955001.html
SpringBoot + Vue + ElementUI 實現后台管理系統模板 -- 前端篇（四）：引入 vuex 進行狀態管理、引入 vue-i18n 進行國際化管理：https://www.cnblogs.com/l-y-h/p/12963576.html
SpringBoot + Vue + ElementUI 實現后台管理系統模板 -- 前端篇（五）：引入 vue-router 進行路由管理、模塊化封裝 axios 請求、使用 iframe 標簽嵌套頁面：https://www.cnblogs.com/l-y-h/p/12973364.html
SpringBoot + Vue + ElementUI 實現后台管理系統模板 -- 前端篇（六）：使用 vue-router 進行動態加載菜單：https://www.cnblogs.com/l-y-h/p/13052196.html
SpringBoot + Vue + ElementUI 實現后台管理系統模板 -- 后端篇（一）： 搭建基本環境、整合 Swagger、MyBatisPlus、JSR303 以及國際化操作：https://www.cnblogs.com/l-y-h/p/13083375.html

（2）代碼地址：

https://github.com/lyh-man/admin-vue-template.git

一、SpringBoot 整合 Redis

1、簡單回顧一下 Redis

（1）特點：
　　基於 key-value 存儲。
　　支持多種數據結構：string（字符串）、list（列表）、set（集合）、zset（sorted set 有序集合）、hash（哈希）。
　　通過內存存儲、操作數據，支持持久化將數據存儲在硬盤中。
　　支持過期時間、事務。
參考：
　　https://www.cnblogs.com/l-y-h/p/12715723.html

（2）什么時候使用？
　　一般把經常查詢、不經常修改且不是特別重要的數據放到 redis 中作為緩存（比如網站首頁的一些圖片、視頻等）。

（3）Redis 與 Memcache 區別？
　　二者都是將數據緩存在內存中。
　　Memcache 只能將數據緩存在內存中，無法將數據寫入硬盤，即機器斷電、重啟使內存清空后，數據會丟失。適用於緩存無需持久化的數據。
　　Redis 可以周期性的將數據存入磁盤（RDB）或者將寫操作以追加的方式寫入文件（AOF）的方式對數據進行持久化。

2、SpringBoot 整合 Redis 緩存

（1）使用緩存目的：
　　對於一些經常被查詢的數據，若每次都從數據庫中獲取，則會極大地消耗系統性能，將這些數據放在緩存中，並設置過期時間，查詢時若緩存中有值，則從緩存中獲取，否則從數據庫中獲取，並將新值存入緩存。這樣可以減輕數據庫的訪問頻率，從而提高系統性能。

（2）安裝 Redis

【docker 安裝 Redis 參考：】
    https://www.cnblogs.com/l-y-h/p/12622730.html#_label6

【linux（CnetOs7） 安裝 Redis 參考：】
    https://www.cnblogs.com/l-y-h/p/12656614.html#_label0_1

（3）添加依賴信息

<!-- redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- spring2.X集成redis所需common-pool2-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.6.0</version>
</dependency>

（4）配置 Redis
　　SpringBoot 2.x 采用 lettuce 客戶端，而非 Jedis。
如下：host 為 redis 存在的 ip 地址（需修改）。

【yml：】
spring:
  # Redis 配置
  redis:
    # Redis 服務器地址
    host: 121.26.184.41
    # 連接端口號
    port: 6379
    # 數據庫索引（0 - 15）
    database: 0
    # 連接超時時間（毫秒）
    timeout: 10000
    # lettuce 參數
    lettuce:
      pool:
        # 最大連接數(使用負值表示沒有限制) 默認為 8
        max-active: 10
        # 最大阻塞等待時間(使用負值表示沒有限制) 默認為 -1 ms
        max-wait: -1
        # 最大空閑連接 默認為 8
        max-idle: 5
        # 最小空閑連接 默認為 0
        min-idle: 0

【properties：】
# Redis 服務器地址
spring.redis.host=121.26.184.41
# 連接端口號
spring.redis.port=6379
# 數據庫（0 - 15）
spring.redis.database= 0
# 超時時間（毫秒）
spring.redis.timeout=600000

# lettuce 參數
# 最大連接數(使用負值表示沒有限制) 默認為 8
spring.redis.lettuce.pool.max-active=20
# 最大阻塞等待時間(使用負值表示沒有限制) 默認為 -1
spring.redis.lettuce.pool.max-wait=-1
# 最大空閑連接 默認為 8
spring.redis.lettuce.pool.max-idle=5
# 最小空閑連接 默認為 0
spring.redis.lettuce.pool.min-idle=0

（5）新增一個 Redis 配置類 RedisConfig.java
　　用於自定義配置、使用 Redis。
　　當然可以直接注入並使用 RedisTemplate，源碼中給出的是 RedisTemplate<Object, Object>，使用起來有些許不便。

　　自定義 RedisConfig.java 配置類如下：
　　@EnableCaching 表示開啟緩存功能。

package com.lyh.admin_template.back.common.config;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * 配置 redisTemplate
     */
    @Bean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 實例化一個 redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 配置連接工廠
        redisTemplate.setConnectionFactory(factory);
        // 設置 key 序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 設置 value 序列化方式
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // 設置 hash key 序列化方式
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // 設置 hash value 序列化方式
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }

    /**
     * 配置緩存
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        // 定義緩存 key 前綴，默認為 ::
        final String keyPrefix = ":";
        // 緩存對象配置
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                // 設置緩存默認超時時間：600 秒
                .entryTtl(Duration.ofSeconds(600))
                // 設置 key 序列化器
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                // 設置 value 序列化器
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
                // 如果該值為 null，則不緩存
                .computePrefixWith(cacheName -> cacheName + keyPrefix)
                .disableCachingNullValues();
        // 根據 redis 緩存配置生成 redis 緩存管理器
        RedisCacheManager redisCacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .transactionAware()
                .build();
        return redisCacheManager;
    }
}

（6）使用注解標注即可。
常用注解：

【@Cacheable】
    標注在方法上（一般標注在查詢操作的方法上），將方法的返回結果進行緩存，下次請求時，
    若緩存存在，則直接讀取緩存數據。
    若緩存不存在，則執行方法，並將返回結果再次保存在緩存中。
常用屬性：
    value、cacheNames   表示緩存命名空間，二選一，不能為空。
    keyGenerator        表示 key 生成規則。 
    key                 表示 key 名。
    
【@CachePut】
    標注在方法上（一般標注在新增操作的方法上），將方法的返回結果進行緩存。
注：
    其每次都會執行，不管緩存中是否有值。
常用屬性：
    value、cacheNames   表示緩存命名空間，二選一，不能為空。
    keyGenerator        表示 key 生成規則。 
    key                 表示 key 名。

【@CacheEvict】
    標注在方法上（一般用於更新操作、刪除操作的方法上），清空指定的緩存。
常用屬性：
    value、cacheNames   表示緩存命名空間，二選一，不能為空。
    keyGenerator        表示 key 生成規則。 
    allEntries          默認為 false，若為 true 表示方法執行后清空緩存。
    beforeInvocation    默認為 false，若為 true 表示方法執行前清空緩存。
    key                 表示 key 名。

在 TestController.java 中編寫測試代碼用於測試上面三個注解的用法：

package com.lyh.admin_template.back.controller;

import com.lyh.admin_template.back.common.utils.Result;
import com.lyh.admin_template.back.service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用於測試環境搭建各個功能是否成功
 */
@RestController
@RequestMapping("/test")
@Api(tags = "測試頁面")
public class TestController {

    @Autowired
    private UserService userService;

    @Cacheable(value = "list", key = "'userList'")
    @ApiOperation(value = "測試 Redis 緩存注解 @Cacheable")
    @GetMapping("/testRedis/cacheable")
    public Result testRedisCacheable() {
        return Result.ok().data("item", userService.list());
    }

    @CachePut(value = "list", key = "'userList2'")
    @ApiOperation(value = "測試 Redis 緩存注解 @CachePut")
    @GetMapping("/testRedis/cachePut")
    public Result testRedisCachePut() {
        return Result.ok().data("item", userService.list());
    }

    @CacheEvict(value = "list", key = "'userList'")
    @ApiOperation(value = "測試 Redis 緩存注解 @CacheEvict")
    @GetMapping("/testRedis/cacheEvict")
    public Result testRedisCacheEvict() {
        return Result.ok().data("item", userService.list());
    }
}

使用 swagger.ui 簡單測試一下：
　　首先，執行 testRedisCacheable、testRedisCachePut 方法，兩者獲取數據都是一樣的，且都會存於緩存中。
　　直接修改數據庫數據，再次訪問，testRedisCacheable 不會獲取到數據庫最新的值（返回緩存中的值），但是 testRedisCachePut 會取到最新數據庫的值。
　　然后訪問 testRedisCacheEvict 方法，可以查看到 testRedisCacheable 的緩存被刪除，重新訪問 testRedisCacheable 可以獲取到最新數據庫的數據。

3、整一個 Redis 常用工具類 RedisUtil.java

（1）基本使用

RedisTemplate 中操作 Redis 如下：
    HashOperations           通過 redisTemplate.opsForHash() 獲取，用於操作 hash 
    ValueOperations          通過 redisTemplate.opsForValue() 獲取，用於操作 string
    ListOperations           通過 redisTemplate.opsForList() 獲取，用於操作 list
    SetOperations            通過 redisTemplate.opsForSet() 獲取，用於操作 set
    ZSetOperations           通過 redisTemplate.opsForZSet() 獲取，用於操作 zset

可以直接通過方法獲取，也可以通過配置文件並使用 @Bean 標注方式交給 Spring 管理。
如下，在配置文件中通過 @Bean 標注。

package com.lyh.admin_template.back.common.config;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * 配置 redisTemplate
     */
    @Bean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 實例化一個 redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 配置連接工廠
        redisTemplate.setConnectionFactory(factory);
        // 設置 key 序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 設置 value 序列化方式
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // 設置 hash key 序列化方式
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // 設置 hash value 序列化方式
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }

    /**
     * 配置緩存
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        // 定義緩存 key 前綴，默認為 ::
        final String keyPrefix = ":";
        // 緩存對象配置
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                // 設置緩存默認超時時間：600 秒
                .entryTtl(Duration.ofSeconds(600))
                // 設置 key 序列化器
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                // 設置 value 序列化器
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
                // 如果該值為 null，則不緩存
                .computePrefixWith(cacheName -> cacheName + keyPrefix)
                .disableCachingNullValues();
        // 根據 redis 緩存配置生成 redis 緩存管理器
        RedisCacheManager redisCacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .transactionAware()
                .build();
        return redisCacheManager;
    }

    /**
     * 用於操作 hash
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     * 用於操作 list
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     * 用於操作 set
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     * 用於操作 zset
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }

    /**
     * 用於操作 String
     */
    @Bean
    public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
        return redisTemplate.opsForValue();
    }
}

注：
　　上面對於 value 的處理，采用了 GenericJackson2JsonRedisSerializer 進行序列化、反序列化。
　　其余序列化方式可以參考鏈接（https://www.freesion.com/article/966738549/）。

解決一個坑：
　　GenericJackson2JsonRedisSerializer 反序列化失敗時，首先檢查是否存在默認無參構造器（自定義構造器時，必須得帶上無參構造器(=_=) ）。

（2）編寫工具類 RedisUtil.java
　　如下代碼，基本覆蓋了 Redis 各類型常用的方法，其余方法可以根據需要自行封裝。

package com.lyh.admin_template.back.common.utils;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Redis 工具類
 */
@Component
public class RedisUtil {

    /**
     * 用於操作 redis
     */
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    /**
     * 用於操作 String
     */
    @Autowired
    private ValueOperations<String, String> valueOperations;
    /**
     * 用於操作 hash
     */
    @Autowired
    private HashOperations<String, String, Object> hashOperations;
    /**
     * 用於操作 list
     */
    @Autowired
    private ListOperations<String, Object> listOperations;
    /**
     * 用於操作 set
     */
    @Autowired
    private SetOperations<String, Object> setOperations;
    /**
     * 用於操作 zset
     */
    @Autowired
    private ZSetOperations<String, Object> zSetOperations;

    /* ================================ common ================================== */
    /**
     * 設置默認過期時間（一天）
     */
    public final static long DEFAULT_EXPIRE = 60 * 60 * 24;
    /**
     * 不設置過期時間
     */
    public final static long NOT_EXPIRE = -1;

    /**
     * 設置 key 的過期時間(單位為 秒)
     */
    public void expire(String key, long expire) {
        redisTemplate.expire(key, expire, TimeUnit.SECONDS);
    }

    /**
     * 根據 key 獲取過期時間
     */
    public Long getExpire(String key) {
        return StringUtils.isNotEmpty(key) ? redisTemplate.getExpire(key, TimeUnit.SECONDS) : null;
    }

    /**
     * 根據 pattern 返回匹配的所有 key
     */
    public Set<String> keys(String pattern) {
        return StringUtils.isNotEmpty(pattern) ? redisTemplate.keys(pattern) : null;
    }

    /**
     * 刪除 一個 或 多個 key
     */
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 判斷 key 是否存在
     */
    public Boolean hasKey(String key) {
        return StringUtils.isNotEmpty(key) ? redisTemplate.hasKey(key) : null;
    }
    /* ================================ common ================================== */

    /* ================================ string ================================== */
    /**
     * string set 操作，設置 key-value
     */
    public void set(String key, String value) {
        set(key, value, DEFAULT_EXPIRE);
    }

    /**
     * string set 操作，設置過期時間
     */
    public void set(String key, String value, long expire) {
        valueOperations.set(key, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * string get 操作，獲取 value
     */
    public String get(String key) {
        return StringUtils.isNotEmpty(key) ? valueOperations.get(key) : null;
    }

    /**
     * string incr 操作，加法
     */
    public Long incr(String key, long data) {
        if (data < 0) {
            throw new RuntimeException("請輸入正整數");
        }
        return valueOperations.increment(key, data);
    }

    /**
     * string decr 操作，減法
     */
    public Long decr(String key, long data) {
        if (data < 0) {
            throw new RuntimeException("請輸入正整數");
        }
        return valueOperations.decrement(key, data);
    }
    /* ================================ string ================================== */

    /* ================================ hash ================================== */
    /**
     * hash set 操作，設置 一個 field - value
     */
    public void hset(String key, String field, Object value) {
        hset(key, field, value, DEFAULT_EXPIRE);
    }

    /**
     * hash set 操作，設置過期時間
     */
    public void hset(String key, String field, Object value, long expire) {
        hashOperations.put(key, field, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * hash set 操作，設置 多個 field - value
     */
    public void hmset(String key, Map<String, Object> map) {
        hmset(key, map, DEFAULT_EXPIRE);
    }

    /**
     * hash set 操作，設置過期時間
     * 此處過期時間是對 key 設置，而非 field（即 key 過期，所有的 field 均失效）。
     */
    public void hmset(String key, Map<String, Object> map, long expire) {
        hashOperations.putAll(key, map);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * hash keys 操作，獲取所有的 field
     */
    public Set<String> hkeys(String key) {
        return StringUtils.isNotEmpty(key) ? hashOperations.keys(key) : null;
    }

    /**
     * hash exists 操作，判斷 keys 中是否存在某個 field
     */
    public Boolean hHasKey(String key, String field) {
        if (StringUtils.isNotEmpty(key) && StringUtils.isNotEmpty(field)) {
            return hashOperations.hasKey(key, field);
        }
        return null;
    }

    /**
     * hash del 操作，刪除一個 或 多個 field
     */
    public void hdel(String key, String... field) {
        if (StringUtils.isNotEmpty(key) && field.length > 0) {
            hashOperations.delete(key, field);
        }
    }

    /**
     * hash get 操作，獲取一個 field 對應的 value 值
     */
    public Object hget(String key, String field) {
        if (StringUtils.isNotEmpty(key) && StringUtils.isNotEmpty(field)) {
            return hashOperations.get(key, field);
        }
        return null;
    }

    /**
     * hash get 操作，獲取所有的 value 值
     */
    public List<Object> hmget(String key) {
        return StringUtils.isNotEmpty(key) ? hashOperations.values(key) : null;
    }

    /**
     * hash get 操作，獲取所有的 field-value
     */
    public Map<String, Object> hgetAll(String key) {
        return StringUtils.isNotEmpty(key) ? hashOperations.entries(key) : null;
    }
    /* ================================ hash ================================== */

    /* ================================ list ================================== */
    /**
     * list left push 操作，設置一個 value
     */
    public void lpush(String key, Object value) {
        lpush(key, value, DEFAULT_EXPIRE);
    }

    /**
     * list left push 操作，設置過期時間
     */
    public void lpush(String key, Object value, long expire) {
        listOperations.leftPush(key, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * list left push 操作，設置多個 value
     */
    public void lpush(String key, List<Object> value) {
        lpush(key, value, DEFAULT_EXPIRE);
    }

    /**
     * list left push 操作，設置過期時間
     */
    public void lpush(String key, List<Object> value, long expire) {
        listOperations.leftPushAll(key, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * list right push 操作，設置一個 value
     */
    public void rpush(String key, Object value) {
        rpush(key, value, DEFAULT_EXPIRE);
    }

    /**
     * list right push 操作，設置過期時間
     */
    public void rpush(String key, Object value, long expire) {
        listOperations.rightPush(key, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * list right push 操作，設置多個 value
     */
    public void rpush(String key, List<Object> value) {
        rpush(key, value, DEFAULT_EXPIRE);
    }

    /**
     * list right push 操作，設置過期時間
     */
    public void rpush(String key, List<Object> value, long expire) {
        listOperations.rightPushAll(key, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * list set 操作，根據 index 下標設置 value
     */
    public void lsetIndex(String key, long index, Object value) {
        lsetIndex(key, index, value, DEFAULT_EXPIRE);
    }

    /**
     * list set 操作，設置過期時間
     */
    public void lsetIndex(String key, long index, Object value, long expire) {
        listOperations.set(key, index, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * list range get 操作，獲取指定范圍的 value
     */
    public List<Object> lrange(String key, long start, long end) {
        return StringUtils.isNotEmpty(key) ? listOperations.range(key, start, end) : null;
    }

    /**
     * list index get 操作，根據指定下標返回 value
     */
    public Object lgetIndex(String key, long index) {
        return StringUtils.isNotEmpty(key) ? listOperations.index(key, index) : null;
    }

    /**
     * list len 操作， 獲取 list 長度
     */
    public Long llen(String key) {
        return StringUtils.isNotEmpty(key) ? listOperations.size(key) : null;
    }

    /**
     * list remove 操作，移除 list 中 指定數量的 value
     */
    public Long lremove(String key, long count, Object value) {
        return StringUtils.isNotEmpty(key) ? listOperations.remove(key, count, value) : null;
    }

    /**
     * list trim 操作，截取指定范圍的 value，並作為新的 list
     */
    public void ltrim(String key, long start, long end) {
        listOperations.trim(key, start, end);
    }

    /**
     * list left pop 操作，返回頭部第一個元素
     */
    public Object lpop(String key) {
        return StringUtils.isNotEmpty(key) ? listOperations.leftPop(key) : null;
    }

    /**
     * list right pop 操作，返回尾部第一個元素
     */
    public Object rpop(String key) {
        return StringUtils.isNotEmpty(key) ? listOperations.rightPop(key) : null;
    }
    /* ================================ list ================================== */

    /* ================================ set ================================== */

    /**
     * set set 操作，設置一個 或 多個 value
     */
    public void sset(String key, Object... value) {
        sset(key, DEFAULT_EXPIRE, value);
    }

    /**
     * set set 操作，設置過期時間
     */
    public void sset(String key, long expire, Object... value) {
        setOperations.add(key, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * set smembers 操作，返回所有 value
     */
    public Set<Object> smembers(String key) {
        return StringUtils.isNotEmpty(key) ? setOperations.members(key) : null;
    }

    /**
     * set sisMember 操作，判斷是否存在 某個 value 值
     */
    public Boolean sisMember(String key, Object value) {
        return StringUtils.isNotEmpty(key) ? setOperations.isMember(key, value) : null;
    }

    /**
     * set scard 操作，返回當前 value 個數。
     */
    public Long slen(String key) {
        return StringUtils.isNotEmpty(key) ? setOperations.size(key) : null;
    }

    /**
     * set srem 操作，根據 value 值移除元素
     */
    public Long sremove(String key, Object... value) {
        if (StringUtils.isNotEmpty(key) && value.length > 0) {
            return setOperations.remove(key, value);
        }
        return null;
    }

    /**
     * set spop 操作，隨機移除一個元素
     */
    public Object spop(String key) {
        return StringUtils.isNotEmpty(key) ? setOperations.pop(key) : null;
    }

    /**
     * set spop 操作，隨機移除 指定個數的元素
     */
    public List<Object> spop(String key, long count) {
        return StringUtils.isNotEmpty(key) ? setOperations.pop(key, count) : null;
    }

    /**
     * set srandmember 操作，隨機返回一個 元素（非移除）
     */
    public Object srandomMember(String key) {
        return StringUtils.isNotEmpty(key) ? setOperations.randomMember(key) : null;
    }

    /**
     * set srandmember 操作，隨機返回指定個數的 元素（非移除）
     */
    public List<Object> srandomMember(String key, long count) {
        return StringUtils.isNotEmpty(key) ? setOperations.randomMembers(key, count) : null;
    }
    /* ================================ set ================================== */

    /* ================================ zset ================================== */

    /**
     * zset set 操作，設置一個 value
     */
    public void zset(String key, Object value, double score) {
        zset(key, value, score, DEFAULT_EXPIRE);
    }

    /**
     * zset set 操作，設置 過期時間
     */
    public void zset(String key, Object value, double score, long expire) {
        zSetOperations.add(key, value, score);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * zset set 操作，設置多個 value
     */
    public void zset(String key, Set<ZSetOperations.TypedTuple<Object>> value) {
        zset(key, value, DEFAULT_EXPIRE);
    }

    /**
     * zset set 操作，設置 過期時間
     */
    public void zset(String key, Set<ZSetOperations.TypedTuple<Object>> value, long expire) {
        zSetOperations.add(key, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * zset zrange 操作，返回指定下標范圍的 value(升序)
     */
    public Set<Object> zrange(String key, long start, long end) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.range(key, start, end) : null;
    }

    /**
     * zset zrange 操作，返回指定下標范圍的 value - score （升序）
     */
    public Set<ZSetOperations.TypedTuple<Object>> zrangeWithScores(String key, long start, long end) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.rangeWithScores(key, start, end) : null;
    }

    /**
     * zset zrange 操作，返回指定 score 范圍的 value（升序）
     */
    public Set<Object> zrangeByScore(String key, double min, double max) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.rangeByScore(key, min, max) : null;
    }

    /**
     * zset zrevrange 操作，返回指定下標范圍的 value(降序)
     */
    public Set<Object> zreverseRange(String key, long start, long end) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.reverseRange(key, start, end) : null;
    }

    /**
     * zset zrevrange 操作，返回指定 score 范圍的 value（降序）
     */
    public Set<Object> zreverseRangeByScore(String key, double min, double max) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.reverseRangeByScore(key, min, max) : null;
    }

    /**
     * zset zrevrange 操作，返回指定下標范圍的 value - score （升序）
     */
    public Set<ZSetOperations.TypedTuple<Object>> zreverseRangeWithScores (String key, long start, long end) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.reverseRangeWithScores(key, start, end) : null;
    }

    /**
     * zset zcard 操作，返回 value 個數
     */
    public Long zlen(String key) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.size(key) : null;
    }

    /**
     * zset zcount 操作，返回指定 score 范圍內的 value 個數。
     */
    public Long zlenByScore(String key, long min, long max) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.count(key, min, max) : null;
    }

    /**
     * zset zscore 操作，返回指定 value 的 score 值
     */
    public Double zscore(String key, Object value) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.score(key, value) : null;
    }

    /**
     * zset zrem 操作，根據 value 移除一個 或 多個 value
     */
    public Long zremove(String key, Object... value) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.remove(key, value) : null;
    }

    /**
     * zset zremrangebyscore 操作，按照指定 score 范圍移除 value
     */
    public Long zremoveByScore(String key, long min, long max) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.removeRangeByScore(key, min, max) : null;
    }

    /**
     * zset zremrangebyrank 操作，按照排序下標范圍 移除 value。
     */
    public Long zremoveRange(String key, long start, long end) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.removeRange(key, start, end) : null;
    }

    /**
     * zset zrank 操作，返回升序序列中 value 的排名
     */
    public Long zrank(String key, Object value) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.rank(key, value) : null;
    }

    /**
     * zset zrevrank 操作，返回降序序列中 value 的排名
     */
    public Long zreverseRank(String key, Object value) {
        return StringUtils.isNotEmpty(key) ? zSetOperations.reverseRank(key, value) : null;
    }
    /* ================================ zset ================================== */
}

（3）簡單測試一下：
　　編寫一個測試類，簡單測試一下。

package com.lyh.admin_template.back;

import com.lyh.admin_template.back.common.utils.RedisUtil;
import lombok.Data;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.DefaultTypedTuple;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.util.CollectionUtils;

import java.util.*;

@SpringBootTest
public class TestRedis {

    @Autowired
    private RedisUtil redisUtil;

    /**
     * 測試 Redis common 操作
     */
    @Test
    void testCommon() {
        redisUtil.set("hello", "10", 100);
        System.out.println("所有的 key: " + redisUtil.keys("*"));
        System.out.println("key 中是否存在 hello: " + redisUtil.hasKey("hello"));
        System.out.println("獲取 hello 的過期時間: " + redisUtil.getExpire("hello"));
        redisUtil.del("hello");
        System.out.println("獲取 hello 的過期時間: " + redisUtil.getExpire("hello"));
    }

    /**
     * 測試 Redis string 操作
     */
    @Test
    void testString() {
        System.out.println("所有的 key: " + redisUtil.keys("*"));
        redisUtil.set("hello", "10", 100);
        System.out.println(redisUtil.get("hello"));
        System.out.println(redisUtil.incr("hello",100));
        System.out.println(redisUtil.get("hello"));
    }

    /**
     * 測試 Redis hash 操作
     */
    @Test
    void testHash() {
        List<Student> lists = new ArrayList<>();
        lists.add(new Student("tom"));
        lists.add(new Student("jarry"));
        Teacher teacher = new Teacher();
        teacher.setName("teacher");
        teacher.setStudents(lists);

        Map<String, Object> map = new HashMap<>();
        map.put("tom", 12);
        map.put("jarry", 24);

        redisUtil.hset("hash", "hello", teacher);
        redisUtil.hmset("hash", map, 100);

        System.out.println(redisUtil.hkeys("hash"));
        System.out.println(redisUtil.hHasKey("hash", "hello"));
        System.out.println(redisUtil.hget("hash", "hello"));
        System.out.println(redisUtil.hgetAll("hash"));
        System.out.println(redisUtil.hmget("hash"));
        System.out.println(redisUtil.getExpire("hash"));

        redisUtil.del("hash", "hello", "hello2");
        System.out.println(redisUtil.hkeys("hash"));
    }

    /**
     * 測試 Redis list 操作
     */
    @Test
    void testList() {
        redisUtil.lpush("list", 1);
        redisUtil.rpush("list", 2);
        redisUtil.lpush("list", CollectionUtils.arrayToList(new int[]{3, 4, 5}));
        redisUtil.rpush("list", CollectionUtils.arrayToList(new int[]{6, 7, 8}));

        System.out.println(redisUtil.llen("list"));
        System.out.println(redisUtil.lrange("list", 0, -1));

        redisUtil.lsetIndex("list", 2, 10);
        System.out.println(redisUtil.lgetIndex("list", 2));

        System.out.println(redisUtil.lrange("list", 0, -1));
        System.out.println(redisUtil.lremove("list", 10, 2));
        System.out.println(redisUtil.lrange("list", 0, -1));

        redisUtil.ltrim("list", 0, 3);
        System.out.println(redisUtil.lrange("list", 0, -1));

        System.out.println(redisUtil.lpop("list"));
        System.out.println(redisUtil.rpop("list"));
        System.out.println(redisUtil.lrange("list", 0, -1));

        redisUtil.del("list");
    }

    /**
     * 測試 Redis set 操作
     */
    @Test
    void testSet() {
        redisUtil.sset("set", "1");
        redisUtil.sset("set", "1", "2", "3");
        System.out.println(redisUtil.smembers("set"));
        System.out.println(redisUtil.sisMember("set", "2"));
        System.out.println(redisUtil.slen("set"));

        System.out.println(redisUtil.srandomMember("set", 10));
        System.out.println(redisUtil.smembers("set"));

        System.out.println(redisUtil.spop("set"));
        System.out.println(redisUtil.smembers("set"));

        redisUtil.del("set");
    }

    /**
     * 測試 Redis zset 操作
     */
    @Test
    void testZset() {
        redisUtil.zset("zset", "20", 1);
        redisUtil.zset("zset", "10", 1);
        redisUtil.zset("zset", "30", 2);
        System.out.println(redisUtil.zrange("zset", 0, -1));
        System.out.println(redisUtil.zrangeByScore("zset", 0, 1));

        System.out.println(redisUtil.zreverseRange("zset", 0, -1));
        System.out.println(redisUtil.zreverseRangeByScore("zset", 0, 1));

        System.out.println(redisUtil.zlen("zset"));
        System.out.println(redisUtil.zlenByScore("zset", 0, 1));

        System.out.println(redisUtil.zscore("zset", "20"));

//        System.out.println(redisUtil.zremove("zset", "20", "30", "40"));
//        System.out.println(redisUtil.zremoveRange("zset", 1, 4));
        System.out.println(redisUtil.zremoveByScore("zset", 2, 4));
        System.out.println(redisUtil.zrange("zset", 0, -1));

        redisUtil.zset("zset", new Student("tom"), 10);
        redisUtil.zset("zset", new Student("jarry"), 20);
        System.out.println(redisUtil.zrange("zset", 0, -1));
        System.out.println(redisUtil.zrank("zset", new Student("tom")));
        System.out.println(redisUtil.zreverseRange("zset", 0, -1));
        System.out.println(redisUtil.zreverseRank("zset", new Student("tom")));

        Set<ZSetOperations.TypedTuple<Object>> set = new HashSet<>();
        set.add(new DefaultTypedTuple<Object>("20", 1.0));
        set.add(new DefaultTypedTuple<Object>("10", 1.0));
        set.add(new DefaultTypedTuple<Object>("30", 2.0));
        redisUtil.zset("zset", set);
        redisUtil.zrangeWithScores("zset", 0, -1).forEach((item) -> {
            System.out.println(item.getValue() + "===" + item.getScore());
        });

        redisUtil.zreverseRangeWithScores("zset", 0, -1).forEach((item) -> {
            System.out.println(item.getValue() + "===" + item.getScore());
        });

        redisUtil.del("zset");
    }
}
@Data
class Teacher {
    private List<Student> students;
    private String name;
}

@Data
class Student {
    private String name;
    Student() {

    }
    Student(String name) {
        this.name = name;
    }
}

簡單測試一下 hash 操作。
主要看看序列化、反序列化問題。

二、SpringBoot 發送郵件

1、簡單了解一下基本概念

（1）常見協議：
　　想要在計算機之間發送郵件，需要各種協議來支撐，比如：SMTP、IMAP、POP3 等。

【來源於網絡：】
【SMTP：】
    為 Simple Mail Transfer Protocol 簡寫，即簡單郵件傳輸協議。
    是一組從源地址到目的地地址傳輸郵件的規范。
    需要使用 賬號名、密碼 才能登陸 SMTP 服務器，從而減少用戶收到垃圾郵件的機會。
    主要用於郵件客戶端 與 郵件服務器之間郵件的發送、接收。
    
【IMAP：】
    為 Internet Mail Access Protocol 簡寫，即互聯網郵件訪問協議。
    主要用於郵件客戶端 從 郵件服務器上獲取郵件信息、下載郵件。
    
【POP 3：】
    為 Post Office Protocol 3 簡寫，即郵局協議 3。
    是一個離線協議標准。即 郵件發送到服務器后，當郵件客戶端訪問郵件服務器時，會下載所有的未讀的郵件。
    主要也用於 下載郵件。
    
【IMAP 與 POP 3 的區別：】
    IMAP 在郵件客戶端的操作 會 影響到郵件服務器。
    POP 3 在郵件客戶端的操作 不會 影響到郵件服務器。

（2）開啟郵件服務（此處使用網易郵箱）。
Step1：
　　登錄網易 163 郵箱（注冊、登錄一個郵箱作為服務器）。

【網址：】
    https://email.163.com/

Step2：
　　選擇設置，並點擊 POP3/SMTP/IMAP。

Step3：
　　點擊開啟 IMAP/SMTP服務、POP3/SMTP服務。

授權碼是用於登錄第三方郵件客戶端的專用密碼。

【IMAP/SMTP服務 授權碼：】
    KFYRVDQAUXLNBSUO

（3）簡單了解一下 JavaMailSender 和 JavaMailSenderImpl
　　JavaMailSender 是 Spring 官方提供的集成郵件服務的一個接口。
　　JavaMailSenderImpl 是 JavaMailSender 的一個實現類。
　　通過 @Autowired 注入並使用 JavaMailSenderImpl 的 send 方法即可發送郵件。
查看 MailSenderPropertiesConfiguration.java 配置類截圖如下：

　　對於簡單的郵件，可以使用 SimpleMailMessage 封裝相關信息。
　　對於復雜的郵件（比如存在附件），可以使用 MimeMessage 封裝相關信息（通過 MimeMessageHelper 進一步操作相關信息）。

2、SpringBoot 發送郵件

（1）添加依賴
　　由於可能涉及到 json 與 string 之間的相互轉換，可以引入 Gson 依賴。

<!--Gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.6</version>
</dependency>

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

（2）配置郵箱信息

spring:
  # mail 配置
  mail:
    # SMTP 服務器地址
    host: smtp.163.com
    # 郵件服務器賬號
    username: m_17730125031@163.com
    # 授權碼
    password: KFYRVDQAUXLNBSUO
    # 配置端口號（默認使用 25，若項目發布到雲服務器，需要開放相應端口 465，需要配置相關 ssl 協議）
    port: 465
    # 編碼字符集采用 UTF-8
    default-encoding: UTF-8
    # 配置 ssl 協議（端口為 25 時，可以不用配置）
    properties:
      mail:
        smtp:
          ssl:
            enable: true
          socketFactory:
            port: 465
            class: javax.net.ssl.SSLSocketFactory
  # 文件上傳大小配置（由於附件的存在，可以視項目情況修改）
  servlet:
    multipart:
      # 限制單個文件大小
      max-file-size: 10MB
      # 限制單次請求總文件大小
      max-request-size: 50MB

（3）編寫一個 vo 對象（MailVo.java），用於保存郵件相關信息。

package com.lyh.admin_template.back.vo;

import lombok.Data;
import org.springframework.web.multipart.MultipartFile;

@Data
public class MailVo {

    /**
     * 郵件發送人
     */
    private String from;
    /**
     * 郵件接收人
     */
    private String[] to;
    /**
     * 郵件抄送
     */
    private String[] cc;
    /**
     * 郵件密送
     */
    private String[] bcc;
    /**
     * 郵件主題
     */
    private String subject;
    /**
     * 郵件內容
     */
    private String text;
    /**
     * 郵件附件
     */
    private MultipartFile[] files;
    /**
     * 郵件附件在服務器存儲的地址
     */
    private String[] fileUrls;
}

（4）編寫一個郵件發送工具類（MailUtil.java），每次發郵件調用即可。
　　當然，對郵件數據還是需要做必要的檢查。比如使用正則表達式檢查郵箱格式。
正則表達式在線生成器：https://www.sojson.com/regex/generate

package com.lyh.admin_template.back.common.utils;

import com.lyh.admin_template.back.vo.MailVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import javax.mail.MessagingException;
import java.util.Date;

/**
 * 郵件發送 工具類
 */
@Component
public class MailUtil {
    /**
     * 用於操作郵件
     */
    @Autowired
    private JavaMailSender javaMailSender;

    /**
     * 發送郵件
     */
    public void sendMail(MailVo mailVo) {
        // 檢查郵件地址是否正確
        if (checkMail(mailVo)) {
            // 發送郵件
            sendMailReal(mailVo);
        } else {
            throw new RuntimeException("郵件地址異常");
        }
    }

    /**
     * 郵件必須項檢查
     */
    private boolean checkMail(MailVo mailVo) {
        return checkAddress(mailVo.getFrom()) && checkAddress(mailVo.getTo())
                && checkAddress(mailVo.getCc()) && checkAddress(mailVo.getBcc());
    }

    /**
     * 檢查郵箱地址是否正確
     */
    private boolean checkAddress(String... address) {
        if (address.length == 0 || address == null) {
            return true;
        }
        String regex = "\\w[-\\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+\\.)+[A-Za-z]{2,14}";
        for (String item : address) {
            if (!item.matches(regex)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 發送郵件真實操作
     */
    private void sendMailReal(MailVo mailVo) {
        // 構造一個郵件助手
        MimeMessageHelper mimeMessageHelper = null;
        try {
            // 傳入 MimeMessage，並對其進行一系列操作,true 表示支持復雜郵件（支持附件等）
            mimeMessageHelper = new MimeMessageHelper(javaMailSender.createMimeMessage(), true);
            // 設置郵件發送人
            mimeMessageHelper.setFrom(mailVo.getFrom());
            // 設置郵件接收人
            mimeMessageHelper.setTo(mailVo.getTo());
            // 設置郵件抄送人
            mimeMessageHelper.setCc(mailVo.getCc());
            // 設置郵件密送人
            mimeMessageHelper.setBcc(mailVo.getBcc());
            // 設置郵件主題
            mimeMessageHelper.setSubject(mailVo.getSubject());
            // 設置郵件內容
            mimeMessageHelper.setText(mailVo.getText());
            // 設置郵件日期
            mimeMessageHelper.setSentDate(new Date());
            // 設置附件
            for (MultipartFile file : mailVo.getFiles()) {
                mimeMessageHelper.addAttachment(file.getOriginalFilename(), file);
            }

            // 發送郵件
            javaMailSender.send(mimeMessageHelper.getMimeMessage());
        } catch (MessagingException e) {
            throw new RuntimeException("郵件發送失敗");
        }
    }
}

（5）編寫測試類 TestMailController.java，對郵件發送功能進行測試。
碰到的問題：
　　由於存在附件，后台接口中可以使用 MultipartFile 類型去接收文件。但是若想同時接收其他參數，不能直接使用 @RequestBody 接收參數轉為相應實體類。其屬於兩種流信息，@RequestBody 屬於 application/json，MultipartFile 屬於 multipart/form-data，兩者同時使用，解析時就會出現問題（有能完美解決這個問題的，還望不吝賜教（+_+））。

我的解決方案：
　　第一種形式，參數使用 HttpServletRequest 接收，然后自己手動去解析。
　　第二種方式，使用 @RequestParam 注解去接收，若參數過多，可以使用 String 去保存前端發送的 JSON 數據，然后在后台手動將 String 數據轉為相應的實體類去處理（可使用 Gson）。
　　第三種方式，將附件單獨處理（做一個文件上傳接口，返回附件在服務器的地址），發送郵件時，根據服務器地址獲取附件信息，然后發送。這樣做就可以使用 @RequestBody 注解了，因為傳遞的是附件 URL 地址（String）而非文件。

【參數接收異常：】
public Result testFiles(@RequestBody MailVo test, MultipartFile[] multipartFiles)

【參數接收正常：（方式一）】
@PostMapping("/send")
public Result send(HttpServletRequest request) {
    MultipartHttpServletRequest params = (MultipartHttpServletRequest) request;
    List<MultipartFile> files = params.getFiles("files");
    MailVo mailVoReal = GsonUtil.fromJson(params.getParameter("mailVo"), MailVo.class);
    mailVoReal.setFiles(files.toArray(new MultipartFile[]{}));
    mailUtil.sendMail(mailVoReal);
    return Result.ok();
}
    
【參數接收正常：（方式二）】
@PostMapping("/send2")
public Result send2(@RequestParam String mailVo, MultipartFile[] files) {
    MailVo mailVoReal = GsonUtil.fromJson(mailVo, MailVo.class);
    mailVoReal.setFiles(files);
    mailUtil.sendMail(mailVoReal);
    return Result.ok();
}

涉及到 Gson 對數據進行轉換，為了方便使用，將其抽成一個工具類 GsonUtil.java。

【依賴：】
<!--Gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.6</version>
</dependency>

【工具類：】
package com.lyh.admin_template.back.common.utils;

import com.google.gson.Gson;

/**
 * Gson 工具類，用於 Object 與 Json 字符串形式互轉
 */
public class GsonUtil {
    private final static Gson GSON = new Gson();

    /**
     * Object 轉 String 數據（JSON 字符串）
     */
    public static String toJson(Object object) {
        if (object instanceof Integer || object instanceof Short || object instanceof Byte
            || object instanceof Long || object instanceof Character || object instanceof Boolean
            || object instanceof Double || object instanceof String || object instanceof Float) {
            return String.valueOf(object);
        }
        return GSON.toJson(object);
    }

    /**
     * string（Json 字符串） 轉 Object。
     */
    public static <T> T fromJson(String json, Class<T> tClass) {
        return GSON.fromJson(json, tClass);
    }
}

完整 TestMailController.java 如下：

package com.lyh.admin_template.back.controller.test;

import com.lyh.admin_template.back.common.utils.GsonUtil;
import com.lyh.admin_template.back.common.utils.MailUtil;
import com.lyh.admin_template.back.common.utils.Result;
import com.lyh.admin_template.back.vo.MailVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

/**
 * 測試郵件發送功能
 */
@RestController
@RequestMapping("/test/mail")
public class TestMailController {

    @Autowired
    private MailUtil mailUtil;

    /**
     * 獲取郵件方式一，使用 HttpServletRequest 獲取，並手動解析數據
     */
    @PostMapping("/send")
    public Result send(HttpServletRequest request) {
        MultipartHttpServletRequest params = (MultipartHttpServletRequest) request;
        List<MultipartFile> files = params.getFiles("files");
        MailVo mailVoReal = GsonUtil.fromJson(params.getParameter("mailVo"), MailVo.class);
        mailVoReal.setFiles(files.toArray(new MultipartFile[]{}));
        mailUtil.sendMail(mailVoReal);
        return Result.ok();
    }

    /**
     * 獲取郵件方式二，使用 @RequestParam 獲取 json 字符串（使用 Gson 手動轉換為 對象）
     */
    @PostMapping("/send2")
    public Result send2(@RequestParam String mailVo, MultipartFile[] files) {
        MailVo mailVoReal = GsonUtil.fromJson(mailVo, MailVo.class);
        mailVoReal.setFiles(files);
        mailUtil.sendMail(mailVoReal);
        return Result.ok();
    }
}

（6）測試
　　由於 Swagger 傳遞多個文件時，得到的值為 null（不知道怎么解決）。
　　所以此處使用 postman 進行測試。
測試需要的 json 數據如下：

【用於測試方式一：】
{
    "bcc": [],
    "cc": [],
    "from": "m_17730125031@163.com",
    "subject": "測試 1",
    "text": "測試郵件發送 11111111111111",
    "to": [
        "13865561381@163.com"
    ]
}

【用於測試方式二：】
{
    "bcc": [
        "13865561381@163.com"
    ],
    "cc": [
        "13865561381@163.com",
        m_17730125031@163.com
    ],
    "from": "m_17730125031@163.com",
    "subject": "測試 2",
    "text": "測試郵件發送 22222222222222222",
    "to": [
        "13865561381@163.com",
        m_17730125031@163.com
    ]
}

郵件發送的過程有點慢（暫時不知道怎么解決 (=_=)），但是確實是可以發送的。

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。