Java项目使用Redis缓存数据

Java项目使用Redis缓存数据

一、Redis的下载安装

1、下载gcc编译器

yum install gcc-c++

安装完成后检查是否安装成功，查看版本

gcc --version

2、使用weget下载redis

wget http://download.redis.io/releases/redis-6.2.4.tar.gz

下载成功后使用 ll 或 ls 命令查看当前目录下有redis压缩包

使用命令解压缩

tar -zxvf redis-6.2.4.tar.gz

解压成功后当前目录下有redis解压后的文件

3、进入解压后的redis文件，使用make进行编译

编译后默认安装目录就是redis文件夹所在目录
4、在解压后目录下执行make install 命令安装redis

5、进入安装目录启动redis服务

redis-server redis.conf

6、在xshell复制一个会话，cd进入redis安装目录，进行客户端连接

redis-cli -h 127.0.0.1 -p 6379

避雷：我本来想在Redisdesktopmanager里面连接我虚拟机里装的redis，然后一直报错

在网上搜解决方案采用修改redis.conf后成功
具体步骤如下
（1）如果已经启动redis，ctrl+c退出关闭redis，vim redis.conf修改配置文件，把原来的bind的IP改成虚拟机IP，protectedmode改成no，保存并退出

（2）重新启动redis

redis-server redis.conf

再次打开Redisdesktopmanager测试连接成功

这种情况下，虚拟机内客户端连接目录中IP记得改成redis.conf里改成的bindIP

redis-cli -h 127.0.0.1 -p 6379

另外，目前redis启动必须在一个会话终端里，启动redis之后就不能切换目录，退出等操作了，如果切换目录或退出就会关闭redis服务，如果要允许在启动redis的会话终端还能做别的操作还需要在redis.conf配置文件中更改配置daemonize yes；即作为守护进程启动，这样redis就可以后台启运行了。

这时候我们再来重新启动redis就不会显示像第五点的图一样的redis服务器启动后的画面，可以做别的操作

二、Java项目中整合Redis

1、添加依赖

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

2、redis连接配置
Redis实例默认创建了16个数据库，且不支持自定义命名，以dbX的方式命名（db0~db15）；
此处我使用的redis的14数据库，没设置密码，若设置了密码则相应在password处输入密码

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    database: 14
    password:

3、代码实现
（1）基础缓存DAO

@Repository
public class BaseCacheOperate {

    private final GsonBuilder gsonBuilder = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss");


    /**
     * @description boundList-Add
     */
    public void add(BoundListOperations<String, String> boundListOperations, Object obj) {
        try {
            boundListOperations.rightPush(gsonBuilder.create().toJson(obj));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * @description boundList-Delete
     */
    public void remove(BoundListOperations<String, String> boundListOperations, String cacheStr) {
        try {
            boundListOperations.remove(1, cacheStr);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @description boundList-Query
     */
    public List<String> list(BoundListOperations<String, String> boundListOperations, long count) {
        List<String> result = null;
        try {
            result = boundListOperations.range(0, count - 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }


    /**
     * @description boundHash-Add
     */
    public void put(BoundHashOperations<String, String, String> boundHashOperations,
                    String key, Object value) {
        try {
            boundHashOperations.put(key, gsonBuilder.create().toJson(value));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @description boundHash-Remove
     */
    public void remove(BoundHashOperations<String, String, String> boundHashOperations,
                       String key) {
        try {
            boundHashOperations.delete(key);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * @description boundHash-Entries（Value单实体）
     */
    public <T> Map<String, T> entries(BoundHashOperations<String, String, String> cacheOperations, Class<T> valueClass) {
        Map<String, T> result = new HashMap<>();
        Map<String, String> entries = cacheOperations.entries();
        if (DataStructureUtils.isValid(entries)) {
            entries.forEach((key, value) -> result.put(key, gsonBuilder.create().fromJson(value, valueClass)));
        }
        return result;
    }


    /**
     * @description boundHash-Get（Value单实体）
     */
    public <T> T get(BoundHashOperations<String, String, String> cacheOperations,
                     String key, Class<T> valueClass) {
        String cacheStr = get(cacheOperations, key);
        return StringUtils.isNotBlank(cacheStr) ? gsonBuilder.create().fromJson(cacheStr, valueClass) : null;
    }


    /**
     * @description boundHash-Get（Value为List）
     */
    public <T> List<T> getList(BoundHashOperations<String, String, String> cacheOperations,
                               String key, Class<T> valueClass) {
        String cacheStr = get(cacheOperations, key);
        return StringUtils.isNotBlank(cacheStr) ? gsonBuilder.create().fromJson(cacheStr, new TypeToken<List<T>>() {
        }.getType()) : null;
    }

    /**
     * @description boundHash-Get
     */
    public String get(BoundHashOperations<String, String, String> cacheOperations,
                      String key) {
        String result = null;
        try {
            result = cacheOperations.get(key);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }


    /**
     * @param cacheOperations Hash缓存操作实例
     * @param keyList         Key值集
     * @param valueClass      Value的类
     * @return 缓存数据集
     * @description 根据Key值集获取多条Value
     */
    public <T> List<T> multiGet(BoundHashOperations<String, String, String> cacheOperations,
                                List<String> keyList, Class<T> valueClass) {
        List<String> cacheStrList = multiGet(cacheOperations, keyList);
        List<T> result = new ArrayList<>();
        if (DataStructureUtils.isValid(cacheStrList)) {
            for (String cacheStr : cacheStrList) {
                result.add(gsonBuilder.create().fromJson(cacheStr, valueClass));
            }
        }
        return result;
    }

    /**
     * @param cacheOperations Hash缓存操作实例
     * @param keyList         Key值集
     * @param typeToken       Gson转换类型
     * @return 缓存数据集
     * @description 根据Key值集获取多条Value
     */
    public <T> List<T> multiGet(BoundHashOperations<String, String, String> cacheOperations,
                                List<String> keyList, TypeToken<List<T>> typeToken) {
        List<String> cacheStrList = multiGet(cacheOperations, keyList);
        List<T> result = new ArrayList<>();
        if (DataStructureUtils.isValid(cacheStrList)) {
            for (String cacheStr : cacheStrList) {
                result.addAll(gsonBuilder.create().fromJson(cacheStr, typeToken.getType()));
            }
        }
        return result;
    }


    /**
     * @param cacheOperations Hash缓存操作实例
     * @param keyList         Key值集
     * @return 缓存数据集
     * @description 根据Key值集获取多条Value
     */
    public List<String> multiGet(BoundHashOperations<String, String, String> cacheOperations, List<String> keyList) {
        List<String> result = null;
        if (DataStructureUtils.isValid(keyList)) {
            try {
                result = cacheOperations.multiGet(keyList);
                if (result != null) {
                    result.removeIf(Objects::isNull);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }

}

（2）实际缓存业务

@Repository
public class TestDataDAO {

    private final BaseCacheOperate baseCacheOperate;
    private final BoundHashOperations<String, String, String> operations;

    @Autowired
    public TestDataDAO(PublicCacheOperate baseCacheOperate, StringRedisTemplate redisTemplate) {
        this.baseCacheOperate = baseCacheOperate;
        this.operations = redisTemplate.boundHashOps("TEST_DATA");
    }

    /**
     * @description 缓存测试数据
     */
    public void cache(TestData testData) {
                baseCacheOperate.put(operations, testData.getId().toString(), airSiteLatestData);
    }

    /**
     * @description 根据ID获取测试数据
     */
    public TestData get(Long id) {
        return baseCacheOperate.get(operations, id.toString(), TestData.class);
    }

    /**
     * @description 根据ID集获取测试数据集
     */
    public List<TestData> list(List<Long> idList) {
        return baseCacheOperate.multiGet(operations, idList.stream()
                .map(Objects::toString).collect(Collectors.toList()), TestData.class);
    }
}