累成一条狗

SpringBoot + Vue + ElementUI 实现后台管理系统模板 -- 后端篇(二): 整合 Redis(常用工具类、缓存)、整合邮件发送功能

(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
    ]
}

邮件发送的过程有点慢(暂时不知道怎么解决 (=_=)),但是确实是可以发送的。

 

posted on 2020-06-19 16:15  累成一条狗  阅读(174)  评论(0编辑  收藏

导航

统计