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("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        //String序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();


        return 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
    private RedisTemplate redisTemplate;

    @Autowired
    private RedisUtils redisUtils;

    //原生Lettuce操作
    @Test
    void contextLoads() {
        redisTemplate.opsForValue().set("name", "zlzl4");
        System.out.println(redisTemplate.opsForValue().get("name"));
    }

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

}

Java連線操作redis

1，jedis

Java連線操作redis

java 連線操作Elasticsearch（一）

java連線操作elasticsearch（二）

java 連線操作Elasticsearch（三）

基於Java程式碼操作Redis過程詳解

Python進階學習_連線操作Redis資料庫

使用 Jedis 連線操作 Redis

使用java連線Redis,Maven管理操作

Java 連線 redis

Java連線Oracle的JDBC插入資料操作

java操作Redis快取設定過期時間的方法

6.java連線Redis

Java連線Redis

Java連線Redis,儲存物件獲取物件()byte和json),連線池

java連線redis資料庫獲取資料

java連線ElasticSearch叢集操作

Java使用Lettuce操作redis

Redis連線操作工具類

Redis入門之Java程式碼操作例項

Java NIO（三）非阻塞的連線操作

Java連線操作redis

1，jedis

相關推薦