谁有好用的Java使用redis的封装的示例

Posted 2023-04-13

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了谁有好用的Java使用redis的封装的示例相关的知识，希望对你有一定的参考价值。

参考技术A Java连接redis的使用示例
Redis是开源的key-value存储工具，redis通常用来存储结构化的数据，因为redis的key可以包含String、hash、listset和sorted list。

Redisclient支持多种语言，包括：c、C++、C#、php、java、python、go等语言，根据自己的开发语言，选择合适的redis client版本类型即可。我是使用java语言开发的，针对java语言，redis client也提供了多种客户端支持，按照推荐类型依次是：Jedis、Redisson、JRedis、JDBC-Redis、RJC、redis-protocol、aredis、lettuce。前两种类型是比较推荐的，我们采用了Redisson类型版本作为redisclient的使用。

Redisson版的redis可发工程搭建
1. 新建maven工程
2. 在pom.xml文件的dependencies节点下增加如下内容：

<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>1.0.2</version>
</dependency>

<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.7</version>
</dependency>

3. 保存pom.xml后，等eclispe工程构建完成后即可进行开发了

开发示例
下面是演示连接redis服务器、保存读取concurrentMap对象、保存读取set对象和保存读取Queue对象的示例代码，代码比较简单，这里就不再详细讲解了，代码如下：
[java] view plaincopy
package com.my.test.redis;

import java.util.Queue;
import java.util.Set;
import java.util.concurrent.ConcurrentMap;

import org.redisson.Config;
import org.redisson.Redisson;

public class RedisExample

/**
* @param args
*/
public static void main(String[] args)
// 1.初始化
Config config = new Config();
config.setConnectionPoolSize(10);
config.addAddress("127.0.0.1:6379");
Redisson redisson = Redisson.create(config);
System.out.println("reids连接成功...");

// 2.测试concurrentMap,put方法的时候就会同步到redis中
ConcurrentMap<String, Object> map = redisson.getMap("FirstMap");
map.put("wuguowei", "男");
map.put("zhangsan", "nan");
map.put("lisi", "女");

ConcurrentMap resultMap = redisson.getMap("FirstMap");
System.out.println("resultMap==" + resultMap.keySet());

// 2.测试Set集合
Set mySet = redisson.getSet("MySet");
mySet.add("wuguowei");
mySet.add("lisi");

Set resultSet = redisson.getSet("MySet");
System.out.println("resultSet===" + resultSet.size());

//3.测试Queue队列
Queue myQueue = redisson.getQueue("FirstQueue");
myQueue.add("wuguowei");
myQueue.add("lili");
myQueue.add("zhangsan");
myQueue.peek();
myQueue.poll();

Queue resultQueue=redisson.getQueue("FirstQueue");
System.out.println("resultQueue==="+resultQueue);

// 关闭连接
redisson.shutdown();

redis（Springboot中封装整合redis,java程序如何操作redis的5种基本数据类型）

平常测试redis操作命令，可能用的是cmd窗口操作redis，记录一下 java程序操作reids，

操作redis的方法可以用Jedis ，在springboot 提供了两种方法操作 RedisTemplate 和StringRedisTemplate 两种方法的区别可参考：https://blog.csdn.net/yifanSJ/article/details/79513179

当然 springboot 中也可以使用Jedis ，本次记录的是如何使用RedisTemplate 操作reids的5种基本数据类型

在项目的pom文件中导入操作redis所需要的依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.2.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>springboot-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-redis</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.directory.studio/org.apache.commons.lang -->
        <dependency>
            <groupId>org.apache.directory.studio</groupId>
            <artifactId>org.apache.commons.lang</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
    <!-- <version>2.9.0</version> -->
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

新建RedisTemplateUtil 注入 RedisTemplate

package com.example.demo.redisutil;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import javax.annotation.Resource;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

@Component
public class RedisTemplateUtil {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

使用RedisTemplate 操作 String类型的数据：
1,将String类型存入到Redis当中：

/**
     * redisTemplate操作普通字符串(存值)
     * 
     * @param key
     * @param value
     */
    public void redisSetString(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

2,从redis当中取出String类型的数据：

/**
     * redisTemplate操作普通字符串 （取值）
     * 
     * @param key
     */
    public Object redisGetString(String key) {
        return redisTemplate.opsForValue().get(key);

    }

3.设置reids key的过期时间(原来出现过设置过期时间不起作用，是因为先设置了过期时间在去存入值到redis )：

    /**
     * 
     * 指定缓存失效时间
     * 
     * @param key
     *            键
     * 
     * @param time
     *            时间(秒)
     * 
     * @return
     * 
     */

    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }

使用RedisTemplate 操作List类型的数据：
1,将list类型存入到Redis当中：

    /**
     * 将一个list集合存放到redis当中
     * 
     * @param key
     */
    public void redisSetList(String key) {
        List<Integer> list = Arrays.asList(9, 2, 3, 4);
        for (Integer integer : list) {
            // 从当前的数据 向右添加 
            // redisTemplate.opsForList().rightPush(key, integer);
            // 从当前的数据 向左添加 
            redisTemplate.opsForList().leftPush(key, integer);
        }
    }

2,从redis中取出list数据：

/**
     * 获取list(获取0 -10 索引的数据)
     * 
     * @param key
     * @return
     */
    public Object getList(String key) {
        return redisTemplate.opsForList().range(key, 0, 10);
    }

3.获取redis中list的长度：

/**
     * 获取list指定key的长度
     * 
     * @param key
     * @return
     */
    public Long getListSize(String key) {
        return redisTemplate.opsForList().size(key);
    }

使用RedisTemplate 操作hash类型的数据：
1.将hash存放到redis当中：

/**
     * 将map存放到reids
     *
     * @param key
     */
    public void setHash(String key) {
        Map<String, String> hashMap = new HashMap<>();
        //使用RedisTemplate  有些情况会乱码
        hashMap.put("redis", "redis");
        hashMap.put("mysql", "mysql");
        for (Entry<String, String> keyValue : hashMap.entrySet()) {
            redisTemplate.opsForHash().put(key, keyValue.getKey(), keyValue.getValue());
        }
    }

2.将hash从redis当中取出来根据具体的key取出具体的值：

/**
     * 获取指定key1的值
     * 
     * @param key
     * @param key1
     * @return
     */
    public Object getHash(String key, String key1) {
        // 检测 是否 存在该键
        boolean isKey = redisTemplate.opsForHash().hasKey(key, key1);
        return redisTemplate.opsForHash().get(key, key1);
    }

3.将key中所有的值都取出来：

/**
     * 获取指定key的所有值
     * 
     * @param key
     * 
     * @return
     */
    public Object getHash(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

4.根据具体的key移除具体的值：

/**
     * 根据具体key移除具体的值
     * 
     * @param key
     * 
     * @return
     */
    public void removeKey(String key, String key1) {
        redisTemplate.opsForHash().delete(key, key1);
    }

5.移除key值则key里面的所有值都被移除：

public void removeStringKey(String key) {
        redisTemplate.delete(key);
    }

使用RedisTemplate 操作set类型的数据：
1.set数据存入redis中

    /**
     * set存入redis中
     * 
     * @param key
     */
    public void setSet(String key) {
        Set<Object> set = new HashSet<>();
        set.add("setKey");
        set.add("tesetKey");
        for (Object object : set) {
            redisTemplate.opsForSet().add(key, object);
        }
    }

2.从redis当中将set数据取出来：

/**
     * 从redis中取出set
     * 
     * @param key
     * @return
     */
    public Object getSet(String key) {
        return redisTemplate.opsForSet().members(key);
    }

使用RedisTemplate 操作sortset类型的数据：
1.将sortSet存放到redis当中：

/**
     * sortset存入redis中
     * 
     * @param key
     */
    public void setZSet(String key) {
        Set<Object> set = new HashSet<>();
        set.add("setKey");
        set.add("tesetKey");
        int i = 0;
        for (Object object : set) {
            i++;
            redisTemplate.opsForZSet().add(key, object, i);
        }
    }

2.将sortset从redis当中取出来的API有很多：

/**
     * 从redis中取出sortset
     * 
     * @param key
     * @return
     */
    public Object getZSet(String key) {
        Long size = redisTemplate.opsForZSet().size(key);
        return redisTemplate.opsForZSet().rangeByScore(key, 0, size);
    }

RedisTemplate操作5种基本类型数据，有一些共同的API 比如设置过期时间，和移除key的值,判断key是否存在
1设置过期时间

/**
     * 
     * 指定缓存失效时间
     * 
     * @param key
     *            键
     * 
     * @param time
     *            时间(秒)
     * 
     * @return
     * 
     */

    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }

2.检测是否存在key

：

/**
     * 
     * 判断key是否存在
     * 
     * @param key
     *            键
     * 
     * @return true 存在 false不存在
     * 
     */

    public boolean checkKey(String key) {

        try {

            return redisTemplate.hasKey(key);

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }

3:移除缓存

  /**
     * 移除key
     * @param key
     */
    public void removeKey(String key) {
        redisTemplate.delete(key);
    }

掌握redis，首先得掌握reids如何操作5种基本数据类型，5种基本数据类型中 set和sortset的区别需要特别注意，然后就是关于使用RedisTemplate 可能乱码的问题，以及StringRedisTemplate 的区别，

以上是关于谁有好用的Java使用redis的封装的示例的主要内容，如果未能解决你的问题，请参考以下文章

Snagit 这款mac截图软件好用吗。谁有snagit2019汉化版分享。

比Redis好用的NoSQL

谁有比较好的压缩软件

漂亮又好用的Redis可视化客户端汇总

超好用的Redis管理及监控工具，使用后可大大提高你的工作效率！