Java语言操作Redis（java语言操作系统）

25-03-20 7

如果您想了解Java语言操作Redis和java语言操作系统的知识，那么本篇文章将是您的不二之选。我们将深入剖析Java语言操作Redis的各个方面，并为您解答java语言操作系统的疑在这篇文章中，我

如果您想了解Java语言操作Redis和java语言操作系统的知识，那么本篇文章将是您的不二之选。我们将深入剖析Java语言操作Redis的各个方面，并为您解答java语言操作系统的疑在这篇文章中，我们将为您介绍Java语言操作Redis的相关知识，同时也会详细的解释java语言操作系统的运用方法，并给出实际的案例分析，希望能帮助到您！

本文目录一览：

Java语言操作Redis（java语言操作系统）
Go 语言操作 Redis
Go语言操作redis数据库的方法
Go语言操作redis用法实例
go语言操作redis连接池的方法

Java语言操作Redis（java语言操作系统）

目前Jedis是官方推荐的比较好的Redis操作API包，我们这里结合Spring来看下如何使用Redis这一神器。

1、在pom文件中引入jredis包：

<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>2.8.1</version>
</dependency>

2、在Spring的resource目录中增加Redis的配置文件/src/main/resources/redis.properties

# Redis settings
redis.host=192.168.56.101
redis.port=6379
redis.pass=lxh20160330
redis.timeout=0

redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true

3、在Spring的配置文件中配置好Redis的相关Bean注入：

<?xml version="1.0"encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:jee="http://www.springframework.org/schema/jee"xmlns:tx="http://www.springframework.org/schema/tx"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="  
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">  

<context:property-placeholder location="classpath:redis.properties"/>
<context:component-scan base-package="com.redis.demo"/>

<bean/>

<bean id="jedisPoolConfig">
<property name="maxActive"value="50"/>
<property name="maxIdle"value="8"/>
<property name="maxWait"value="1000"/>
<property name="testOnBorrow"value="true"/>
<property name="testOnReturn"value="true"/>
<!--<property name="testWhileIdle"value="true"/>-->
</bean>

<bean id="shardedJedisPool"scope="singleton">
<constructor-arg index="0"ref="jedisPoolConfig"/>
<constructor-arg index="1">
<list>
<bean>
<constructor-arg name="host"value="${redis.host}"/>
<constructor-arg name="port"value="${redis.port}"/>
<constructor-arg name="timeout"value="${redis.timeout}"/>
<constructor-arg name="weight"value="1"/>
</bean>
</list>
</constructor-arg>
</bean>
</beans>

4、获取Redis客户端对象的类

package com.redis.demo.service.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.redis.demo.service.RedisService;

import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

@Repository("redisService")
public class RedisServiceImpl implements RedisService {
     private static final Logger log = LoggerFactory.getLogger(RedisServiceImpl.class);

    @Autowired
    private ShardedJedisPool shardedJedisPool;
 
     public ShardedJedis getRedisClient() {
         try {
            ShardedJedis shardJedis = shardedJedisPool.getResource();
             return shardJedis;
         } catch (Exception e) {
             log.error("getRedisClent error", e);
         }
         return null;
    }
 
     public void returnResource(ShardedJedis shardedJedis) {
         shardedJedisPool.returnResource(shardedJedis);
     }
 
     public void returnResource(ShardedJedis shardedJedis, boolean broken) {
         if (broken) {
             shardedJedisPool.returnBrokenResource(shardedJedis);
         } else {
             shardedJedisPool.returnResource(shardedJedis);
         }
     }
 }

5、RedisClient类中实现Redis的相关操作

  package com.redis.demo;
    
    import java.util.Collection;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.annotation.Autowired;
   
   import com.redis.demo.service.impl.RedisServiceImpl;
   
   import redis.clients.jedis.BinaryClient.LIST_POSITION;
   import redis.clients.jedis.Jedis;
   import redis.clients.jedis.JedisShardInfo;
   import redis.clients.jedis.ShardedJedis;
   import redis.clients.jedis.ShardedJedisPipeline;
   import redis.clients.jedis.SortingParams;
   import redis.clients.jedis.Tuple;
   
 
   public class RedisClient {
   
       private static final Logger log = LoggerFactory.getLogger(RedisClient.class);
   
       @Autowired
       private RedisServiceImpl redisService;
   
       public void disconnect() {
           ShardedJedis shardedJedis = redisService.getRedisClient();
           shardedJedis.disconnect();
       }
   
       /**
        * 设置单个值
        */
       public String set(String key, String value) {
           String result = null;
   
           ShardedJedis shardedJedis = redisService.getRedisClient();
           if (shardedJedis == null) {
               return result;
           }
           boolean flag = false;
           try {
               result = shardedJedis.set(key, value);
           } catch (Exception e) {
               log.error(e.getMessage(), e);
               flag = true;
           } finally {
               redisService.returnResource(shardedJedis, flag);
           }
           return result;
       }
   
       /**
        * 获取单个值
        */
       public String get(String key) {
           String result = null;
           ShardedJedis shardedJedis = redisService.getRedisClient();
           if (shardedJedis == null) {
               return result;
           }
   
           boolean flag = false;
           try {
               result = shardedJedis.get(key);
   
           } catch (Exception e) {
               log.error(e.getMessage(), e);
               flag = true;
           } finally {
               redisService.returnResource(shardedJedis, flag);
           }
           return result;
       }
   
       public Boolean exists(String key) {
           Boolean result = false;
           ShardedJedis shardedJedis = redisService.getRedisClient();
           if (shardedJedis == null) {
               return result;
           }
           boolean flag = false;
           try {
               result = shardedJedis.exists(key);
           } catch (Exception e) {
               log.error(e.getMessage(), e);
               flag = true;
           } finally {
               redisService.returnResource(shardedJedis, flag);
           }
           return result;
      }
  
      public String type(String key) {
          String result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.type(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      /**
       * 在某段时间后失效
       */
      public Long expire(String key, int seconds) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.expire(key, seconds);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      /**
       * 在某个时间点失效
       */
      public Long expireAt(String key, long time) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.expireAt(key, time);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long ttl(String key) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.ttl(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public boolean setbit(String key, long offset, boolean value) {
  
          ShardedJedis shardedJedis = redisService.getRedisClient();
          boolean result = false;
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.setbit(key, offset, value);
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public boolean getbit(String key, long offset) {
          ShardedJedis shardedJedis = redisService.getRedisClient();
          boolean result = false;
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
  
          try {
              result = shardedJedis.getbit(key, offset);
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public long setrange(String key, long offset, String value) {
          ShardedJedis shardedJedis = redisService.getRedisClient();
          long result = ;
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.setrange(key, offset, value);
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public String getrange(String key, long startOffset, long endOffset) {
          ShardedJedis shardedJedis = redisService.getRedisClient();
          String result = null;
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.getrange(key, startOffset, endOffset);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public String getSet(String key, String value) {
          String result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.getSet(key, value);
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long setnx(String key, String value) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.setnx(key, value);
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public String setex(String key, int seconds, String value) {
          String result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.setex(key, seconds, value);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long decrBy(String key, long integer) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.decrBy(key, integer);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long decr(String key) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.decr(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long incrBy(String key, long integer) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.incrBy(key, integer);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long incr(String key) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.incr(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long append(String key, String value) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.append(key, value);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public String substr(String key, int start, int end) {
          String result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.substr(key, start, end);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long hset(String key, String field, String value) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.hset(key, field, value);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public String hget(String key, String field) {
          String result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.hget(key, field);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long hsetnx(String key, String field, String value) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.hsetnx(key, field, value);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public String hmset(String key, Map<String, String> hash) {
          String result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.hmset(key, hash);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public List<String> hmget(String key, String... fields) {
          List<String> result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.hmget(key, fields);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long hincrBy(String key, String field, long value) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.hincrBy(key, field, value);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Boolean hexists(String key, String field) {
          Boolean result = false;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.hexists(key, field);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long del(String key) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.del(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long hdel(String key, String field) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.hdel(key, field);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long hlen(String key) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.hlen(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Set<String> hkeys(String key) {
          Set<String> result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.hkeys(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public List<String> hvals(String key) {
          List<String> result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.hvals(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Map<String, String> hgetAll(String key) {
          Map<String, String> result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.hgetAll(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      /**
       * 在redis list尾部增加一个String
       * */
      public Long rpush(String key, String string) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.rpush(key, string);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      /**
       * 在redis list头部增加一个String
       * */
      public Long lpush(String key, String string) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.lpush(key, string);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long llen(String key) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.llen(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public List<String> lrange(String key, long start, long end) {
          List<String> result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.lrange(key, start, end);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public String ltrim(String key, long start, long end) {
          String result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.ltrim(key, start, end);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public String lIndex(String key, long index) {
          String result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.lindex(key, index);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public String lset(String key, long index, String value) {
          String result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.lset(key, index, value);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long lrem(String key, long count, String value) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.lrem(key, count, value);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      /**
       * 从redis list头部取出一个key
       * */
      public String lpop(String key) {
          String result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.lpop(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      /**
       * 从redis list尾部取出一个key
       * */
      public String rpop(String key) {
          String result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.rpop(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long sadd(String key, String member) {
          Long result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.sadd(key, member);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Set<String> smembers(String key) {
          Set<String> result = null;
          ShardedJedis shardedJedis = redisService.getRedisClient();
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.smembers(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long srem(String key, String member) {
          ShardedJedis shardedJedis = redisService.getRedisClient();
  
          Long result = null;
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.srem(key, member);
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public String spop(String key) {
          ShardedJedis shardedJedis = redisService.getRedisClient();
          String result = null;
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.spop(key);
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Long scard(String key) {
          ShardedJedis shardedJedis = redisService.getRedisClient();
          Long result = null;
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.scard(key);
  
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public Boolean sismember(String key, String member) {
          ShardedJedis shardedJedis = redisService.getRedisClient();
          Boolean result = null;
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.sismember(key, member);
          } catch (Exception e) {
              log.error(e.getMessage(), e);
              flag = true;
          } finally {
              redisService.returnResource(shardedJedis, flag);
          }
          return result;
      }
  
      public String srandmember(String key) {
          ShardedJedis shardedJedis = redisService.getRedisClient();
          String result = null;
          if (shardedJedis == null) {
              return result;
          }
          boolean flag = false;
          try {
              result = shardedJedis.srandmember(key);
          } catch (Exception e) {
              log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Long zadd(String key, double score, String member) {
         Long result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
             result = shardedJedis.zadd(key, score, member);
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Set<String> zrange(String key, int start, int end) {
         Set<String> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
             result = shardedJedis.zrange(key, start, end);
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Long zrem(String key, String member) {
         Long result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
             result = shardedJedis.zrem(key, member);
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Double zincrby(String key, double score, String member) {
         Double result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zincrby(key, score, member);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Long zrank(String key, String member) {
         Long result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zrank(key, member);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Long zrevrank(String key, String member) {
         Long result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zrevrank(key, member);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Set<String> zrevrange(String key, int start, int end) {
         Set<String> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zrevrange(key, start, end);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Set<Tuple> zrangeWithScores(String key, int start, int end) {
         Set<Tuple> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zrangeWithScores(key, start, end);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Set<Tuple> zrevrangeWithScores(String key, int start, int end) {
         Set<Tuple> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zrevrangeWithScores(key, start, end);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Long zcard(String key) {
         Long result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zcard(key);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Double zscore(String key, String member) {
         Double result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zscore(key, member);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public List<String> sort(String key) {
         List<String> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.sort(key);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public List<String> sort(String key, SortingParams sortingParameters) {
         List<String> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.sort(key, sortingParameters);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Long zcount(String key, double min, double max) {
         Long result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zcount(key, min, max);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Set<String> zrangeByScore(String key, double min, double max) {
         Set<String> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zrangeByScore(key, min, max);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Set<String> zrevrangeByScore(String key, double max, double min) {
         Set<String> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zrevrangeByScore(key, max, min);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Set<String> zrangeByScore(String key, double min, double max,
             int offset, int count) {
         Set<String> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zrangeByScore(key, min, max, offset, count);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Set<String> zrevrangeByScore(String key, double max, double min,
             int offset, int count) {
         Set<String> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis
                     .zrevrangeByScore(key, max, min, offset, count);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
 
         Set<Tuple> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zrangeByScoreWithScores(key, min, max);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Set<Tuple> zrevrangeByScoreWithScores(String key, double max,
             double min) {
         Set<Tuple> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zrevrangeByScoreWithScores(key, max, min);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Set<Tuple> zrangeByScoreWithScores(String key, double min,
             double max, int offset, int count) {
         Set<Tuple> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zrangeByScoreWithScores(key, min, max,
                     offset, count);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Set<Tuple> zrevrangeByScoreWithScores(String key, double max,
             double min, int offset, int count) {
         Set<Tuple> result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zrevrangeByScoreWithScores(key, max, min,
                     offset, count);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Long zremrangeByRank(String key, int start, int end) {
         Long result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zremrangeByRank(key, start, end);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Long zremrangeByScore(String key, double start, double end) {
         Long result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.zremrangeByScore(key, start, end);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Long linsert(String key, LIST_POSITION where, String pivot,
             String value) {
         Long result = null;
         ShardedJedis shardedJedis = redisService.getRedisClient();
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
 
             result = shardedJedis.linsert(key, where, pivot, value);
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     
     @SuppressWarnings("deprecation")
     public List<Object> pipelined(ShardedJedisPipeline shardedJedisPipeline) {
         ShardedJedis shardedJedis = redisService.getRedisClient();
         List<Object> result = null;
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
             result = shardedJedis.pipelined(shardedJedisPipeline);
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Jedis getShard(String key) {
         ShardedJedis shardedJedis = redisService.getRedisClient();
         Jedis result = null;
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
             result = shardedJedis.getShard(key);
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public JedisShardInfo getShardInfo(String key) {
         ShardedJedis shardedJedis = redisService.getRedisClient();
         JedisShardInfo result = null;
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
             result = shardedJedis.getShardInfo(key);
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public String getKeyTag(String key) {
         ShardedJedis shardedJedis = redisService.getRedisClient();
         String result = null;
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
             result = shardedJedis.getKeyTag(key);
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Collection<JedisShardInfo> getAllShardInfo() {
         ShardedJedis shardedJedis = redisService.getRedisClient();
         Collection<JedisShardInfo> result = null;
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
             result = shardedJedis.getAllShardInfo();
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
     public Collection<Jedis> getAllShards() {
         ShardedJedis shardedJedis = redisService.getRedisClient();
         Collection<Jedis> result = null;
         if (shardedJedis == null) {
             return result;
         }
         boolean flag = false;
         try {
             result = shardedJedis.getAllShards();
 
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             flag = true;
         } finally {
             redisService.returnResource(shardedJedis, flag);
         }
         return result;
     }
 
 }

本文同步分享在博客“张志翔ۤ”（CSDN）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

Go 语言操作 Redis

文章引用自

Go 语言操作 Redis

Redis 介绍

Redis 是一个开源的内存数据库，Redis 提供了多种不同类型的数据结构，很多业务场景下的问题都可以很自然地映射到这些数据结构上。除此之外，通过复制、持久化和客户端分片等特性，我们可以很方便地将 Redis 扩展成一个能够包含数百 GB 数据、每秒处理上百万次请求的系统。

Redis 支持的数据结构

Redis 支持诸如字符串（strings）、哈希（hashes）、列表（lists）、集合（sets）、带范围查询的排序集合（sorted sets）、位图（bitmaps）、hyperloglogs、带半径查询和流的地理空间索引等数据结构（geospatial indexes）。

Redis 应用场景

缓存系统，减轻主数据库（MySQL）的压力。
计数场景，比如微博、抖音中的关注数和粉丝数。
热门排行榜，需要排序的场景特别适合使用 ZSET。
利用 LIST 可以实现队列的功能。

Redis 与 Memcached 比较

Memcached 中的值只支持简单的字符串，Reids 支持更丰富的 5 中数据结构类型。 Redis 的性能比 Memcached 好很多 Redis 支持 RDB 持久化和 AOF 持久化。 Redis 支持 master/slave 模式。

Go 操作 Redis

安装

Go 语言中使用第三方库 https://github.com/go-redis/redis 连接 Redis 数据库并进行操作。使用以下命令下载并安装:

go get -u github.com/go-redis/redis

连接

// 声明一个全局的redisdb变量
var redisdb *redis.Client

// 初始化连接
func initClient() (err error) {
	redisdb = redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})

	_, err = redisdb.Ping().Result()
	if err != nil {
		return err
	}
	return nil
}

基本使用

set/get 示例

func redisExample() {
	// 调用set方法存放数据 分别传入 key value timeout 并链式操作调用.Err方法判断是否有错
    err := redisdb.Set("score", 100, 0).Err()
    if err != nil {
        fmt.Printf("set score failed, err:%v\n", err)
        return
    }
 	
 	// 调用get方法获取数据 传入key 并链式操作调用.Result方法获取值
    val, err := redisdb.Get("score").Result()
    if err != nil {
        fmt.Printf("get score failed, err:%v\n", err)
        return
    }
    fmt.Println("score", val)
 
    val2, err := redisdb.Get("name").Result()
    if err == redis.Nil {
        fmt.Println("name does not exist")
    } else if err != nil {
        fmt.Printf("get name failed, err:%v\n", err)
        return
    } else {
        fmt.Println("name", val2)
    }
}

zset 示例

func redisExample2() {
	zsetKey := "language_rank"
	languages := []*redis.Z{
		&redis.Z{Score: 90.0, Member: "Golang"},
		&redis.Z{Score: 98.0, Member: "Java"},
		&redis.Z{Score: 95.0, Member: "Python"},
		&redis.Z{Score: 97.0, Member: "JavaScript"},
		&redis.Z{Score: 99.0, Member: "C/C++"},
	}
	// ZADD
	num, err := redisdb.ZAdd(zsetKey, languages...).Result()
	if err != nil {
		fmt.Printf("zadd failed, err:%v\n", err)
		return
	}
	fmt.Printf("zadd %d succ.\n", num)

	// 把Golang的分数加10
	newScore, err := redisdb.ZIncrBy(zsetKey, 10.0, "Golang").Result()
	if err != nil {
		fmt.Printf("zincrby failed, err:%v\n", err)
		return
	}
	fmt.Printf("Golang''s score is %f now.\n", newScore)

	// 取分数最高的3个
	ret, err := redisdb.ZRevRangeWithScores(zsetKey, 0, 2).Result()
	if err != nil {
		fmt.Printf("zrevrange failed, err:%v\n", err)
		return
	}
	for _, z := range ret {
		fmt.Println(z.Member, z.Score)
	}

	// 取95~100分的
	op := &redis.ZRangeBy{
		Min: "95",
		Max: "100",
	}
	ret, err = redisdb.ZRangeByScoreWithScores(zsetKey, op).Result()
	if err != nil {
		fmt.Printf("zrangebyscore failed, err:%v\n", err)
		return
	}
	for _, z := range ret {
		fmt.Println(z.Member, z.Score)
	}
}
输出结果如下：

$ ./06redis_demo 
zadd 0 succ.
Golang''s score is 100.000000 now.
Golang 100
C/C++ 99
Java 98
JavaScript 97
Java 98
C/C++ 99
Golang 100

封装使用

package sql_redis

import (
	"fmt"
	"github.com/go-redis/redis"
	"time"
)

var RedisDb *redis.Client

func init() {
	// 连接redis
	RedisDb = redis.NewClient(&redis.Options{
		Addr: "127.0.0.1:6379",
	})
	_, err := RedisDb.Ping().Result()
	if err != nil {
		fmt.Println("未成功连接Redis:", err)
		return
	}
	println("连接Redis成功")
}

func RedisSet(key string, value interface{}, expiration time.Duration) (interface{},error) {
	err := RedisDb.Set(key, value, expiration).Err()
	if err != nil {
		return fmt.Sprintln("Redis设置指失败"),err
	}
	return 	fmt.Sprintln("设置成功"),nil
}

func RedisGet(key string) (interface{}, error) {
	value, err := RedisDb.Get(key).Result()
	if err != nil {
		fmt.Println("Redis获取key失败")
		return nil, err
	}
	return value, nil
}

Go语言操作redis数据库的方法

先上命令速查网站，菜鸟yyds
https://www.runoob.com/redis/redis-strings.html
操作redis的包是go-redis/redis
官方文档 https://redis.uptrace.dev/guide/
github https://github.com/go-redis/redis

创建项目
创建test文件夹
创建 Redis_test.go 文件
直接上代码，代码解释全写在注释里

package test
import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/go-redis/redis/v8"
	"testing"
	"time"
)
var ctx = context.Background()
var rdb *redis.Client
func init() {
	rdb = redis.NewClient(&redis.Options{
		//	端口需要改，这里是docker的端口
		Addr:	  "localhost:49153",
		Password: "redispw", // no password set
		DB:		  0,  // use default DB
		PoolSize:15,
		MinIdleConns: 10, //在启动阶段创建指定数量的Idle连接，并长期维持idle状态的连接数不少于指定数量；。
		//超时
		//DialTimeout:  5 * time.Second, //连接建立超时时间，默认5秒。
		//ReadTimeout:  3 * time.Second, //读超时，默认3秒， -1表示取消读超时
		//WriteTimeout: 3 * time.Second, //写超时，默认等于读超时
		//PoolTimeout:  4 * time.Second, //当所有连接都处在繁忙状态时，客户端等待可用连接的最大等待时长，默认为读超时+1秒。
	})
}
//	基础使用
func Test_Base(t *testing.T) {
	//	添加key
	//0表示没有过期时间
	rdb.Set(ctx, "testKey", "xxx", 0)
	//	获取值
	val, err := rdb.Get(ctx, "testKey").Result()
	if err != nil {
		fmt.Println("错误", err)
	}
	fmt.Println("值：", val)
	//	设置key过期时间 成功true
	rdb.Expire(ctx, "testKey", time.Second*60)
	//	存在返回1
	rdb.Exists(ctx, "testKey")
	//	key不存在时设置值
	rdb.SetNX(ctx, "unkey", "val", 0)
	rdb.Set(ctx, "testKey2", "xxx", 0)
	//	删除key 可删除多个
	rdb.Del(ctx, "testKey2", "testKey")
}
//	字符串
func Test_String(t *testing.T) {
	//	设置值
	rdb.Set(ctx, "strKey", 100, 0)
	rdb.Set(ctx, "straey", 100, 0)
	//	key自增1
	rdb.Incr(ctx, "strKey")
	//	增加 66
	rdb.IncrBy(ctx, "straey", 66)
	//	-1
	rdb.Decr(ctx, "straey")
	//	-5
	rdb.DecrBy(ctx, "straey", 5)
	//	过期时间
	rdb.TTL(ctx, "strKey")
	//	str*ey		: *为任意字符串
	//	str[kKac]ey : 匹配[] 内的单个字符 strkey,strKey,straey,strcey
	//	str?ey		: ? 任意单个字符
	//	扫描key
	iter := rdb.Scan(ctx, 0, "str?ey", 0).Iterator()
	for iter.Next(ctx) {
		fmt.Println("keys", iter.Val(), ": val", rdb.Get(ctx, iter.Val()).Val())
	}
	if err := iter.Err(); err != nil {
		panic(err)
	}
}
//	哈希
func Test_Hash(t *testing.T) {
	rdb.HMSet(ctx,"hkey1","name","shushan","age",99,"b",true)
	//	以结构体存入 注意redis tag
	type User struct {
		Name string `json:"name,omitempty" redis:"name"`
		Age  int    `json:"age,omitempty" redis:"age"`
		B    bool   `json:"b,omitempty" redis:"b"`
		//...
	}
	user1 := User{
		Name: "shushan2",
		Age:  55,
		B:    true,
	}
	//	结构体序列化反序列化map 你也可以用其他包进行转化为map,但是注意转化后的键名大小写问题
	m := make(map[string]interface{})
	buf,_ := json.Marshal(user1)
	_ = json.Unmarshal(buf,&m)
	//	存入
	rdb.HSet(ctx, "user4", m)
	//	取出绑定到结构体 map也行
	var user User
	rdb.HGetAll(ctx,"user4").Scan(&user)
	fmt.Printf(" %#v \n ",user)
	//	test.User{Name:"shushan2", Age:55, B:true}
	//	获取key下的所有值   *匹配方式与string的所有原理一样
	iter := rdb.HScan(ctx,"user4",0,"*",0).Iterator()
	for iter.Next(ctx) {
		fmt.Println("keys", iter.Val())
	}
	if err := iter.Err(); err != nil {
		panic(err)
	}
}
//	列表
func Test_List(t *testing.T) {
	//	添加
	rdb.LPush(ctx,"listKey1",111,222,333,444)
	rdb.RPush(ctx,"listKey1",5555)
	//	不存在不添加
	rdb.LPushX(ctx,"unlistKey",111)
	var intf []int
	//	根据索引获取 绑定到数组
	rdb.LRange(ctx,"listKey1",0,10).ScanSlice(&intf)
	fmt.Println(intf)
	var i int
	//	弹出
	rdb.LPop(ctx,"listKey1").Scan(&i)
	fmt.Println(i)
	//....
}
//	集合
func Test_Set(t *testing.T) {
	//	添加
	rdb.SAdd(ctx,"setKey1","m1","onlyk1")
	rdb.SAdd(ctx,"setKey2","m2","xca")
	sl,_:= rdb.SDiff(ctx,"setKey1","setKey2").Result()
	fmt.Println(sl)
	// onlyk1,m1
	//随机移除
	var val string
	rdb.SPop(ctx,"setKey1").Scan(&val)
	fmt.Println(val)
	// .....
}
//	管道
func Test_Pipe(t *testing.T) {
	// 	官方描述
	// 	Redis 管道允许客户端命令服务器通过执行任务而通过执行任务来提高您的性能。
	//	在管道中，像命令命令一样将编写 + 使用命令来执行任务，并将其用于执行任务，执行任务不是一个地执行100个命令。
	//	理解为命令就像石头，一次运送一个石头
	//	使用管道等于 用车装石头  Exec 时就运送过去
	pipe := rdb.Pipeline()
	incr := pipe.Set(ctx, "pip_test","bt",0)
	pipe.Expire(ctx, "pip_test", time.Hour)
	//	提交
	cmds, err := pipe.Exec(ctx)
	if err != nil {
		fmt.Println(err)
	}
	for _, cmd := range cmds {
		fmt.Println(cmd.String())
	}
	// 该值得Exec提交后有效
	fmt.Println(incr.Val())
}

其他操作都可以查看go-redis的源码或者直接打出rdb.命令，go-redis 的函数命名方式和redis的命令是差不多的

到此这篇关于Go语言操作redis数据库的方法的文章就介绍到这了,更多相关go操作redis内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

您可能感兴趣的文章:

golang MySQL实现对数据库表存储获取操作示例
实现像php一样方便的go ORM数据库操作示例详解
Golang连接并操作PostgreSQL数据库基本操作
golang连接MongoDB数据库及数据库操作指南
golang实现文件上传并转存数据库功能
Go实现简单的数据库表转结构体详解

Go语言操作redis用法实例

本文实例讲述了Go语言操作redis用法。分享给大家供大家参考。具体如下：

复制代码代码如下:

package main
import (
"fmt"
"log"
"redis"
)
func main() {
//DefaultSpec()创建一个连接规格
spec := redis.DefaultSpec().Db(0).Password("");
//创建一个新的syncclient，并连接到Redis的服务器上使用,指定ConnectionSpec接口。
client,err := redis.NewSynchClientWithSpec (spec);
if err != nil {
  log.Println ("连接服务器失败>",err);
  return
}
dbkey := "GAME:TEST:info";
value,err := client.Get(dbkey);
if err!= nil {
  log.Println ("error on Get",err);
  return
}
//
if value == nil {
  value :=[]byte("Hello World!");
  client.Set(dbkey,value);
  fmt.Printf("插入数据>%s \n",value)
} else {
  fmt.Printf("接收到数据>%s \n",value);
  //return;
}
}

希望本文所述对大家的Go语言程序设计有所帮助。

go语言操作redis连接池的方法

本文实例讲述了go语言操作redis连接池的方法。分享给大家供大家参考。具体实现方法如下：

复制代码代码如下:

func newPool(server, password string) *redis.Pool {
    return &redis.Pool{
        MaxIdle: 3,
        IdleTimeout: 240 * time.Second,
        Dial: func () (redis.Conn, error) {
            c, err := redis.Dial("tcp", server)
            if err != nil {
                return nil, err
            }
            if _, err := c.Do("AUTH", password); err != nil {
                c.Close()
                return nil, err
            }
            return c, err
        },
        TestOnBorrow: func(c redis.Conn, t time.Time) error {
            _, err := c.Do("PING")
            return err
        },
    }
}
var (
    pool *redis.Pool
    redisServer = flag.String("redisServer", ":6379", "")
    redisPassword = flag.String("redisPassword", "", "")
)

func main() {
    flag.Parse()
    pool = newPool(*redisServer, *redisPassword)
    ...
}

希望本文所述对大家的Go语言程序设计有所帮助。

您可能感兴趣的文章:

Go实现Redis连接池方法

关于Java语言操作Redis和java语言操作系统的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于Go 语言操作 Redis、Go语言操作redis数据库的方法、Go语言操作redis用法实例、go语言操作redis连接池的方法等相关知识的信息别忘了在本站进行查找喔。

本文标签：