"1，jedis redis 官方推荐使用 jedis 操作 redis 导入依赖 redis.clients jedis 3.3.0 直接使用即可 import redis.clients.jedis.Jedis; public class RedisTest { public static v ...."

someone1
AI专业者开发社区 1 号成员
AI开发者社区 • 0 回帖 • 5 浏览 • 4 个月前

Java连接操作redis

1，jedis

redis 官方推荐使用 jedis 操作 redis

导入依赖

<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>

直接使用即可

import redis.clients.jedis.Jedis;
public class RedisTest {
public static void main(String[] args) {
Jedis jedis = new Jedis("127.0.0.1", 6379);
System.out.println(jedis.ping());
jedis.set("name", "zl");
System.out.println(jedis.get("name"));
jedis.lpush("list", "a");
jedis.lpush("list", "b");
jedis.lpush("list", "c");
jedis.lpush("list", "d");
System.out.println(jedis.lrange("list", 0, -1));
System.out.println(jedis.keys("*"));
}
}

注意：当多线程使用同一个连接时，是线程不安全的。所以要使用连接池，为每个 jedis 实例分配一个连接。

2，Lettuce

springBoot2.x 之后默认集成了 Lettuce

相较于 jedis，当多线程使用同一连接实例时，它是线程安全的。

依赖引入（创建 springboot 项目时勾选 noSQL 中的 redis）

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

一般情况下不直接使用Lettuce，会手动封装一个操作 redis 的工具类，这个网上有很多，一下提供做参考

package com.zl.utils;
import org.apache.tomcat.util.buf.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**


Redis 工具类，使用之前请确保 RedisTemplate 成功注入



@author ye17186


@version 2019/2/22 10:48
*/
@Component
public class RedisUtils {
private RedisUtils() {
}
@Autowired
private RedisTemplate redisTemplate;
/**


设置有效时间



@param key Redis 键


@param timeout 超时时间


@return true= 设置成功；false= 设置失败
*/
public boolean expire(final String key, final long timeout) {
return expire(key, timeout, TimeUnit.SECONDS);
}


/**


设置有效时间



@param key Redis 键


@param timeout 超时时间


@param unit 时间单位


@return true= 设置成功；false= 设置失败
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit) {
Boolean ret = redisTemplate.expire(key, timeout, unit);
return ret != null && ret;
}


/**


删除单个 key



@param key 键


@return true= 删除成功；false= 删除失败
*/
public boolean del(final String key) {
Boolean ret = redisTemplate.delete(key);
return ret != null && ret;
}


/**


删除多个 key



@param keys 键集合


@return 成功删除的个数
*/
public long del(final Collection<String> keys) {
Long ret = redisTemplate.delete(keys);
return ret == null ? 0 : ret;
}


/**


存入普通对象



@param key Redis 键


@param value 值
*/
public void set(final String key, final Object value) {
redisTemplate.opsForValue().set(key, value, 1, TimeUnit.MINUTES);
}


// 存储普通对象操作
/**


存入普通对象



@param key 键


@param value 值


@param timeout 有效期，单位秒
*/
public void set(final String key, final Object value, final long timeout) {
redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
}


/**


获取普通对象



@param key 键


@return 对象
*/
public Object get(final String key) {
return redisTemplate.opsForValue().get(key);
}


// 存储 Hash 操作
/**


往 Hash 中存入数据



@param key Redis 键


@param hKey Hash 键


@param value 值
*/
public void hPut(final String key, final String hKey, final Object value) {
redisTemplate.opsForHash().put(key, hKey, value);
}


/**


往 Hash 中存入多个数据



@param key Redis 键


@param values Hash 键值对
*/
public void hPutAll(final String key, final Map<String, Object> values) {
redisTemplate.opsForHash().putAll(key, values);
}


/**


获取 Hash 中的数据



@param key Redis 键


@param hKey Hash 键


@return Hash 中的对象
*/
public Object hGet(final String key, final String hKey) {
return redisTemplate.opsForHash().get(key, hKey);
}


/**


获取多个 Hash 中的数据



@param key Redis 键


@param hKeys Hash 键集合


@return Hash 对象集合
*/
public List<Object> hMultiGet(final String key, final Collection<Object> hKeys) {
return redisTemplate.opsForHash().multiGet(key, hKeys);
}


// 存储 Set 相关操作
/**

往 Set 中存入数据

@param key Redis 键
@param values 值
@return 存入的个数
*/
public long sSet(final String key, final Object... values) {
Long count = redisTemplate.opsForSet().add(key, values);
return count == null ? 0 : count;
}

/**

删除 Set 中的数据

@param key Redis 键
@param values 值
@return 移除的个数
*/
public long sDel(final String key, final Object... values) {
Long count = redisTemplate.opsForSet().remove(key, values);
return count == null ? 0 : count;
}

// 存储 List 相关操作
/**

往 List 中存入数据

@param key Redis 键
@param value 数据
@return 存入的个数
*/
public long lPush(final String key, final Object value) {
Long count = redisTemplate.opsForList().rightPush(key, value);
return count == null ? 0 : count;
}

/**

往 List 中存入多个数据

@param key Redis 键
@param values 多个数据
@return 存入的个数
*/
public long lPushAll(final String key, final Collection<Object> values) {
Long count = redisTemplate.opsForList().rightPushAll(key, values);
return count == null ? 0 : count;
}

/**

往 List 中存入多个数据

@param key Redis 键
@param values 多个数据
@return 存入的个数
*/
public long lPushAll(final String key, final Object... values) {
Long count = redisTemplate.opsForList().rightPushAll(key, values);
return count == null ? 0 : count;
}

/**

从 List 中获取 begin 到 end 之间的元素

@param key Redis 键
@param start 开始位置
@param end 结束位置（start=0，end=-1 表示获取全部元素）
@return List 对象
*/
public List<Object> lGet(final String key, final int start, final int end) {
return redisTemplate.opsForList().range(key, start, end);
}
}

RedisUtils.java

另外根据需要重新配置 redisConfig

package com.zl.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.net.UnknownHostException;
@Configuration
public class RedisConfig {
@Bean
@SuppressWarnings(</span>"all"<span style="color: rgba(0, 0, 0, 1)">)
</span><span style="color: rgba(0, 0, 255, 1)">public</span> RedisTemplate&lt;String, Object&gt;<span style="color: rgba(0, 0, 0, 1)"> redisTemplate(RedisConnectionFactory redisConnectionFactory)
        </span><span style="color: rgba(0, 0, 255, 1)">throws</span><span style="color: rgba(0, 0, 0, 1)"> UnknownHostException {
    RedisTemplate</span>&lt;String, Object&gt; template = <span style="color: rgba(0, 0, 255, 1)">new</span> RedisTemplate&lt;&gt;<span style="color: rgba(0, 0, 0, 1)">();
    template.setConnectionFactory(redisConnectionFactory);

    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer </span>= <span style="color: rgba(0, 0, 255, 1)">new</span> Jackson2JsonRedisSerializer(Object.<span style="color: rgba(0, 0, 255, 1)">class</span><span style="color: rgba(0, 0, 0, 1)">);
    ObjectMapper objectMapper </span>= <span style="color: rgba(0, 0, 255, 1)">new</span><span style="color: rgba(0, 0, 0, 1)"> ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">String序列化</span>
    StringRedisSerializer stringRedisSerializer = <span style="color: rgba(0, 0, 255, 1)">new</span><span style="color: rgba(0, 0, 0, 1)"> StringRedisSerializer();
    template.setKeySerializer(stringRedisSerializer);
    template.setHashKeySerializer(stringRedisSerializer);
    template.setValueSerializer(jackson2JsonRedisSerializer);
    template.setHashValueSerializer(jackson2JsonRedisSerializer);
    template.afterPropertiesSet();


    </span><span style="color: rgba(0, 0, 255, 1)">return</span><span style="color: rgba(0, 0, 0, 1)"> template;
}

}

RedisConfig.java

最后测试操作

package com.zl;
import com.zl.utils.RedisUtils;
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.RedisTemplate;
@SpringBootTest
class RedisSpringbootApplicationTests {
@Autowired
</span><span style="color: rgba(0, 0, 255, 1)">private</span><span style="color: rgba(0, 0, 0, 1)"> RedisTemplate redisTemplate;

@Autowired
</span><span style="color: rgba(0, 0, 255, 1)">private</span><span style="color: rgba(0, 0, 0, 1)"> RedisUtils redisUtils;

</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">原生Lettuce操作</span>

    @Test
void contextLoads() {
redisTemplate.opsForValue().set("name", "zlzl4");
System.out.println(redisTemplate.opsForValue().get("name"));
}
</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">redisUtils操作</span>

    @Test
public void test1() {
redisUtils.set("hello", "world");
System.out.println(redisUtils.get("hello"));
}
}

Java连接操作redis

1，jedis

相关帖子

随便看看

Java连接操作redis