Java项目使用Redis缓存数据

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 命令安装redis

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

redis-server redis.conf

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

redis-cli -h 127.0.0.1 -p 6379

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

在网上搜解决方案采用修改redis.conf后成功

具体步骤如下

（1）如果已经启动redis，ctrl+c退出关闭redis，vim redis.conf修改配置文件，把原来的bind的IP改成虚拟机IPJava项目使用Redis缓存数据，改成no，保存并退出

（2）重新启动redis

redis-server redis.conf

再次打开测试连接成功

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

redis-cli -h 127.0.0.1 -p 6379

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

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

二、Java项目中整合Redis

1、添加依赖

            org.springframework.boot
            spring-boot-starter-data-redis
        

2、redis连接配置

Redis实例默认创建了16个数据库，且不支持自定义命名，以dbX的方式命名（db0~db15）；

此处我使用的redis的14数据库，没设置密码，若设置了密码则相应在处输入密码

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 boundListOperations, Object obj) {
        try {
            boundListOperations.rightPush(gsonBuilder.create().toJson(obj));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * @description boundList-Delete
     */
    public void remove(BoundListOperations boundListOperations, String cacheStr) {
        try {
            boundListOperations.remove(1, cacheStr);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * @description boundList-Query
     */
    public List list(BoundListOperations boundListOperations, long count) {
        List result = null;
        try {
            result = boundListOperations.range(0, count - 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * @description boundHash-Add
     */
    public void put(BoundHashOperations 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 boundHashOperations,
                       String key) {
        try {
            boundHashOperations.delete(key);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * @description boundHash-Entries（Value单实体）
     */
    public  Map entries(BoundHashOperations cacheOperations, Class valueClass) {
        Map result = new HashMap();
        Map 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 get(BoundHashOperations cacheOperations,
                     String key, Class valueClass) {
        String cacheStr = get(cacheOperations, key);
        return StringUtils.isNotBlank(cacheStr) ? gsonBuilder.create().fromJson(cacheStr, valueClass) : null;
    }
    /**
     * @description boundHash-Get（Value为List）
     */
    public  List getList(BoundHashOperations cacheOperations,
                               String key, Class valueClass) {
        String cacheStr = get(cacheOperations, key);
        return StringUtils.isNotBlank(cacheStr) ? gsonBuilder.create().fromJson(cacheStr, new TypeToken<List>() {
        }.getType()) : null;
    }
    /**
     * @description boundHash-Get
     */
    public String get(BoundHashOperations 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  List multiGet(BoundHashOperations cacheOperations,
                                List keyList, Class valueClass) {
        List cacheStrList = multiGet(cacheOperations, keyList);
        List 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  List multiGet(BoundHashOperations cacheOperations,
                                List keyList, TypeToken<List> typeToken) {
        List cacheStrList = multiGet(cacheOperations, keyList);
        List 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 multiGet(BoundHashOperations cacheOperations, List keyList) {
        List 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 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 list(List idList) {
        return baseCacheOperate.multiGet(operations, idList.stream()
                .map(Objects::toString).collect(Collectors.toList()), TestData.class);
    }
}