自定义redis工具jar包供其他项目模块直接引用

注：(最终redis数据库连接信息由使用者项目模块配置提供)

一、Redis常用数据存储查询操作实现（redis-util模块，该module最后会打包成jar供其他服务引用）

1.引用相关依赖

<!-- 如果有继承父级spring-boot-starter-parent，可不用添加版本号 -->
<!-- Redis缓存 [start] -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
			<version>2.3.0.RELEASE</version>
		</dependency>
<!-- Redis缓存 [end]  -->

2.配置reids连接信息

注：由于此时还处于redis-util工具包开发阶段，所以reids的配置文件还是由自己的模块来提供，后期打包成jar时，会清除redis-util工具包里的redis连接信息，然后由需要使用redis-util工具的服务模块提供reids的连接信息；
在reids-util的application.properties里配置redis数据库连接信息

#Redis服务器地址
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database=0  

3.自定义序列化类，将存储在Redis的对象序列化为json格式

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.io.Serializable;
@Configuration
@EnableAutoConfiguration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Serializable> redisTemplate(LettuceConnectionFactory redisConnectionFactory){
        RedisTemplate<String, Serializable> template = new RedisTemplate();
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

4.开发相应的redis常用方法

package com.gh.redis.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;
import org.springframework.util.CollectionUtils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Repository
public class RedisUtil {

    @Autowired
    RedisTemplate<String, Serializable> redisTemplate;   // key-value是对象的

    public RedisUtil(){

    }

    /**
     * 判断是否存在key
     * @param key 主键
     * @return true或false
     */
    public boolean hasKey(String key) {
        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }

    /**
     * 新增、修改Redis键值
     * @param key 主键
     * @param value 值
     */
    public void insertOrUpdate(String key, Serializable value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 新增、修改Redis键值,并设置有效时间（秒）
     * @param key 主键
     * @param value 值
     * @param seconds 有效时间（秒）
     */
    public void insertOrUpdateBySeconds(String key, Serializable value, long seconds) {
        redisTemplate.opsForValue().set(key, value, seconds, TimeUnit.SECONDS);
    }

    /**
     * 新增、修改Redis键值,并设置有效时间（分）
     * @param key 主键
     * @param value 值
     * @param minutes 有效时间（分）
     */
    public void insertOrUpdateByMinutes(String key, Serializable value, long minutes) {
        redisTemplate.opsForValue().set(key, value, minutes, TimeUnit.MINUTES);
    }

    /**
     * 新增、修改Redis键值,并设置有效时间（小时）
     * @param key 主键
     * @param value 值
     * @param hours 有效时间（小时）
     */
    public void insertOrUpdateByHours(String key, Serializable value, long hours) {
        this.redisTemplate.opsForValue().set(key, value, hours, TimeUnit.HOURS);
    }

    /**
     * 新增、修改Redis键值,并设置有效时间（天）
     * @param key 主键
     * @param value 值
     * @param days 有效时间（天）
     */
    public void insertOrUpdateByDays(String key, Serializable value, long days) {
        this.redisTemplate.opsForValue().set(key, value, days, TimeUnit.DAYS);
    }

    /**
     * 通过主键获取值
     * @param key 主键
     * @return
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 获取redis的所有key里包含pattern字符的key集
     * @param pattern 模糊查询字符
     * @return
     */
    public Set<String> getPattern(String pattern) {
        return redisTemplate.keys("*" + pattern + "*");
    }

    /**
     * 删除指定redis缓存
     * @param key 主键
     * @return
     */
    public boolean remove(String key) {
        return Boolean.TRUE.equals(redisTemplate.delete(key));
    }

    /**
     * 删除指定的多个缓存
     * @param keys 主键1，主键2，...
     * @return 删除主键数
     */
    public int removes(String... keys){
        int count = 0;
        List<String> deleteFails = new ArrayList<>();

        for (String key : keys) {
            if (Boolean.TRUE.equals(redisTemplate.delete(key))) {
                ++count;
            } else {
                deleteFails.add(key);
            }
        }

        if (!CollectionUtils.isEmpty(deleteFails)) {
            System.err.println("======> Redis缓存删除失败的key：" + deleteFails.toString());
        }
        return count;
    }

    /**
     * 删除所有的键值对数据
     * @return 清除键值对数据量
     */
    public int removeAll(){
        Set<String> keys = redisTemplate.keys("*");
        Long delete = 0L;

        if (keys != null) {
            delete = redisTemplate.delete(keys);
        }

        return delete != null ? delete.intValue() : 0;
    }

}

5.工具包开发完成，测试一下

import com.gh.common.toolsclass.ResultData;
import com.gh.redis.util.RedisUtil;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Set;

@SpringBootTest
class RedisApplicationTests {

    @Autowired
    private RedisUtil redisUtil;

    @Test
    void test1() {
        ResultData resultData = new ResultData();
        resultData.setCode(0);
        resultData.setMessage("redis测试");
        resultData.setData("666666");
        redisUtil.insertOrUpdate("demo", resultData);
        System.err.println(redisUtil.hasKey("demo"));
        Object demo = redisUtil.get("demo");
        ResultData bo = (ResultData) demo;
        System.err.println(bo.toString());
    }

    @Test
    void test2() {
        Set<String> list = redisUtil.getPattern("l");
        for (String s: list) {
            System.err.println(s);
        }
    }
}

其中ResultData是自定义的一个用于返回信息的对象，可用其他对象替代，但是该对象需要实现Serializable接口（ResultData implements Serializable）

运行test1：

运行test2：

其他方法自行测试，这里不一 一展示；

6.清除redis数据库连接信息

自此redis-util工具包开发完成，可供其他服务使用，最后清除redis-util模块application.properties里的redis数据库连接信息。之后的连接信息由使用者模块提供，这样才符合redis-util作为一个纯工具包的定义。

二、创建一个consumer项目来引用redis-util工具包

1.在consumer项目的pom.xml中添加reids-utils的依赖

<!-- redis工具包 [start] -->
<dependency>
            <groupId>com.gh</groupId>
            <artifactId>redis-util</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
<!-- redis工具包 [end] -->

pom如何引用自定义jar包依赖自行百度，如果在同一父工程模块下，可直接这么引用。不在同一父工程，需要先将jar包放到maven仓库。

2.在consumer的application.properties配置文件里添加redis数据的连接信息

#Redis服务器地址
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database=0

3.测试在cunsumer里是否可以使用redis-util工具包的方法

package com.gh.consumer;

import com.gh.common.toolsclass.ResultData;
import com.gh.redis.util.RedisUtil;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ConsumerApplicationTests {

// 这里使用该构造器注入的方式，因为使用变量注入
    final RedisUtil redisUtil;

    @Autowired
    public ConsumerApplicationTests(RedisUtil redisUtil){
        this.redisUtil = redisUtil;
    }

    @Test
    void test1() {
        // 如果存在demo缓存，就删除
        if (redisUtil.hasKey("demo")) {
            System.err.println(redisUtil.remove("demo"));
        }
        // 插入新的demo缓存
        ResultData resultData = new ResultData();
        resultData.setCode(0);
        resultData.setMessage("redis测试-2");
        resultData.setData("888888");
        redisUtil.insertOrUpdate("demo", resultData);
        Object demo = redisUtil.get("demo");
        ResultData bo = (ResultData) demo;
        System.err.println(bo.toString());
    }

    @Test
    void test2() {
        redisUtil.insertOrUpdate("test", "redis工具测试");
        System.err.println(redisUtil.get("test"));
    }

}

运行test1，此时会发现控制台提示找不到RedisUtil的bean

4.在启动类添加扫描

其他注解不用管，解决redis-util工具包bean扫描不到的问题，只需要添加注解@ComponentScan(value = “com.gh.redis.*”)就好

package com.gh.consumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScans;
import org.springframework.scheduling.annotation.EnableScheduling;


//@EnableDiscoveryClient eureka开启发现服务功能
@EnableFeignClients(basePackages = "com.gh.consumer.feign")
//@ComponentScan(basePackages = "com.gh.consumer.*")
@ComponentScans(value = {
		@ComponentScan(value = "com.gh.consumer.*")
		,@ComponentScan(value = "com.gh.redis.*")
})
@EnableScheduling	// 开启定时任务功能
@SpringBootApplication
public class ConsumerApplication {

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

5.再次测试

成功调用redis-utils工具包方法！