精华内容
下载资源
问答
  • Jedis使用教程完整版

    千次阅读 2018-11-12 18:49:00
    ...Jedis使用教程完整版 的内容,更多  整版  使用  教程  jedis  的内容,请您使用右上方搜索功能获取相关信息。 转载于:https://my.oschina.net/airship/blog/2875170
    • 摘要:概述Jedis是Redis官方推荐的Java连接开发工具。要在Java开发中使用好Redis中间件,必须对Jedis熟悉才能写成漂亮的代码。这篇文章不描述怎么安装Redis和Reids的命令,只对Jedis的使用进行对介绍。1.基本使用Jedis的基本使用非常简单,只需要创建Jedis对象的时候指定host,port,password即可。当然,Jedis对象又很多构造方法,都大同小异,只是对应和Redis连接的socket的参数不一样而已。Jedisjedis=newJed
    • 概述 

      Jedis是Redis官方推荐的Java连接开发工具。要在Java开发中使用好Redis中间件,必须对Jedis熟悉才能写成漂亮的代码。这篇文章不描述怎么安装Redis和Reids的命令,只对Jedis的使用进行对介绍。

       

      Jedis使用教程完整版_Java


      1. 基本使用 

      Jedis的基本使用非常简单,只需要创建Jedis对象的时候指定host,port, password即可。当然,Jedis对象又很多构造方法,都大同小异,只是对应和Redis连接的socket的参数不一样而已。


      Jedis jedis = new Jedis("localhost", 6379);//指定Redis服务Host和port 
      jedis.auth("xxxx"); //如果Redis服务连接需要密码,制定密码 
      String value = jedis.get("key"); //访问Redis服务 
      jedis.close(); //使用完关闭连接 

      Jedis基本使用十分简单,在每次使用时,构建Jedis对象即可。在Jedis对象构建好之后,Jedis底层会打开一条Socket通道和Redis服务进行连接。所以在使用完Jedis对象之后,需要调用Jedis.close()方法把连接关闭,不如会占用系统资源。当然,如果应用非常平凡的创建和销毁Jedis对象,对应用的性能是很大影响的,因为构建Socket的通道是很耗时的(类似数据库连接)。我们应该使用连接池来减少Socket对象的创建和销毁过程。


      2. 连接池使用 

      Jedis连接池是基于apache-commons pool2实现的。在构建连接池对象的时候,需要提供池对象的配置对象,及JedisPoolConfig(继承自GenericObjectPoolConfig)。我们可以通过这个配置对象对连接池进行相关参数的配置(如最大连接数,最大空数等)。


      JedisPoolConfig config = new JedisPoolConfig(); 
      config.setMaxIdle(8); 
      config.setMaxTotal(18); 
      JedisPool pool = new JedisPool(config, "127.0.0.1", 6379, 2000, "password"); 
      Jedis jedis = pool.getResource(); 
      String value = jedis.get("key"); 
      ...... 
      jedis.close(); 
      pool.close(); 

      使用Jedis连接池之后,在每次用完连接对象后一定要记得把连接归还给连接池。Jedis对close方法进行了改造,如果是连接池中的连接对象,调用Close方法将会是把连接对象返回到对象池,若不是则关闭连接。可以查看如下代码


      @Override 
      public void close() { //Jedis的close方法 
      if (dataSource != null) { 
      if (client.isBroken()) { 
      this.dataSource.returnBrokenResource(this); 
      } else { 
      this.dataSource.returnResource(this); 

      } else { 
      client.close(); 


      //另外从对象池中获取Jedis链接时,将会对dataSource进行设置 
      // JedisPool.getResource()方法 
      public Jedis getResource() { 
      Jedis jedis = super.getResource(); 
      jedis.setDataSource(this); 
      return jedis; 

      3. 高可用连接 

      我们知道,连接池可以大大提高应用访问Reids服务的性能,减去大量的Socket的创建和销毁过程。但是Redis为了保障高可用,服务一般都是Sentinel部署方式(可以查看我的文章详细了解)。当Redis服务中的主服务挂掉之后,会仲裁出另外一台Slaves服务充当Master。这个时候,我们的应用即使使用了Jedis连接池,Master服务挂了,我们的应用奖还是无法连接新的Master服务。为了解决这个问题,Jedis也提供了相应的Sentinel实现,能够在Redis Sentinel主从切换时候,通知我们的应用,把我们的应用连接到新的 Master服务。先看下怎么使用。

       
       

      注意:Jedis版本必须2.4.2或更新版本


      Set sentinels = new HashSet<>(); 
      sentinels.add("172.18.18.207:26379"); 
      sentinels.add("172.18.18.208:26379"); 
      JedisPoolConfig config = new JedisPoolConfig(); 
      config.setMaxIdle(5); 
      config.setMaxTotal(20); 
      JedisSentinelPool pool = new JedisSentinelPool("mymaster", sentinels, config); 
      Jedis jedis = pool.getResource(); 
      jedis.set("jedis", "jedis"); 
      ...... 
      jedis.close(); 
      pool.close(); 

      Jedis Sentinel的使用也是十分简单的,只是在JedisPool中添加了Sentinel和MasterName参数。Jedis Sentinel底层基于Redis订阅实现Redis主从服务的切换通知。当Reids发生主从切换时,Sentinel会发送通知主动通知Jedis进行连接的切换。JedisSentinelPool在每次从连接池中获取链接对象的时候,都要对连接对象进行检测,如果此链接和Sentinel的Master服务连接参数不一致,则会关闭此连接,重新获取新的Jedis连接对象。


      public Jedis getResource() { 
      while (true) { 
      Jedis jedis = super.getResource(); 
      jedis.setDataSource(this); 
      // get a reference because it can change concurrently 
      final HostAndPort master = currentHostMaster; 
      final HostAndPort connection = new HostAndPort(jedis.getClient().getHost(), jedis.getClient().getPort()); 
      if (master.equals(connection)) { 
      // connected to the correct master 
      return jedis; 
      } else { 
      returnBrokenResource(jedis); 


      当然,JedisSentinelPool对象要时时监控RedisSentinel的主从切换。在其内部通过Reids的订阅实现。具体的实现看JedisSentinelPool的两个方法就很清晰


      private HostAndPort initSentinels(Set sentinels, final String masterName) { 
      HostAndPort master = null; 
      boolean sentinelAvailable = false; 
      log.info("Trying to find master from available Sentinels..."); 
      for (String sentinel : sentinels) { 
      final HostAndPort hap = HostAndPort.parseString(sentinel); 
      log.fine("Connecting to Sentinel " + hap); 
      Jedis jedis = null; 
      try { 
      jedis = new Jedis(hap.getHost(), hap.getPort()); 
      //从RedisSentinel中获取Master信息 
      List masterAddr = jedis.sentinelGetMasterAddrByName(masterName); 
      sentinelAvailable = true; // connected to sentinel... 
      if (masterAddr == null || masterAddr.size() != 2) { 
      log.warning("Can not get master addr, master name: " + masterName + ". Sentinel: " + hap + "."); 
      continue; 

      master = toHostAndPort(masterAddr); 
      log.fine("Found Redis master at " + master); 
      break; 
      } catch (JedisException e) { 
      // it should handle JedisException there's another chance of raising JedisDataException 
      log.warning("Cannot get master address from sentinel running @ " + hap + ". Reason: " + e + ". Trying next one."); 
      } finally { 
      if (jedis != null) { 
      jedis.close(); 



      if (master == null) { 
      if (sentinelAvailable) { 
      // can connect to sentinel, but master name seems to not monitored 
      throw new JedisException("Can connect to sentinel, but " + masterName + " seems to be not monitored..."); 
      } else { 
      throw new JedisConnectionException("All sentinels down, cannot determine where is " + masterName + " master is running..."); 


      log.info("Redis master running at " + master + ", starting Sentinel listeners..."); 
      //启动后台线程监控RedisSentinal的主从切换通知 
      for (String sentinel : sentinels) { 
      final HostAndPort hap = HostAndPort.parseString(sentinel); 
      MasterListener masterListener = new MasterListener(masterName, hap.getHost(), hap.getPort()); 
      // whether MasterListener threads are alive or not, process can be stopped 
      masterListener.setDaemon(true); 
      masterListeners.add(masterListener); 
      masterListener.start(); 

      return master; 
      }private void initPool(HostAndPort master) { 
      if (!master.equals(currentHostMaster)) { 
      currentHostMaster = master; 
      if (factory == null) { 
      factory = new JedisFactory(master.getHost(), master.getPort(), connectionTimeout, soTimeout, password, database, clientName, false, null, null, null); 
      initPool(poolConfig, factory); 
      } else { 
      factory.setHostAndPort(currentHostMaster); 
      // although we clear the pool, we still have to check the returned object 
      // in getResource, this call only clears idle instances, not 
      // borrowed instances 
      internalPool.clear(); 

      log.info("Created JedisPool to master at " + master); 

      可以看到,JedisSentinel的监控时使用MasterListener这个对象来实现的。看对应源码可以发现是基于Redis的订阅实现的,其订阅频道为"+switch-master"。当MasterListener接收到switch-master消息时候,会使用新的Host和port进行initPool。这样对连接池中的连接对象清除,重新创建新的连接指向新的Master服务。


      4. 客户端分片 

      对于大应用来说,单台Redis服务器肯定满足不了应用的需求。在Redis3.0之前,是不支持集群的。如果要使用多台Reids服务器,必须采用其他方式。很多公司使用了代理方式来解决Redis集群。对于Jedis,也提供了客户端分片的模式来连接“Redis集群”。其内部是采用Key的一致性hash算法来区分key存储在哪个Redis实例上的。


      JedisPoolConfig config = new JedisPoolConfig(); 
      config.setMaxTotal(500); 
      config.setTestOnBorrow(true); 
      List jdsInfoList = new ArrayList<>(2); 
      jdsInfoList.add(new JedisShardInfo("192.168.2.128", 6379)); 
      jdsInfoList.add(new JedisShardInfo("192.168.2.108", 6379)); 
      pool = new ShardedJedisPool(config, jdsInfoList, Hashing.MURMUR_HASH, Sharded.DEFAULT_KEY_TAG_PATTERN); 
      jds.set(key, value); 
      ...... 
      jds.close(); 
      pool.close(); 

      当然,采用这种方式也存在两个问题

      扩容问题: 因为使用了一致性哈稀进行分片,那么不同的key分布到不同的Redis-Server上,当我们需要扩容时,需要增加机器到分片列表中,这时候会使得同样的key算出来落到跟原来不同的机器上,这样如果要取某一个值,会出现取不到的情况。 
      单点故障问题: 当集群中的某一台服务挂掉之后,客户端在根据一致性hash无法从这台服务器取数据。

      对于扩容问题,Redis的作者提出了一种名为Pre-Sharding的方式。即事先部署足够多的Redis服务。 对于单点故障问题,我们可以使用Redis的HA高可用来实现。利用Redis-Sentinal来通知主从服务的切换。当然,Jedis没有实现这块。我将会在下一篇文章进行介绍。


      5. 小结 
       

      对于Jedis的基本使用还是很简单的。要根据不用的应用场景选择对于的使用方式。 另外,Spring也提供了Spring-data-redis包来整合Jedis的操作,另外Spring也单独分装了Jedis(我将会在另外一篇文章介绍)。

       

      作者:曹金桂 链接:http://www.jianshu.com/p/a1038eed6d44 來源:简书

    • 以上是Jedis使用教程完整版的内容,更多 整版 使用 教程 jedis 的内容,请您使用右上方搜索功能获取相关信息。

    转载于:https://my.oschina.net/airship/blog/2875170

    展开全文
  • Jedis使用教程完整版读后感概述基本使用连接池使用高可用连接客户端分片小结 读后感 简介 Jedis是Redis官方推荐的Java链接工具 资源的创建 通过Jedis自带的线程池创建资源 Jedis一般使用JedisPool线程池链接...


    读后感

    简介

    • Jedis是Redis官方推荐的Java链接工具

    资源的创建

    • 通过Jedis自带的线程池创建资源
      • Jedis一般使用JedisPool线程池链接Redis
      • 为了实现高可用,通过使用JedisSentinelPool来链接Redis
    • 创建完之后通过pool.getResource来获得资源

    资源的回收

    • 使用完后,需要通过jedis.close();pool.close();将资源还给连接池
    • Jedis会自动判断,若是连接池对象则把连接对象还给连接池,若不是则关闭链接。

    以下是原文

    概述

    Jedis是Redis官方推荐的Java连接开发工具。要在Java开发中使用好Redis中间件,必须对Jedis熟悉才能写成漂亮的代码。这篇文章不描述怎么安装Redis和Reids的命令,只对Jedis的使用进行对介绍。

    基本使用

    Jedis的基本使用非常简单,只需要创建Jedis对象的时候指定host,port, password即可。当然,Jedis对象又很多构造方法,都大同小异,只是对应和Redis连接的socket的参数不一样而已。

    Jedis jedis = new Jedis("localhost", 6379);  //指定Redis服务Host和port
    jedis.auth("xxxx"); //如果Redis服务连接需要密码,制定密码
    String value = jedis.get("key"); //访问Redis服务
    jedis.close(); //使用完关闭连接
    

    Jedis基本使用十分简单,在每次使用时,构建Jedis对象即可。在Jedis对象构建好之后,Jedis底层会打开一条Socket通道和Redis服务进行连接。所以在使用完Jedis对象之后,需要调用Jedis.close()方法把连接关闭,不如会占用系统资源。当然,如果应用非常平凡的创建和销毁Jedis对象,对应用的性能是很大影响的,因为构建Socket的通道是很耗时的(类似数据库连接)。我们应该使用连接池来减少Socket对象的创建和销毁过程。

    连接池使用

    Jedis连接池是基于apache-commons pool2实现的。在构建连接池对象的时候,需要提供池对象的配置对象,及JedisPoolConfig(继承自GenericObjectPoolConfig)。我们可以通过这个配置对象对连接池进行相关参数的配置(如最大连接数,最大空数等)。

    JedisPoolConfig config = new JedisPoolConfig();
    config.setMaxIdle(8);
    config.setMaxTotal(18);
    JedisPool pool = new JedisPool(config, "127.0.0.1", 6379, 2000, "password");
    Jedis jedis = pool.getResource();
    String value = jedis.get("key");
    ......
    jedis.close();
    pool.close();
    

    使用Jedis连接池之后,在每次用完连接对象后一定要记得把连接归还给连接池。Jedis对close方法进行了改造,如果是连接池中的连接对象,调用Close方法将会是把连接对象返回到对象池,若不是则关闭连接。可以查看如下代码

    @Override
    public void close() { //Jedis的close方法
        if (dataSource != null) {
            if (client.isBroken()) {
                this.dataSource.returnBrokenResource(this);
            } else {
                this.dataSource.returnResource(this);
            }
        } else {
            client.close();
        }
    }
    
    
    //另外从对象池中获取Jedis链接时,将会对dataSource进行设置
    // JedisPool.getResource()方法
    public Jedis getResource() {
        Jedis jedis = super.getResource();   
        jedis.setDataSource(this);
        return jedis;
    }
    

    高可用连接

    我们知道,连接池可以大大提高应用访问Reids服务的性能,减去大量的Socket的创建和销毁过程。但是Redis为了保障高可用,服务一般都是Sentinel部署方式(可以查看原博主的文章详细了解)。当Redis服务中的主服务挂掉之后,会仲裁出另外一台Slaves服务充当Master。这个时候,我们的应用即使使用了Jedis连接池,Master服务挂了,我们的应用奖还是无法连接新的Master服务。为了解决这个问题,Jedis也提供了相应的Sentinel实现,能够在Redis Sentinel主从切换时候,通知我们的应用,把我们的应用连接到新的 Master服务。先看下怎么使用。

    注意:Jedis版本必须2.4.2或更新版本

    Set<String> sentinels = new HashSet<>();
    sentinels.add("172.18.18.207:26379");
    sentinels.add("172.18.18.208:26379");
    JedisPoolConfig config = new JedisPoolConfig();
    config.setMaxIdle(5);
    config.setMaxTotal(20);
    JedisSentinelPool pool = new JedisSentinelPool("mymaster", sentinels, config);
    Jedis jedis = pool.getResource();
    jedis.set("jedis", "jedis");
    ......
    jedis.close();
    pool.close();
    

    Jedis Sentinel的使用也是十分简单的,只是在JedisPool中添加了Sentinel和MasterName参数。Jedis Sentinel底层基于Redis订阅实现Redis主从服务的切换通知。当Reids发生主从切换时,Sentinel会发送通知主动通知Jedis进行连接的切换。JedisSentinelPool在每次从连接池中获取链接对象的时候,都要对连接对象进行检测,如果此链接和Sentinel的Master服务连接参数不一致,则会关闭此连接,重新获取新的Jedis连接对象。

    public Jedis getResource() {
        while (true) {
            Jedis jedis = super.getResource();
            jedis.setDataSource(this);
    
            // get a reference because it can change concurrently
            final HostAndPort master = currentHostMaster;
            final HostAndPort connection = new HostAndPort(jedis.getClient().getHost(), jedis.getClient().getPort());
            if (master.equals(connection)) {
                // connected to the correct master
                return jedis;
            } else {
                returnBrokenResource(jedis);
            }
        }
    }
    

    当然,JedisSentinelPool对象要时时监控RedisSentinel的主从切换。在其内部通过Reids的订阅实现。具体的实现看JedisSentinelPool的两个方法就很清晰

    private HostAndPort initSentinels(Set<String> sentinels, final String masterName) {
        HostAndPort master = null;
        boolean sentinelAvailable = false;
        log.info("Trying to find master from available Sentinels...");
        for (String sentinel : sentinels) {
            final HostAndPort hap = HostAndPort.parseString(sentinel);
            log.fine("Connecting to Sentinel " + hap);
            Jedis jedis = null;
            try {
                jedis = new Jedis(hap.getHost(), hap.getPort());
                //从RedisSentinel中获取Master信息
                List<String> masterAddr = jedis.sentinelGetMasterAddrByName(masterName);
                sentinelAvailable = true; // connected to sentinel...
                if (masterAddr == null || masterAddr.size() != 2) {
                    log.warning("Can not get master addr, master name: " + masterName + ". Sentinel: " + hap + ".");
                    continue;
                }
                master = toHostAndPort(masterAddr);
                log.fine("Found Redis master at " + master);
                break;
            } catch (JedisException e) {
                // it should handle JedisException there's another chance of raising JedisDataException
                log.warning("Cannot get master address from sentinel running @ " + hap + ". Reason: " + e + ". Trying next one.");
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
        if (master == null) {
            if (sentinelAvailable) {
                // can connect to sentinel, but master name seems to not monitored
                throw new JedisException("Can connect to sentinel, but " + masterName + " seems to be not monitored...");
            } else {
                throw new JedisConnectionException("All sentinels down, cannot determine where is " + masterName + " master is running...");
            }
        }
        log.info("Redis master running at " + master + ", starting Sentinel listeners...");
        //启动后台线程监控RedisSentinal的主从切换通知
        for (String sentinel : sentinels) {
            final HostAndPort hap = HostAndPort.parseString(sentinel);
            MasterListener masterListener = new MasterListener(masterName, hap.getHost(), hap.getPort());
            // whether MasterListener threads are alive or not, process can be stopped
            masterListener.setDaemon(true);
            masterListeners.add(masterListener);
            masterListener.start();
        }
        return master;
    }
    
    
    private void initPool(HostAndPort master) {
        if (!master.equals(currentHostMaster)) {
            currentHostMaster = master;
            if (factory == null) {
                factory = new JedisFactory(master.getHost(), master.getPort(), connectionTimeout, soTimeout, password, database, clientName, false, null, null, null);
                initPool(poolConfig, factory);
            } else {
                factory.setHostAndPort(currentHostMaster);
                // although we clear the pool, we still have to check the returned object
                // in getResource, this call only clears idle instances, not
                // borrowed instances
                internalPool.clear();
            }
            log.info("Created JedisPool to master at " + master);
        }
    }
    

    可以看到,JedisSentinel的监控时使用MasterListener这个对象来实现的。看对应源码可以发现是基于Redis的订阅实现的,其订阅频道为"+switch-master"。当MasterListener接收到switch-master消息时候,会使用新的Host和port进行initPool。这样对连接池中的连接对象清除,重新创建新的连接指向新的Master服务。

    客户端分片

    对于大应用来说,单台Redis服务器肯定满足不了应用的需求。在Redis3.0之前,是不支持集群的。如果要使用多台Reids服务器,必须采用其他方式。很多公司使用了代理方式来解决Redis集群。对于Jedis,也提供了客户端分片的模式来连接“Redis集群”。其内部是采用Key的一致性hash算法来区分key存储在哪个Redis实例上的。

    JedisPoolConfig config = new JedisPoolConfig();
    config.setMaxTotal(500);
    config.setTestOnBorrow(true);
    List<JedisShardInfo> jdsInfoList = new ArrayList<>(2);
    jdsInfoList.add(new JedisShardInfo("192.168.2.128", 6379));
    jdsInfoList.add(new JedisShardInfo("192.168.2.108", 6379));
    pool = new ShardedJedisPool(config, jdsInfoList, Hashing.MURMUR_HASH, Sharded.DEFAULT_KEY_TAG_PATTERN);
    jds.set(key, value);
    ......
    jds.close();
    pool.close();
    

    当然,采用这种方式也存在两个问题

    • 扩容问题:
      因为使用了一致性哈稀进行分片,那么不同的key分布到不同的Redis-Server上,当我们需要扩容时,需要增加机器到分片列表中,这时候会使得同样的key算出来落到跟原来不同的机器上,这样如果要取某一个值,会出现取不到的情况。
    • 单点故障问题:
      当集群中的某一台服务挂掉之后,客户端在根据一致性hash无法从这台服务器取数据。

    对于扩容问题,Redis的作者提出了一种名为Pre-Sharding的方式。即事先部署足够多的Redis服务。
    对于单点故障问题,我们可以使用Redis的HA高可用来实现。利用Redis-Sentinal来通知主从服务的切换。当然,Jedis没有实现这块。我将会在下一篇文章进行介绍。

    小结

    对于Jedis的基本使用还是很简单的。要根据不用的应用场景选择对于的使用方式。
    另外,Spring也提供了Spring-data-redis包来整合Jedis的操作,另外Spring也单独分装了Jedis.

    原文链接

    展开全文
  • Jedis使用指南

    千次阅读 2017-07-14 10:30:41
    简介 Jedis Client是Redis官网推荐的一个面向java客户端,库文件...想要使用Jedis必须加载jar包或者添加maven依赖,jar包可以自己上网下载,我的是Maven项目,所以在pom.xml中增加如下语句: &lt;dependenc...

    简介

    Jedis Client是Redis官网推荐的一个面向java客户端,库文件实现了对各类API进行封装调用。
    Jedis源码工程地址:

    https://github.com/xetorthio/jedis

    使用

    想要使用Jedis必须加载jar包或者添加maven依赖,jar包可以自己上网下载,我的是Maven项目,所以在pom.xml中增加如下语句:

    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
        <type>jar</type>
        <scope>compile</scope>
    </dependency>

    简单的Jedis实例

    在加载Jedis JAR包之后,我们可以直接使用新建一个Jedis实例的方法,来建立一个到Redis的连接,并进行操作,以下是一个简单的jedis实例:

    public void setup() {
     //连接redis服务器
            jedis = new Jedis("172.24.4.183", 6379);
    //        jedis.auth("redis");//验证密码,如果需要验证的话
        }
    /**
     * 键操作
     */
    public void testKey()  throws InterruptedException{
        System.out.println("清空数据:"+jedis.flushDB());
        System.out.println("判断某个键是否存在:"+jedis.exists("username"));
        System.out.println("新增<'username','xmr'>的键值对:"+jedis.set("username", "xmr"));
        System.out.println(jedis.exists("username"));
        System.out.println("新增<'password','password'>的键值对:"+jedis.set("password", "123"));
        System.out.print("系统中所有的键如下:");
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);
        System.out.println("删除键password:"+jedis.del("password"));
        System.out.println("判断键password是否存在:"+jedis.exists("password"));
        System.out.println("设置键username的过期时间为5s:"+jedis.expire("username", 8));
        TimeUnit.SECONDS.sleep(2);
        System.out.println("查看键username的剩余生存时间:"+jedis.ttl("username"));
        System.out.println("移除键username的生存时间:"+jedis.persist("username"));
        System.out.println("查看键username的剩余生存时间:"+jedis.ttl("username"));
        System.out.println("查看键username所存储的值的类型:"+jedis.type("username"));
    }

    输出结果:

    字符串操作

    输出结果:

    public void testString() throws InterruptedException {
        jedis.flushDB();
        System.out.println("===========增加数据===========");
        System.out.println(jedis.set("key1", "value1"));
        System.out.println(jedis.set("key2", "value2"));
        System.out.println(jedis.set("key3", "value3"));
        System.out.println("删除键key2:" + jedis.del("key2"));
        System.out.println("获取键key2:" + jedis.get("key2"));
        System.out.println("修改key1:" + jedis.set("key1", "1"));
        System.out.println("获取key1的值:" + jedis.get("key1"));
        System.out.println("在key3后面加入值:" + jedis.append("key3", "End"));
        System.out.println("key3的值:" + jedis.get("key3"));
        System.out.println("增加多个键值对:" + jedis.mset("key01", "value01", "key02", "value02", "key03", "value03"));
        System.out.println("获取多个键值对:" + jedis.mget("key01", "key02", "key03"));
        System.out.println("获取多个键值对:" + jedis.mget("key01", "key02", "key03", "key04"));
        System.out.println("删除多个键值对:" + jedis.del(new String[]{"key01", "key02"}));
        System.out.println("获取多个键值对:" + jedis.mget("key01", "key02", "key03"));
    
        jedis.flushDB();
        System.out.println("===========新增键值对,防止覆盖原先值==============");
        System.out.println(jedis.setnx("key1", "value1"));
        System.out.println(jedis.setnx("key2", "value2"));
        System.out.println(jedis.setnx("key2", "value2-new"));
        System.out.println(jedis.get("key1"));
        System.out.println(jedis.get("key2"));
    
        System.out.println("===========新增键值对并设置有效时间=============");
        System.out.println(jedis.setex("key3", 2, "value3"));
        System.out.println(jedis.get("key3"));
        TimeUnit.SECONDS.sleep(3);
        System.out.println(jedis.get("key3"));
    
        System.out.println("===========获取原值,更新为新值==========");//GETSET is an atomic set this value and return the old value command.
        System.out.println(jedis.getSet("key2", "key2GetSet"));
        System.out.println(jedis.get("key2"));
    
        System.out.println("获得key2的值的字串:" + jedis.getrange("key2", 2, 4));
    }

    输出结果:

    哈希操作

    输出结果:

    /**
     * redis操作Hash
     */
    public void testHash() {
        jedis.flushDB();
        Map<String, String> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");
        map.put("key4", "value4");
        jedis.hmset("hash", map);
        jedis.hset("hash", "key5", "value5");
        System.out.println("散列hash的所有键值对为:" + jedis.hgetAll("hash"));//return Map<String,String>
        System.out.println("散列hash的所有键为:" + jedis.hkeys("hash"));//return Set<String>
        System.out.println("散列hash的所有值为:" + jedis.hvals("hash"));//return List<String>
        System.out.println("将key6保存的值加上一个整数,如果key6不存在则添加key6:" + jedis.hincrBy("hash", "key6", 6));
        System.out.println("散列hash的所有键值对为:" + jedis.hgetAll("hash"));
        System.out.println("将key6保存的值加上一个整数,如果key6不存在则添加key6:" + jedis.hincrBy("hash", "key6", 3));
        System.out.println("散列hash的所有键值对为:" + jedis.hgetAll("hash"));
        System.out.println("删除一个或者多个键值对:" + jedis.hdel("hash", "key2"));
        System.out.println("散列hash的所有键值对为:" + jedis.hgetAll("hash"));
        System.out.println("散列hash中键值对的个数:" + jedis.hlen("hash"));
        System.out.println("判断hash中是否存在key2:" + jedis.hexists("hash", "key2"));
        System.out.println("判断hash中是否存在key3:" + jedis.hexists("hash", "key3"));
        System.out.println("获取hash中的值:" + jedis.hmget("hash", "key3"));
        System.out.println("获取hash中的值:" + jedis.hmget("hash", "key3", "key4"));
    }

    输出结果:

    列表操作

    代码如下
     

    public void testList() {
        jedis.flushDB();
        System.out.println("===========添加一个list===========");
        jedis.lpush("lists", "ArrayList", "Vector", "Stack", "HashMap", "WeakHashMap", "LinkedHashMap");
        jedis.lpush("lists", "HashSet");
        jedis.lpush("lists", "TreeSet");
        jedis.lpush("lists", "TreeMap");
        System.out.println("lists的内容:" + jedis.lrange("lists", 0, -1));//-1代表倒数第一个元素,-2代表倒数第二个元素
        System.out.println("lists区间0-3的元素:" + jedis.lrange("lists", 0, 3));
        System.out.println("===============================");
        // 删除列表指定的值 ,第二个参数为删除的个数(有重复时),后add进去的值先被删,类似于出栈
        System.out.println("删除指定元素个数:" + jedis.lrem("lists", 2, "HashMap"));
        System.out.println("lists的内容:" + jedis.lrange("lists", 0, -1));
        System.out.println("删除下表0-3区间之外的元素:" + jedis.ltrim("lists", 0, 3));
        System.out.println("lists的内容:" + jedis.lrange("lists", 0, -1));
        System.out.println("lists列表出栈(左端):" + jedis.lpop("lists"));
        System.out.println("lists的内容:" + jedis.lrange("lists", 0, -1));
        System.out.println("lists添加元素,从列表右端,与lpush相对应:" + jedis.rpush("lists", "EnumMap"));
        System.out.println("lists的内容:" + jedis.lrange("lists", 0, -1));
        System.out.println("lists列表出栈(右端):" + jedis.rpop("lists"));
        System.out.println("lists的内容:" + jedis.lrange("lists", 0, -1));
        System.out.println("修改lists指定下标1的内容:" + jedis.lset("lists", 1, "LinkedArrayList"));
        System.out.println("lists的内容:" + jedis.lrange("lists", 0, -1));
        System.out.println("===============================");
        System.out.println("lists的长度:" + jedis.llen("lists"));
        System.out.println("获取lists下标为2的元素:" + jedis.lindex("lists", 2));
        System.out.println("===============================");
        jedis.lpush("sortedList", "3", "6", "2", "0", "7", "4");
        System.out.println("sortedList排序前:" + jedis.lrange("sortedList", 0, -1));
        System.out.println(jedis.sort("sortedList"));
        System.out.println("sortedList排序后:" + jedis.lrange("sortedList", 0, -1));
    }

    输出结果:

    集合(Set)操作

    public void testSet() {
        jedis.flushDB();
        System.out.println("============向集合中添加元素============");
        System.out.println(jedis.sadd("eleSet", "e1", "e2", "e4", "e3", "e0", "e8", "e7", "e5"));
        System.out.println(jedis.sadd("eleSet", "e6"));
        System.out.println("eleSet的所有元素为:" + jedis.smembers("eleSet"));
        System.out.println("删除一个元素e0:" + jedis.srem("eleSet", "e0"));
        System.out.println("eleSet的所有元素为:" + jedis.smembers("eleSet"));
        System.out.println("删除两个元素e7和e6:" + jedis.srem("eleSet", "e7", "e6"));
        System.out.println("eleSet的所有元素为:" + jedis.smembers("eleSet"));
        System.out.println("随机的移除集合中的一个元素:" + jedis.spop("eleSet"));
        System.out.println("eleSet的所有元素为:" + jedis.smembers("eleSet"));
        System.out.println("eleSet中包含元素的个数:" + jedis.scard("eleSet"));
        System.out.println("e1是否在eleSet中:" + jedis.sismember("eleSet", "e1"));
        System.out.println("=================================");
        System.out.println(jedis.sadd("eleSet1", "e1", "e2", "e4", "e3", "e0", "e8", "e7", "e5"));
        System.out.println(jedis.sadd("eleSet2", "e1", "e2", "e4", "e3", "e0", "e8"));
        System.out.println("将eleSet1中删除e1并存入eleSet3中:" + jedis.smove("eleSet1", "eleSet3", "e1"));
        System.out.println("eleSet1中的元素:" + jedis.smembers("eleSet1"));
        System.out.println("eleSet3中的元素:" + jedis.smembers("eleSet3"));
        System.out.println("============集合运算=================");
        System.out.println("eleSet1中的元素:" + jedis.smembers("eleSet1"));
        System.out.println("eleSet2中的元素:" + jedis.smembers("eleSet2"));
        System.out.println("eleSet1和eleSet2的交集:" + jedis.sinter("eleSet1", "eleSet2"));
        System.out.println("eleSet1和eleSet2的并集:" + jedis.sunion("eleSet1", "eleSet2"));
        System.out.println("eleSet1和eleSet2的差集:" + jedis.sdiff("eleSet1", "eleSet2"));//eleSet1中有,eleSet2中没有
    }

    输出结果:

    ============向集合中添加元素============
    
    8
    
    1
    
    eleSet的所有元素为:[e0, e5, e3, e8, e7, e2, e1, e4, e6]
    
    删除一个元素e0:1
    
    eleSet的所有元素为:[e5, e3, e8, e7, e2, e1, e4, e6]
    
    删除两个元素e7和e6:2
    
    eleSet的所有元素为:[e1, e4, e3, e5, e2, e8]
    
    随机的移除集合中的一个元素:e1
    
    eleSet的所有元素为:[e3, e5, e2, e8, e4]
    
    eleSet中包含元素的个数:5
    
    e1是否在eleSet中:false
    
    =================================
    
    8
    
    6
    
    将eleSet1中删除e1并存入eleSet3中:1
    
    eleSet1中的元素:[e0, e5, e3, e8, e7, e2, e4]
    
    eleSet3中的元素:[e1]
    
    ============集合运算=================
    
    eleSet1中的元素:[e0, e5, e3, e8, e7, e2, e4]
    
    eleSet2中的元素:[e3, e1, e4, e0, e8, e2]
    
    eleSet1和eleSet2的交集:[e3, e4, e0, e8, e2]
    
    eleSet1和eleSet2的并集:[e2, e1, e4, e0, e3, e5, e7, e8]
    
    eleSet1和eleSet2的差集:[e5, e7]

    有序集合

    public void testSortedSet(){
        jedis.flushDB();
        Map<String,Double> map = new HashMap<>();
        map.put("key2",1.5);
        map.put("key3",1.6);
        map.put("key4",1.9);
        System.out.println(jedis.zadd("zset", 3,"key1"));
        System.out.println(jedis.zadd("zset",map));
        System.out.println("zset中的所有元素:"+jedis.zrangeByScore("zset", 0,100));
        System.out.println("zset中key2的分值:"+jedis.zscore("zset", "key2"));
        System.out.println("zset中key2的排名:"+jedis.zrank("zset", "key2"));
        System.out.println("删除zset中的元素key3:"+jedis.zrem("zset", "key3"));
        System.out.println("zset中的所有元素:"+jedis.zrange("zset", 0, -1));
        System.out.println("zset中元素的个数:"+jedis.zcard("zset"));
        System.out.println("zset中分值在1-4之间的元素的个数:"+jedis.zcount("zset", 1, 4));
        System.out.println("key2的分值加上5:"+jedis.zincrby("zset", 5, "key2"));
        System.out.println("key3的分值加上4:"+jedis.zincrby("zset", 4, "key3"));
        System.out.println("zset中的所有元素:"+jedis.zrange("zset", 0, -1));
    }

    输出结果:

    1
    3
    zset中的所有元素:[key2, key3, key4, key1]
    zset中key2的分值:1.5
    zset中key2的排名:0
    删除zset中的元素key3:1
    zset中的所有元素:[key2, key4, key1]
    zset中元素的个数:3
    zset中分值在1-4之间的元素的个数:3
    key2的分值加上5:6.5
    key3的分值加上4:4.0
    zset中的所有元素:[key4, key1, key3, key2]

    排序sort

    public void testSort(){
        jedis.flushDB();
        jedis.lpush("collections", "ArrayList", "Vector", "Stack", "HashMap", "WeakHashMap", "LinkedHashMap");
        System.out.println("collections的内容:"+jedis.lrange("collections", 0, -1));
        SortingParams sortingParameters = new SortingParams();
        System.out.println(jedis.sort("collections",sortingParameters.alpha()));
        System.out.println("===============================");
        jedis.lpush("sortedList", "3","6","2","0","7","4");
        System.out.println("sortedList排序前:"+jedis.lrange("sortedList", 0, -1));
        System.out.println("升序:"+jedis.sort("sortedList", sortingParameters.asc()));
        System.out.println("升序:"+jedis.sort("sortedList", sortingParameters.desc()));
        System.out.println("===============================");
        jedis.lpush("userlist", "33");
        jedis.lpush("userlist", "22");
        jedis.lpush("userlist", "55");
        jedis.lpush("userlist", "11");
        jedis.hset("user:66", "name", "66");
        jedis.hset("user:55", "name", "55");
        jedis.hset("user:33", "name", "33");
        jedis.hset("user:22", "name", "79");
        jedis.hset("user:11", "name", "24");
        jedis.hset("user:11", "add", "beijing");
        jedis.hset("user:22", "add", "shanghai");
        jedis.hset("user:33", "add", "guangzhou");
        jedis.hset("user:55", "add", "chongqing");
        jedis.hset("user:66", "add", "xi'an");
        sortingParameters = new SortingParams();
        sortingParameters.get("user:*->name");
        sortingParameters.get("user:*->add");
        System.out.println(jedis.sort("userlist",sortingParameters));
    }

    输出结果:

    collections的内容:[LinkedHashMap, WeakHashMap, HashMap, Stack, Vector, ArrayList]
    [ArrayList, HashMap, LinkedHashMap, Stack, Vector, WeakHashMap]
    ===============================
    sortedList排序前:[4, 7, 0, 2, 6, 3]
    升序:[0, 2, 3, 4, 6, 7]
    升序:[7, 6, 4, 3, 2, 0]
    ===============================
    [24, beijing, 79, shanghai, 33, guangzhou, 55, chongqing]
    

    JedisPool应用

    虽然我们可以简单地创建Jedis使用,但每次操作的时候,都建立连接,很耗费性能。解决方法就是从一个连接池中取出连接对象,用完还回去。使用连接池的方案还能解决很多同步性问题。在Jedis中,管理Redis连接的类是JedisPool。要想使用JedisPool需要添加jar包或依赖库,在pom.xml中添加

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.4.2</version>
    </dependency>
    • 普通连接池连接

    实现方式有两种,一种是通过配置文件(properties文件),我的文件名是jedisPool.properties:

    #最大分配的对象数
    
    redis.pool.maxTotal=1024
    
    #最大能够保持idel状态的对象数
    
    redis.pool.maxIdle=200
    
    #当池内没有返回对象时,最大等待时间
    
    redis.pool.maxWait=1000
    
    #当调用borrow Object方法时,是否进行有效性检查
    
    redis.pool.testOnBorrow=true
    
    #当调用return Object方法时,是否进行有效性检查
    
    redis.pool.testOnReturn=true
    
    #IP
    
    redis.ip=172.24.4.183
    
    #Port
    
    redis.port=6379
    
    

    java类如下:

    public class JedisUtil {
        private static Jedis jedis;
        private static JedisPool jedisPool = null;
        /**
         * 初始化Redis连接池
         */
        static {
            ResourceBundle bundle = ResourceBundle.getBundle("jedisPool");
            if (bundle == null) {
                throw new IllegalArgumentException(
                        "[jedisPool.properties] is not found!");
            }
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(Integer.valueOf(bundle
                    .getString("redis.pool.maxTotal")));
            config.setMaxIdle(Integer.valueOf(bundle
                    .getString("redis.pool.maxIdle")));
            config.setMaxWaitMillis(Long.valueOf(bundle.getString("redis.pool.maxWait")));
            config.setTestOnBorrow(Boolean.valueOf(bundle
                    .getString("redis.pool.testOnBorrow")));
            config.setTestOnReturn(Boolean.valueOf(bundle
                    .getString("redis.pool.testOnReturn")));
            jedisPool = new JedisPool(config, bundle.getString("redis.ip"),
                    Integer.valueOf(bundle.getString("redis.port")));
            // 从池中获取一个Jedis对象
             jedis = jedisPool .getResource();
        }
        public void add(String sn) {
            jedis.sadd("snSet", sn);
            jedisPool.destroy();
        }
        public void remove(String sn) {
            jedis.srem("snSet", sn);
        }
        public boolean isExist(String sn) {
            Set<String> snSet = jedis.smembers("snSet");
            return snSet.contains(sn);
        }
        public static void main(String[] args) {
            String keys = "name";
    // 删数据
            jedis.del(keys);
    // 存数据
            jedis.set(keys, "snowolf");
    // 取数据
            String value = jedis.get(keys);
            System.out.println(value);
    // 释放对象池
    //        jedisPool.returnResource(jedis);
        }
    }

    而直接通过代码实现的话,其实也是一个原理:

    public class JedisUtil1 {
    private static JedisUtil1 instance = null;
    private Jedis jedis;
    private static JedisPool jedisPool = null;
    //Redis服务器IP
    private static String HOST = "172.24.4.183";
    //Redis的端口号
    private static int PORT = 6379;
    //可用连接实例的最大数目,默认值为8;
    //如果赋值为-1,则表示不限制;如果pool已经分配了maxActive个jedis实例,则此时pool的状态为exhausted(耗尽)。
    private static int MAX_ACTIVE = 1024;
    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例,默认值也是8。
    private static int MAX_IDLE = 200;
    private static int TIMEOUT = 10000;
    //在borrow一个jedis实例时,是否提前进行validate操作;如果为true,则得到的jedis实例均是可用的;
    private static boolean TEST_ON_BORROW = true;
    /**
     * 初始化Redis连接池
     */
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWaitMillis(TIMEOUT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            jedisPool = new JedisPool(config, HOST, PORT);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    • Sentinel连接池连接

    Sentinel连接池用于应对Redis的Sentinel的主从切换机制,能够正确在服务器宕机导致服务器切换时得到正确的服务器连接,当服务器采用该部署策略的时候推荐使用该连接池进行操作

    private static Jedis jedis;
    private static JedisSentinelPool jedisSentinelPool = null;
    
    /**
     * 初始化Redis连接池
     */
    static {
        ResourceBundle bundle = ResourceBundle.getBundle("jedisSentinePool");
        if (bundle == null) {
            throw new IllegalArgumentException(
                    "[jedisSentinePool.properties] is not found!");
        }
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(Integer.valueOf(bundle
                .getString("redis.pool.maxTotal")));
        config.setMaxIdle(Integer.valueOf(bundle
                .getString("redis.pool.maxIdle")));
        config.setMaxWaitMillis(Long.valueOf(bundle.getString("redis.pool.maxWait")));
        config.setTestOnBorrow(Boolean.valueOf(bundle
                .getString("redis.pool.testOnBorrow")));
        config.setTestOnReturn(Boolean.valueOf(bundle
                .getString("redis.pool.testOnReturn")));
        //监听器列表
        Set<String> sentinels = new HashSet<>();
        /**
         *
         //监听器1
         sentinels.add(new HostAndPort("172.24.4.183", 26379).toString());
         //监听器2
         sentinels.add(new HostAndPort("172.24.4.184", 26379).toString());
         //实际使用的时候在properties里配置即可:redis.sentinel.hostandports=172.24.4.183:26379, 172.24.4.184:26379
         //然后使用 bundle.getString("redis.sentinel.hostandports");获取地址
         */
        //mastername是服务器上的master的名字,在master服务器的sentinel.conf中配置
        String masterName = bundle.getString("redis.sentinel.masterName");
        sentinels.add(bundle.getString("redis.sentinel.hostandports"));
        //初始化连接池
        jedisSentinelPool = new JedisSentinelPool(masterName,
                sentinels, config);
        // 从池中获取一个Jedis对象
        jedis = jedisSentinelPool.getResource();
    }
    • ShardedJedisPool连接池分片连接

    Memcached完全基于分布式集群,而Redis是Master-Slave,Redis在容灾处理方面可以通过服务器端配置Master-Slave模式来实现。如果想把Reids做成集群模式,无外乎多做几套Master-Slave,每套Master-Slave完成各自的容灾处理,通过Client工具来实现一致性哈希分布存储,即key分片存储。

    shared一致性哈希采用以下方案:

    1. Redis服务器节点划分:将每台服务器节点采用hash算法划分为160个虚拟节点(可以配置划分权重)
    2. 将划分虚拟节点采用TreeMap存储
    3. 对每个Redis服务器的物理连接采用LinkedHashMap存储
    4. 对Key or KeyTag 采用同样的hash算法,然后从TreeMap获取大于等于键hash值得节点,取最邻近节点存储;当key的hash值大于虚拟节点hash值得最大值时,存入第一个虚拟节点

    sharded采用的hash算法:MD5 和 MurmurHash两种;默认采用64位的MurmurHash算法;有兴趣的可以研究下~

    保留前面的JedisPoolConfig,新增两个Redis的IP(redis1.ip,redis2.ip),完成两个JedisShardInfo实例,并将其丢进List中:

    private static ShardedJedis jedis;
    private static ShardedJedisPool shardedJedisPool = null;
    /**
     * 初始化Redis连接池
     */
    static {
        ResourceBundle bundle = ResourceBundle.getBundle("sharedJedisPool");
        if (bundle == null) {
            throw new IllegalArgumentException(
                    "[jedisPool.properties] is not found!");
        }
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(Integer.valueOf(bundle
                .getString("redis.pool.maxTotal")));
        config.setMaxIdle(Integer.valueOf(bundle
                .getString("redis.pool.maxIdle")));
        config.setMaxWaitMillis(Long.valueOf(bundle.getString("redis.pool.maxWait")));
        config.setTestOnBorrow(Boolean.valueOf(bundle
                .getString("redis.pool.testOnBorrow")));
        config.setTestOnReturn(Boolean.valueOf(bundle
                .getString("redis.pool.testOnReturn")));
        JedisShardInfo jedisShardInfo1 = new JedisShardInfo(
                bundle.getString("redis1.ip"), Integer.valueOf(bundle.getString("redis.port")));
        JedisShardInfo jedisShardInfo2 = new JedisShardInfo(
                bundle.getString("redis2.ip"), Integer.valueOf(bundle.getString("redis.port")));
        List<JedisShardInfo> list = new LinkedList<>();
        list.add(jedisShardInfo1);
        list.add(jedisShardInfo2);
        shardedJedisPool = new ShardedJedisPool(config,list);
        // 从池中获取一个Jedis对象
        jedis = shardedJedisPool.getResource();
    }

     

    参考:

    http://www.boyunjian.com/javadoc/org.apache.servicemix.bundles/org.apache.servicemix.bundles.jedis/2.1.0_1/_/redis/clients/jedis/JedisShardInfo.html

    https://yq.aliyun.com/articles/236384

    http://blog.csdn.net/dslztx/article/details/46743053

    http://flyingsnail.blog.51cto.com/5341669/1371650

    http://www.tuicool.com/articles/vaqABb

    http://www.importnew.com/19321.html

    http://www.cnblogs.com/liuling/p/2014-4-19-04.html

    http://www.cnblogs.com/libaoting/p/4418007.html

    http://blog.csdn.net/fachang/article/details/7984123

    http://blog.csdn.net/aubdiy/article/details/53511410

    http://blog.csdn.net/moxiaomomo/article/details/17588483

     

    展开全文
  • java Jedis使用示例

    千次阅读 2016-05-15 21:34:08
    * 在不同的线程中使用相同的Jedis实例会发生奇怪的错误。但是创建太多的实现也不好因为这意味着会建立很多sokcet连接, * 也会导致奇怪的错误发生。单一Jedis实例不是线程安全的。为了避免这些问题,可以使用...
    import java.util.Date;  
    import java.util.HashMap;  
    import java.util.Iterator;  
    import java.util.List;  
    import java.util.Map;  
    import java.util.Set;  
      
    import org.junit.Test;  
      
    import redis.clients.jedis.Jedis;  
    import redis.clients.jedis.Pipeline;  
    import redis.clients.jedis.SortingParams;  
      
    import com.wujintao.redis.util.RedisUtil;  
      
      
    public class TestCase {  
      
        /** 
         * 在不同的线程中使用相同的Jedis实例会发生奇怪的错误。但是创建太多的实现也不好因为这意味着会建立很多sokcet连接, 
         * 也会导致奇怪的错误发生。单一Jedis实例不是线程安全的。为了避免这些问题,可以使用JedisPool, 
         * JedisPool是一个线程安全的网络连接池。可以用JedisPool创建一些可靠Jedis实例,可以从池中拿到Jedis的实例。 
         * 这种方式可以解决那些问题并且会实现高效的性能 
         */  
      
        public static void main(String[] args) {  
      
            // ...when closing your application:  
            RedisUtil.getPool().destroy();  
      
        }  
      
        public static void Hello() {  
            Jedis jedis = RedisUtil.getJedis();  
            try {  
                // 向key-->name中放入了value-->minxr  
                jedis.set("name", "minxr");  
                String ss = jedis.get("name");  
                System.out.println(ss);  
      
                // 很直观,类似map 将jintao append到已经有的value之后  
                jedis.append("name", "jintao");  
                ss = jedis.get("name");  
                System.out.println(ss);  
      
                // 2、直接覆盖原来的数据  
                jedis.set("name", "jintao");  
                System.out.println(jedis.get("jintao"));  
      
                // 删除key对应的记录  
                jedis.del("name");  
                System.out.println(jedis.get("name"));// 执行结果:null  
      
                /** 
                 * mset相当于 jedis.set("name","minxr"); jedis.set("jarorwar","aaa"); 
                 */  
                jedis.mset("name", "minxr", "jarorwar", "aaa");  
                System.out.println(jedis.mget("name", "jarorwar"));  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                RedisUtil.getPool().returnResource(jedis);  
            }  
      
        }  
      
        private void testKey() {  
            Jedis jedis = RedisUtil.getJedis();  
            System.out.println("=============key==========================");  
            // 清空数据  
            System.out.println(jedis.flushDB());  
            System.out.println(jedis.echo("foo"));  
            // 判断key否存在  
            System.out.println(jedis.exists("foo"));  
            jedis.set("key", "values");  
            System.out.println(jedis.exists("key"));  
        }  
      
        public static void testString() {  
            System.out.println("==String==");  
            Jedis jedis = RedisUtil.getJedis();  
            try {  
                // String  
                jedis.set("key", "Hello World!");  
                String value = jedis.get("key");  
                System.out.println(value);  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                RedisUtil.getPool().returnResource(jedis);  
            }  
      
            System.out.println("=============String==========================");  
            // 清空数据  
            System.out.println(jedis.flushDB());  
            // 存储数据  
            jedis.set("foo", "bar");  
            System.out.println(jedis.get("foo"));  
            // 若key不存在,则存储  
            jedis.setnx("foo", "foo not exits");  
            System.out.println(jedis.get("foo"));  
            // 覆盖数据  
            jedis.set("foo", "foo update");  
            System.out.println(jedis.get("foo"));  
            // 追加数据  
            jedis.append("foo", " hello, world");  
            System.out.println(jedis.get("foo"));  
            // 设置key的有效期,并存储数据  
            jedis.setex("foo", 2, "foo not exits");  
            System.out.println(jedis.get("foo"));  
            try {  
                Thread.sleep(3000);  
            } catch (InterruptedException e) {  
            }  
            System.out.println(jedis.get("foo"));  
            // 获取并更改数据  
            jedis.set("foo", "foo update");  
            System.out.println(jedis.getSet("foo", "foo modify"));  
            // 截取value的值  
            System.out.println(jedis.getrange("foo", 1, 3));  
            System.out.println(jedis.mset("mset1", "mvalue1", "mset2", "mvalue2",  
                    "mset3", "mvalue3", "mset4", "mvalue4"));  
            System.out.println(jedis.mget("mset1", "mset2", "mset3", "mset4"));  
            System.out.println(jedis.del(new String[] { "foo", "foo1", "foo3" }));  
        }  
      
        public static void testList() {  
            System.out.println("==List==");  
            Jedis jedis = RedisUtil.getJedis();  
            try {  
                // 开始前,先移除所有的内容  
                jedis.del("messages");  
                jedis.rpush("messages", "Hello how are you?");  
                jedis.rpush("messages", "Fine thanks. I'm having fun with redis.");  
                jedis.rpush("messages", "I should look into this NOSQL thing ASAP");  
      
                // 再取出所有数据jedis.lrange是按范围取出,  
                // 第一个是key,第二个是起始位置,第三个是结束位置,jedis.llen获取长度 -1表示取得所有  
                List<String> values = jedis.lrange("messages", 0, -1);  
                System.out.println(values);  
      
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                RedisUtil.getPool().returnResource(jedis);  
            }  
      
            // 清空数据  
            System.out.println(jedis.flushDB());  
            // 添加数据  
            jedis.lpush("lists", "vector");  
            jedis.lpush("lists", "ArrayList");  
            jedis.lpush("lists", "LinkedList");  
            // 数组长度  
            System.out.println(jedis.llen("lists"));  
            // 排序  
            System.out.println(jedis.sort("lists"));  
            // 字串  
            System.out.println(jedis.lrange("lists", 0, 3));  
            // 修改列表中单个值  
            jedis.lset("lists", 0, "hello list!");  
            // 获取列表指定下标的值  
            System.out.println(jedis.lindex("lists", 1));  
            // 删除列表指定下标的值  
            System.out.println(jedis.lrem("lists", 1, "vector"));  
            // 删除区间以外的数据  
            System.out.println(jedis.ltrim("lists", 0, 1));  
            // 列表出栈  
            System.out.println(jedis.lpop("lists"));  
            // 整个列表值  
            System.out.println(jedis.lrange("lists", 0, -1));  
        }  
      
        public static void testSet() {  
            System.out.println("==Set==");  
            Jedis jedis = RedisUtil.getJedis();  
            try {  
                jedis.sadd("myset", "1");  
                jedis.sadd("myset", "2");  
                jedis.sadd("myset", "3");  
                jedis.sadd("myset", "4");  
                Set<String> setValues = jedis.smembers("myset");  
                System.out.println(setValues);  
      
                // 移除noname  
                jedis.srem("myset", "4");  
                System.out.println(jedis.smembers("myset"));// 获取所有加入的value  
                System.out.println(jedis.sismember("myset", "4"));// 判断 minxr  
                                                                    // 是否是sname集合的元素  
                System.out.println(jedis.scard("sname"));// 返回集合的元素个数  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                RedisUtil.getPool().returnResource(jedis);  
            }  
      
            // 清空数据  
            System.out.println(jedis.flushDB());  
            // 添加数据  
            jedis.sadd("sets", "HashSet");  
            jedis.sadd("sets", "SortedSet");  
            jedis.sadd("sets", "TreeSet");  
            // 判断value是否在列表中  
            System.out.println(jedis.sismember("sets", "TreeSet"));  
            ;  
            // 整个列表值  
            System.out.println(jedis.smembers("sets"));  
            // 删除指定元素  
            System.out.println(jedis.srem("sets", "SortedSet"));  
            // 出栈  
            System.out.println(jedis.spop("sets"));  
            System.out.println(jedis.smembers("sets"));  
            //  
            jedis.sadd("sets1", "HashSet1");  
            jedis.sadd("sets1", "SortedSet1");  
            jedis.sadd("sets1", "TreeSet");  
            jedis.sadd("sets2", "HashSet2");  
            jedis.sadd("sets2", "SortedSet1");  
            jedis.sadd("sets2", "TreeSet1");  
            // 交集  
            System.out.println(jedis.sinter("sets1", "sets2"));  
            // 并集  
            System.out.println(jedis.sunion("sets1", "sets2"));  
            // 差集  
            System.out.println(jedis.sdiff("sets1", "sets2"));  
        }  
      
        public static void sortedSet() {  
            System.out.println("==SoretedSet==");  
            Jedis jedis = RedisUtil.getJedis();  
            try {  
                jedis.zadd("hackers", 1940, "Alan Kay");  
                jedis.zadd("hackers", 1953, "Richard Stallman");  
                jedis.zadd("hackers", 1965, "Yukihiro Matsumoto");  
                jedis.zadd("hackers", 1916, "Claude Shannon");  
                jedis.zadd("hackers", 1969, "Linus Torvalds");  
                jedis.zadd("hackers", 1912, "Alan Turing");  
                Set<String> setValues = jedis.zrange("hackers", 0, -1);  
                System.out.println(setValues);  
                Set<String> setValues2 = jedis.zrevrange("hackers", 0, -1);  
                System.out.println(setValues2);  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                RedisUtil.getPool().returnResource(jedis);  
            }  
      
            // 清空数据  
            System.out.println(jedis.flushDB());  
            // 添加数据  
            jedis.zadd("zset", 10.1, "hello");  
            jedis.zadd("zset", 10.0, ":");  
            jedis.zadd("zset", 9.0, "zset");  
            jedis.zadd("zset", 11.0, "zset!");  
            // 元素个数  
            System.out.println(jedis.zcard("zset"));  
            // 元素下标  
            System.out.println(jedis.zscore("zset", "zset"));  
            // 集合子集  
            System.out.println(jedis.zrange("zset", 0, -1));  
            // 删除元素  
            System.out.println(jedis.zrem("zset", "zset!"));  
            System.out.println(jedis.zcount("zset", 9.5, 10.5));  
            // 整个集合值  
            System.out.println(jedis.zrange("zset", 0, -1));  
        }  
      
        public static void testHsh() {  
            System.out.println("==Hash==");  
            Jedis jedis = RedisUtil.getJedis();  
            try {  
                Map<String, String> pairs = new HashMap<String, String>();  
                pairs.put("name", "Akshi");  
                pairs.put("age", "2");  
                pairs.put("sex", "Female");  
                jedis.hmset("kid", pairs);  
                List<String> name = jedis.hmget("kid", "name");// 结果是个泛型的LIST  
                // jedis.hdel("kid","age"); //删除map中的某个键值  
                System.out.println(jedis.hmget("kid", "pwd")); // 因为删除了,所以返回的是null  
                System.out.println(jedis.hlen("kid")); // 返回key为user的键中存放的值的个数  
                System.out.println(jedis.exists("kid"));// 是否存在key为user的记录  
                System.out.println(jedis.hkeys("kid"));// 返回map对象中的所有key  
                System.out.println(jedis.hvals("kid"));// 返回map对象中的所有value  
      
                Iterator<String> iter = jedis.hkeys("kid").iterator();  
                while (iter.hasNext()) {  
                    String key = iter.next();  
                    System.out.println(key + ":" + jedis.hmget("kid", key));  
                }  
      
                List<String> values = jedis.lrange("messages", 0, -1);  
                values = jedis.hmget("kid", new String[] { "name", "age", "sex" });  
                System.out.println(values);  
                Set<String> setValues = jedis.zrange("hackers", 0, -1);  
                setValues = jedis.hkeys("kid");  
                System.out.println(setValues);  
                values = jedis.hvals("kid");  
                System.out.println(values);  
                pairs = jedis.hgetAll("kid");  
                System.out.println(pairs);  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                RedisUtil.getPool().returnResource(jedis);  
            }  
      
            // 清空数据  
            System.out.println(jedis.flushDB());  
            // 添加数据  
            jedis.hset("hashs", "entryKey", "entryValue");  
            jedis.hset("hashs", "entryKey1", "entryValue1");  
            jedis.hset("hashs", "entryKey2", "entryValue2");  
            // 判断某个值是否存在  
            System.out.println(jedis.hexists("hashs", "entryKey"));  
            // 获取指定的值  
            System.out.println(jedis.hget("hashs", "entryKey")); // 批量获取指定的值  
            System.out.println(jedis.hmget("hashs", "entryKey", "entryKey1"));  
            // 删除指定的值  
            System.out.println(jedis.hdel("hashs", "entryKey"));  
            // 为key中的域 field 的值加上增量 increment  
            System.out.println(jedis.hincrBy("hashs", "entryKey", 123l));  
            // 获取所有的keys  
            System.out.println(jedis.hkeys("hashs"));  
            // 获取所有的values  
            System.out.println(jedis.hvals("hashs"));  
        }  
      
        public static void testOther() throws InterruptedException {  
            Jedis jedis = RedisUtil.getJedis();  
      
            try {  
                // keys中传入的可以用通配符  
                System.out.println(jedis.keys("*")); // 返回当前库中所有的key [sose, sanme,  
                                                        // name, jarorwar, foo,  
                                                        // sname, java framework,  
                                                        // user, braand]  
                System.out.println(jedis.keys("*name"));// 返回的sname [sname, name]  
                System.out.println(jedis.del("sanmdde"));// 删除key为sanmdde的对象 删除成功返回1  
                                                            // 删除失败(或者不存在)返回 0  
                System.out.println(jedis.ttl("sname"));// 返回给定key的有效时间,如果是-1则表示永远有效  
                jedis.setex("timekey", 10, "min");// 通过此方法,可以指定key的存活(有效时间) 时间为秒  
                Thread.sleep(5000);// 睡眠5秒后,剩余时间将为<=5  
                System.out.println(jedis.ttl("timekey")); // 输出结果为5  
                jedis.setex("timekey", 1, "min"); // 设为1后,下面再看剩余时间就是1了  
                System.out.println(jedis.ttl("timekey")); // 输出结果为1  
                System.out.println(jedis.exists("key"));// 检查key是否存在  
                System.out.println(jedis.rename("timekey", "time"));  
                System.out.println(jedis.get("timekey"));// 因为移除,返回为null  
                System.out.println(jedis.get("time")); // 因为将timekey 重命名为time  
                                                        // 所以可以取得值 min  
                // jedis 排序  
                // 注意,此处的rpush和lpush是List的操作。是一个双向链表(但从表现来看的)  
                jedis.del("a");// 先清除数据,再加入数据进行测试  
                jedis.rpush("a", "1");  
                jedis.lpush("a", "6");  
                jedis.lpush("a", "3");  
                jedis.lpush("a", "9");  
                System.out.println(jedis.lrange("a", 0, -1));// [9, 3, 6, 1]  
                System.out.println(jedis.sort("a")); // [1, 3, 6, 9] //输入排序后结果  
                System.out.println(jedis.lrange("a", 0, -1));  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                RedisUtil.getPool().returnResource(jedis);  
            }  
      
        }  
      
        @org.junit.Test  
        public void testUnUsePipeline() {  
            long start = new Date().getTime();  
      
            Jedis jedis = RedisUtil.getJedis();  
            for (int i = 0; i < 10000; i++) {  
                jedis.set("age1" + i, i + "");  
                jedis.get("age1" + i);// 每个操作都发送请求给redis-server  
            }  
            long end = new Date().getTime();  
      
            System.out.println("unuse pipeline cost:" + (end - start) + "ms");  
      
            RedisUtil.getPool().returnResource(jedis);  
        }  
      
        @org.junit.Test  
        /** 
         * 参考:http://blog.csdn.net/freebird_lb/article/details/7778919 
         */  
        public void testUsePipeline() {  
            long start = new Date().getTime();  
      
            Jedis jedis = RedisUtil.getJedis();  
            jedis.flushDB();  
            Pipeline p = jedis.pipelined();  
            for (int i = 0; i < 10000; i++) {  
                p.set("age2" + i, i + "");  
                System.out.println(p.get("age2" + i));  
            }  
            p.sync();// 这段代码获取所有的response  
      
            long end = new Date().getTime();  
      
            System.out.println("use pipeline cost:" + (end - start) + "ms");  
      
            RedisUtil.getPool().returnResource(jedis);  
        }  
      
      
        @org.junit.Test  
        /** 
         * 时间复杂度: 
              O(N+M*log(M)), N 为要排序的列表或集合内的元素数量, M 为要返回的元素数量。 
                如果只是使用 SORT 命令的 GET 选项获取数据而没有进行排序,时间复杂度 O(N)。 
         */  
        public void testSort1() {  
            // 排序默认以数字作为对象,值被解释为双精度浮点数,然后进行比较  
            Jedis redis = RedisUtil.getJedis();  
            // 一般SORT用法 最简单的SORT使用方法是SORT key。  
            redis.lpush("mylist", "1");  
            redis.lpush("mylist", "4");  
            redis.lpush("mylist", "6");  
            redis.lpush("mylist", "3");  
            redis.lpush("mylist", "0");  
            // List<String> list = redis.sort("sort");// 默认是升序  
            SortingParams sortingParameters = new SortingParams();  
            sortingParameters.desc();  
            // sortingParameters.alpha();//当数据集中保存的是字符串值时,你可以用 ALPHA  
            // 修饰符(modifier)进行排序。  
            sortingParameters.limit(0, 2);// 可用于分页查询  
            List<String> list = redis.sort("mylist", sortingParameters);// 默认是升序  
            for (int i = 0; i < list.size(); i++) {  
                System.out.println(list.get(i));  
            }  
            redis.flushDB();  
            RedisUtil.closeJedis(redis);  
        }  
      
        @org.junit.Test  
        /** 
         * sort list 
         * LIST结合hash的排序 
         */  
        public void testSort2() {  
            Jedis jedis = RedisUtil.getJedis();  
            jedis.del("user:66", "user:55", "user:33", "user:22", "user:11",  
                    "userlist");  
            jedis.lpush("userlist", "33");  
            jedis.lpush("userlist", "22");  
            jedis.lpush("userlist", "55");  
            jedis.lpush("userlist", "11");  
      
            jedis.hset("user:66", "name", "66");  
            jedis.hset("user:55", "name", "55");  
            jedis.hset("user:33", "name", "33");  
            jedis.hset("user:22", "name", "79");  
            jedis.hset("user:11", "name", "24");  
            jedis.hset("user:11", "add", "beijing");  
            jedis.hset("user:22", "add", "shanghai");  
            jedis.hset("user:33", "add", "guangzhou");  
            jedis.hset("user:55", "add", "chongqing");  
            jedis.hset("user:66", "add", "xi'an");  
      
            SortingParams sortingParameters = new SortingParams();  
            // 符号 "->" 用于分割哈希表的键名(key name)和索引域(hash field),格式为 "key->field" 。  
            sortingParameters.get("user:*->name");  
            sortingParameters.get("user:*->add");  
    //      sortingParameters.by("user:*->name");  
    //      sortingParameters.get("#");  
            List<String> result = jedis.sort("userlist", sortingParameters);  
            for (String item : result) {  
                System.out.println("item...." + item);  
            }  
            /** 
             * 对应的redis客户端命令是:sort ml get user*->name sort ml get user:*->name get 
             * user:*->add 
             */  
        }  
      
        @org.junit.Test  
        /** 
         * sort set 
         * SET结合String的排序 
         */  
        public void testSort3() {  
            Jedis jedis = RedisUtil.getJedis();  
            jedis.del("tom:friend:list", "score:uid:123", "score:uid:456",  
                    "score:uid:789", "score:uid:101", "uid:123", "uid:456",  
                    "uid:789", "uid:101");  
      
            jedis.sadd("tom:friend:list", "123"); // tom的好友列表  
            jedis.sadd("tom:friend:list", "456");  
            jedis.sadd("tom:friend:list", "789");  
            jedis.sadd("tom:friend:list", "101");  
      
            jedis.set("score:uid:123", "1000"); // 好友对应的成绩  
            jedis.set("score:uid:456", "6000");  
            jedis.set("score:uid:789", "100");  
            jedis.set("score:uid:101", "5999");  
      
            jedis.set("uid:123", "{'uid':123,'name':'lucy'}"); // 好友的详细信息  
            jedis.set("uid:456", "{'uid':456,'name':'jack'}");  
            jedis.set("uid:789", "{'uid':789,'name':'jay'}");  
            jedis.set("uid:101", "{'uid':101,'name':'jolin'}");  
      
            SortingParams sortingParameters = new SortingParams();  
      
            sortingParameters.desc();  
            // sortingParameters.limit(0, 2);  
            // 注意GET操作是有序的,GET user_name_* GET user_password_*  
            // 和 GET user_password_* GET user_name_*返回的结果位置不同  
            sortingParameters.get("#");// GET 还有一个特殊的规则—— "GET #"  
                                        // ,用于获取被排序对象(我们这里的例子是 user_id )的当前元素。  
            sortingParameters.get("uid:*");  
            sortingParameters.get("score:uid:*");  
            sortingParameters.by("score:uid:*");  
            // 对应的redis 命令是./redis-cli sort tom:friend:list by score:uid:* get # get  
            // uid:* get score:uid:*  
            List<String> result = jedis.sort("tom:friend:list", sortingParameters);  
            for (String item : result) {  
                System.out.println("item..." + item);  
            }  
      
        }  
      
        /** 
         *  
         * 只获取对象而不排序 BY 修饰符可以将一个不存在的 key 当作权重,让 SORT 跳过排序操作。 
         * 该方法用于你希望获取外部对象而又不希望引起排序开销时使用。 # 确保fake_key不存在 redis> EXISTS fake_key 
         * (integer) 0 # 以fake_key作BY参数,不排序,只GET name 和 GET password redis> SORT 
         * user_id BY fake_key GET # GET user_name_* GET user_password_* 1) "222" # 
         * id 2) "hacker" # user_name 3) "hey,im in" # password 4) "59230" 5) "jack" 
         * 6) "jack201022" 7) "2" 8) "huangz" 9) "nobodyknows" 10) "1" 11) "admin" 
         * 12) "a_long_long_password" 
         */  
        public void testSort4() {  
      
        }  
      
        /** 
         *  
         保存排序结果 默认情况下, SORT 操作只是简单地返回排序结果,如果你希望保存排序结果,可以给 STORE 选项指定一个 key 
         * 作为参数,排序结果将以列表的形式被保存到这个 key 上。(若指定 key 已存在,则覆盖。) redis> EXISTS 
         * user_info_sorted_by_level # 确保指定key不存在 (integer) 0 redis> SORT user_id BY 
         * user_level_* GET # GET user_name_* GET user_password_* STORE 
         * user_info_sorted_by_level # 排序 (integer) 12 # 显示有12条结果被保存了 redis> LRANGE 
         * user_info_sorted_by_level 0 11 # 查看排序结果 1) "59230" 2) "jack" 3) 
         * "jack201022" 4) "2" 5) "huangz" 6) "nobodyknows" 7) "222" 8) "hacker" 9) 
         * "hey,im in" 10) "1" 11) "admin" 12) "a_long_long_password" 一个有趣的用法是将 SORT 
         * 结果保存,用 EXPIRE 为结果集设置生存时间,这样结果集就成了 SORT 操作的一个缓存。 这样就不必频繁地调用 SORT 
         * 操作了,只有当结果集过期时,才需要再调用一次 SORT 操作。 
         * 有时候为了正确实现这一用法,你可能需要加锁以避免多个客户端同时进行缓存重建(也就是多个客户端,同一时间进行 SORT 
         * 操作,并保存为结果集),具体参见 SETNX 命令。 
         */  
        @Test  
        public void testSort5() {  
            // 排序默认以数字作为对象,值被解释为双精度浮点数,然后进行比较  
            Jedis jedis = RedisUtil.getJedis();  
            // 一般SORT用法 最简单的SORT使用方法是SORT key。  
            jedis.lpush("mylist", "1");  
            jedis.lpush("mylist", "4");  
            jedis.lpush("mylist", "6");  
            jedis.lpush("mylist", "3");  
            jedis.lpush("mylist", "0");  
            // List<String> list = redis.sort("sort");// 默认是升序  
            SortingParams sortingParameters = new SortingParams();  
            sortingParameters.desc();  
            // sortingParameters.alpha();//当数据集中保存的是字符串值时,你可以用 ALPHA  
            // 修饰符(modifier)进行排序。  
            // sortingParameters.limit(0, 2);//可用于分页查询  
      
            // 没有使用 STORE 参数,返回列表形式的排序结果. 使用 STORE 参数,返回排序结果的元素数量。  
      
            jedis.sort("mylist", sortingParameters, "mylist");// 排序后指定排序结果到一个KEY中,这里讲结果覆盖原来的KEY  
      
            List<String> list = jedis.lrange("mylist", 0, -1);  
            for (int i = 0; i < list.size(); i++) {  
                System.out.println(list.get(i));  
            }  
      
            jedis.sadd("tom:friend:list", "123"); // tom的好友列表  
            jedis.sadd("tom:friend:list", "456");  
            jedis.sadd("tom:friend:list", "789");  
            jedis.sadd("tom:friend:list", "101");  
      
            jedis.set("score:uid:123", "1000"); // 好友对应的成绩  
            jedis.set("score:uid:456", "6000");  
            jedis.set("score:uid:789", "100");  
            jedis.set("score:uid:101", "5999");  
      
            jedis.set("uid:123", "{'uid':123,'name':'lucy'}"); // 好友的详细信息  
            jedis.set("uid:456", "{'uid':456,'name':'jack'}");  
            jedis.set("uid:789", "{'uid':789,'name':'jay'}");  
            jedis.set("uid:101", "{'uid':101,'name':'jolin'}");  
      
            sortingParameters = new SortingParams();  
            // sortingParameters.desc();  
            sortingParameters.get("#");// GET 还有一个特殊的规则—— "GET #"  
                                        // ,用于获取被排序对象(我们这里的例子是 user_id )的当前元素。  
            sortingParameters.by("score:uid:*");  
            jedis.sort("tom:friend:list", sortingParameters, "tom:friend:list");  
            List<String> result = jedis.lrange("tom:friend:list", 0, -1);  
            for (String item : result) {  
                System.out.println("item..." + item);  
            }  
      
            jedis.flushDB();  
            RedisUtil.closeJedis(jedis);  
        }  
          
          
        public void testMore(){  
            //ZRANGE取出最新的10个项目。  
            //使用LPUSH + LTRIM,确保只取出最新的1000条项目。  
            //HINCRBY key field increment,为哈希表 key 中的域 field 的值加上增量 increment  
            //INCRBY,HINCRBY等等,redis有了原子递增(atomic increment),你可以放心的加上各种计数,用GETSET重置,或者是让它们过期。  
            // LREM greet 2 morning     # 移除从表头到表尾,最先发现的两个 morning,这个可以用来删除特定评论  
            // zrevrank test a 查看a在sorted set中倒排序时排在第几名,查询结果按照INDEX,所以INDEX是3表示排在第四名  
            // zrank test a 相反,表示正排序时候的名次  
            // zscore test one表示one这个元素在sorted set中的score为多少  
            // zrevrange test 0 -1 表示sorted set倒排序,zrange test 0 -1表示正排序  
            //将一个或多个 member 元素及其 score 值加入到有序集 key 当中。如果某个 member 已经是有序集的成员,那么更新这个 member 的 score 值,并通过重新插入这个 member 元素,来保证该 member 在正确的位置上。  
            //zrem test one删除sorted set中某个元素  
        }  
          
        public List<String> get_latest_comments(int start, int num_items){  
            //获取最新评论  
            //LPUSH latest.comments <ID>   
            //-我们将列表裁剪为指定长度,因此Redis只需要保存最新的5000条评论:  
            //LTRIM latest.comments 0 5000   
            //们做了限制不能超过5000个ID,因此我们的获取ID函数会一直询问Redis。只有在start/count参数超出了这个范围的时候,才需要去访问数据库。  
            Jedis jedis = RedisUtil.getJedis();  
            List<String> id_list = jedis.lrange("latest.comments",start,start+num_items-1) ;  
              
            if(id_list.size()<num_items){  
                //id_list = SQL.EXECUTE("SELECT ... ORDER BY time LIMIT ...");  
            }  
            return id_list;  
        }  
                 
          
      
        @Test  
        public void testDB() {  
            Jedis jedis = RedisUtil.getJedis();  
            System.out.println(jedis.select(0));// select db-index  
                                                // 通过索引选择数据库,默认连接的数据库所有是0,默认数据库数是16个。返回1表示成功,0失败  
            System.out.println(jedis.dbSize());// dbsize 返回当前数据库的key数量  
            System.out.println(jedis.keys("*")); // 返回匹配指定模式的所有key  
            System.out.println(jedis.randomKey());  
            jedis.flushDB();// 删除当前数据库中所有key,此方法不会失败。慎用  
            jedis.flushAll();// 删除所有数据库中的所有key,此方法不会失败。更加慎用  
      
        }  
      
        @Test  
        public void testMget() {  
      
            Jedis jedis = RedisUtil.getJedis();  
            jedis.flushDB();// 删除当前数据库中所有key,此方法不会失败。慎用  
      
            jedis.rpush("ids", "aa");  
            jedis.rpush("ids", "bb");  
            jedis.rpush("ids", "cc");  
      
            List<String> ids = jedis.lrange("ids", 0, -1);  
      
            jedis.set("aa", "{'name':'zhoujie','age':20}");  
            jedis.set("bb", "{'name':'yilin','age':28}");  
            jedis.set("cc", "{'name':'lucy','age':21}");  
            List<String> list = jedis.mget(ids.toArray(new String[ids.size()]));  
            System.out.println(list);  
        }  
      
        /** 
         * 可以利用lrange对list进行分页操作 
         */  
        @Test  
        public void queryPageBy() {  
            int pageNo = 6;  
            int pageSize = 6;  
            Jedis jedis = RedisUtil.getJedis();  
            jedis.del("a");  
            for (int i = 1; i <= 30; i++) {  
                jedis.rpush("a", i + "");  
            }  
      
            int start = pageSize * (pageNo - 1);// 因为redis中list元素位置基数是0  
            int end = start + pageSize - 1;  
      
            List<String> results = jedis.lrange("a", start, end);// 从start算起,start算一个元素,到结束那个元素  
            for (String str : results) {  
                System.out.println(str);  
            }  
      
        }  
      
        @Test  
        /** 
         * [向Redis list压入ID而不是实际的数据] 
            在上面的例子里 ,我们将“对象”(此例中是简单消息)直接压入Redis list,但通常不应这么做, 
            由于对象可能被多次引用:例如在一个list中维护其时间顺序,在一个集合中保存它的类别,只要有必要,它还会出现在其他list中,等等。 
            让我们回到reddit.com的例子,将用户提交的链接(新闻)添加到list中,有更可靠的方法如下所示: 
            $ redis-cli incr next.news.id 
            (integer) 1 
            $ redis-cli set news:1:title "Redis is simple" 
            OK 
            $ redis-cli set news:1:url "http://code.google.com/p/redis" 
            OK 
            $ redis-cli lpush submitted.news 1 
            OK 
            我们自增一个key,很容易得到一个独一无二的自增ID,然后通过此ID创建对象–为对象的每个字段设置一个key。最后将新对象的ID压入submitted.news list。 
            这只是牛刀小试。在命令参考文档中可以读到所有和list有关的命令。你可以删除元素,旋转list,根据索引获取和设置元素,当然也可以用LLEN得到list的长度。 
         */  
        public void testListStrUsage() {  
            String title = "太阳能是绿色能源4";  
            String url = "http://javacreazyer.iteye.com";  
            Jedis jedis = RedisUtil.getJedis();  
      
            long adInfoId = jedis.incr("ad:adinfo:next.id");  
            jedis.set("ad:adinfo:" + adInfoId + ":title", title);  
            jedis.set("ad:adinfo:" + adInfoId + ":url", url);  
            jedis.lpush("ad:adinfo", String.valueOf(adInfoId));  
      
            String resultTitle = jedis.get("ad:adinfo:" + adInfoId + ":title");  
            String resultUrl = jedis.get("ad:adinfo:" + adInfoId + ":url");  
            List<String> ids = jedis.lrange("ad:adinfo", 0, -1);  
            System.out.println(resultTitle);  
            System.out.println(resultUrl);  
            System.out.println(ids);  
      
            /** 
             * dbsize返回的是所有key的数目,包括已经过期的, 而redis-cli keys "*"查询得到的是有效的key数目 
             */  
            System.out.println(jedis.dbSize());  
      
            jedis.flushAll();  
        }  
      
        /** 
         * 下面是一个简单的方案:对每个想加标签的对象,用一个标签ID集合与之关联,并且对每个已有的标签,一组对象ID与之关联。 例如假设我们的新闻ID 
         * 1000被加了三个标签tag 1,2,5和77,就可以设置下面两个集合: $ redis-cli sadd news:1000:tags 1 
         * (integer) 1 $ redis-cli sadd news:1000:tags 2 (integer) 1 $ redis-cli 
         * sadd news:1000:tags 5 (integer) 1 $ redis-cli sadd news:1000:tags 77 
         * (integer) 1 $ redis-cli sadd tag:1:objects 1000 (integer) 1 $ redis-cli 
         * sadd tag:2:objects 1000 (integer) 1 $ redis-cli sadd tag:5:objects 1000 
         * (integer) 1 $ redis-cli sadd tag:77:objects 1000 (integer) 1 
         * 要获取一个对象的所有标签,如此简单: $ redis-cli smembers news:1000:tags 1. 5 2. 1 3. 77 4. 
         * 2 而有些看上去并不简单的操作仍然能使用相应的Redis命令轻松实现。例如我们也许想获得一份同时拥有标签1, 2, 
         * 10和27的对象列表。这可以用SINTER命令来做,他可以在不同集合之间取出交集。因此为达目的我们只需: $ redis-cli sinter 
         * tag:1:objects tag:2:objects tag:10:objects tag:27:objects ... no result 
         * in our dataset composed of just one object ... 
         * 在命令参考文档中可以找到和集合相关的其他命令,令人感兴趣的一抓一大把。一定要留意SORT命令,Redis集合和list都是可排序的。 
         */  
        @Test  
        public void testSetUsage() {  
            Jedis jedis = RedisUtil.getJedis();  
            jedis.sadd("zhongsou:news:1000:tags", "1");  
            jedis.sadd("zhongsou:news:1000:tags", "2");  
            jedis.sadd("zhongsou:news:1000:tags", "5");  
            jedis.sadd("zhongsou:news:1000:tags", "77");  
            jedis.sadd("zhongsou:news:2000:tags", "1");  
            jedis.sadd("zhongsou:news:2000:tags", "2");  
            jedis.sadd("zhongsou:news:2000:tags", "5");  
            jedis.sadd("zhongsou:news:2000:tags", "77");  
            jedis.sadd("zhongsou:news:3000:tags", "2");  
            jedis.sadd("zhongsou:news:4000:tags", "77");  
            jedis.sadd("zhongsou:news:5000:tags", "1");  
            jedis.sadd("zhongsou:news:6000:tags", "5");  
      
            jedis.sadd("zhongsou:tag:1:objects", 1000 + "");  
            jedis.sadd("zhongsou:tag:2:objects", 1000 + "");  
            jedis.sadd("zhongsou:tag:5:objects", 1000 + "");  
            jedis.sadd("zhongsou:tag:77:objects", 1000 + "");  
      
            jedis.sadd("zhongsou:tag:1:objects", 2000 + "");  
            jedis.sadd("zhongsou:tag:2:objects", 2000 + "");  
            jedis.sadd("zhongsou:tag:5:objects", 2000 + "");  
            jedis.sadd("zhongsou:tag:77:objects", 2000 + "");  
      
            Set<String> sets = jedis.sinter("zhongsou:tag:1:objects",  
                    "zhongsou:tag:2:objects", "zhongsou:tag:5:objects",  
                    "zhongsou:tag:77:objects");  
            System.out.println(sets);  
            jedis.flushAll();  
        }  
      
        @Test  
        public void testSortedSetUsage() {  
            Jedis jedis = RedisUtil.getJedis();  
            jedis.zadd("zhongsou:hackers", 1940, "Alan Kay");  
            jedis.zadd("zhongsou:hackers", 1953, "Richard Stallman");  
            jedis.zadd("zhongsou:hackers", 1943, "Jay");  
            jedis.zadd("zhongsou:hackers", 1920, "Jellon");  
            jedis.zadd("zhongsou:hackers", 1965, "Yukihiro Matsumoto");  
            jedis.zadd("zhongsou:hackers", 1916, "Claude Shannon");  
            jedis.zadd("zhongsou:hackers", 1969, "Linus Torvalds");  
            jedis.zadd("zhongsou:hackers", 1912, "Alan Turing");  
      
            Set<String> hackers = jedis.zrange("zhongsou:hackers", 0, -1);  
            System.out.println(hackers);  
      
            Set<String> hackers2 = jedis.zrevrange("zhongsou:hackers", 0, -1);  
            System.out.println(hackers2);  
      
            // 区间操作,我们请求Redis返回score介于负无穷到1920年之间的元素(两个极值也包含了)。  
            Set<String> hackers3 = jedis.zrangeByScore("zhongsou:hackers", "-inf",  
                    "1920");  
            System.out.println(hackers3);  
      
            // ZREMRANGEBYSCORE 这个名字虽然不算好,但他却非常有用,还会返回已删除的元素数量。  
            long num = jedis.zremrangeByScore("zhongsou:hackers", "-inf", "1920");  
            System.out.println(num);  
      
            jedis.flushAll();  
        }  
      
    } 

    附加一个工作中常用到的Jedis工具类,如下:

    import java.util.HashMap;  
    import java.util.Map;  
      
    import org.slf4j.Logger;  
    import org.slf4j.LoggerFactory;  
      
    import redis.clients.jedis.Jedis;  
    import redis.clients.jedis.JedisPool;  
    import redis.clients.jedis.JedisPoolConfig;  
      
    import com.zhongsou.vertportal.conf.BaseConfig;  
    import com.zhongsou.vertportal.conf.RedisConfig;  
      
    /** 
     * Redis工具类,用于获取RedisPool. 
     * 参考官网说明如下: 
     * You shouldn't use the same instance from different threads because you'll have strange errors. 
     * And sometimes creating lots of Jedis instances is not good enough because it means lots of sockets and connections, 
     * which leads to strange errors as well. A single Jedis instance is not threadsafe! 
     * To avoid these problems, you should use JedisPool, which is a threadsafe pool of network connections. 
     * This way you can overcome those strange errors and achieve great performance. 
     * To use it, init a pool: 
     *  JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost"); 
     *  You can store the pool somewhere statically, it is thread-safe. 
     *  JedisPoolConfig includes a number of helpful Redis-specific connection pooling defaults. 
     *  For example, Jedis with JedisPoolConfig will close a connection after 300 seconds if it has not been returned. 
     * @author wujintao 
     */  
    public class JedisUtil  {  
        protected Logger log = LoggerFactory.getLogger(getClass());  
          
        /** 
         * 私有构造器. 
         */  
        private JedisUtil() {  
              
        }  
        private static Map<String,JedisPool> maps  = new HashMap<String,JedisPool>();  
          
          
        /** 
         * 获取连接池. 
         * @return 连接池实例 
         */  
        private static JedisPool getPool(String ip,int port) {  
            String key = ip+":" +port;  
            JedisPool pool = null;  
            if(!maps.containsKey(key)) {  
                JedisPoolConfig config = new JedisPoolConfig();  
                config.setMaxActive(RedisConfig.getMaxactive());  
                config.setMaxIdle(RedisConfig.getMaxidle());  
                config.setMaxWait(RedisConfig.getMaxwait());  
                config.setTestOnBorrow(true);  
                config.setTestOnReturn(true);  
                try{    
                    /** 
                     *如果你遇到 java.net.SocketTimeoutException: Read timed out exception的异常信息 
                     *请尝试在构造JedisPool的时候设置自己的超时值. JedisPool默认的超时时间是2秒(单位毫秒) 
                     */  
                    pool = new JedisPool(config, ip, port,RedisConfig.getTimeout());  
                    maps.put(key, pool);  
                } catch(Exception e) {  
                    e.printStackTrace();  
                }  
            }else{  
                pool = maps.get(key);  
            }  
            return pool;  
        }  
      
        /** 
         *类级的内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例 
         *没有绑定关系,而且只有被调用到时才会装载,从而实现了延迟加载。 
         */  
        private static class RedisUtilHolder{  
            /** 
             * 静态初始化器,由JVM来保证线程安全 
             */  
            private static JedisUtil instance = new JedisUtil();  
        }  
      
        /** 
         *当getInstance方法第一次被调用的时候,它第一次读取 
         *RedisUtilHolder.instance,导致RedisUtilHolder类得到初始化;而这个类在装载并被初始化的时候,会初始化它的静 
         *态域,从而创建RedisUtil的实例,由于是静态的域,因此只会在虚拟机装载类的时候初始化一次,并由虚拟机来保证它的线程安全性。 
         *这个模式的优势在于,getInstance方法并没有被同步,并且只是执行一个域的访问,因此延迟初始化并没有增加任何访问成本。 
         */  
        public static JedisUtil getInstance() {  
            return RedisUtilHolder.instance;  
        }  
          
        /** 
         * 获取Redis实例. 
         * @return Redis工具类实例 
         */  
        public Jedis getJedis(String ip,int port) {  
            Jedis jedis  = null;  
            int count =0;  
            do{  
                try{   
                    jedis = getPool(ip,port).getResource();  
                    //log.info("get redis master1!");  
                } catch (Exception e) {  
                    log.error("get redis master1 failed!", e);  
                     // 销毁对象    
                    getPool(ip,port).returnBrokenResource(jedis);    
                }  
                count++;  
            }while(jedis==null&&count<BaseConfig.getRetryNum());  
            return jedis;  
        }  
      
        /** 
         * 释放redis实例到连接池. 
         * @param jedis redis实例 
         */  
        public void closeJedis(Jedis jedis,String ip,int port) {  
            if(jedis != null) {  
                getPool(ip,port).returnResource(jedis);  
            }  
        }  
    }  

    开发参考资料:

    redis官方文档:http://redis.io/documentation

    redis命令参考中文版:http://redis.readthedocs.org/en/2.4/index.html


    展开全文
  • Redis实战-Jedis使用指南

    万次阅读 2016-05-01 23:04:02
    概述Redis是一个开源的、高效的key-value存储系统,也是nosql中的最常见的一种。redis非常适合用来做缓存系统,关于Redis的详细介绍可以查看Redis官方documentation。Redis支持多语言的调用,官方...使用教程 1、配置
  • redis学习之Jedis使用线程池封装redis的基本操作及spring的简单封装
  • Jedis API中文使用文档.-比较详细

    热门讨论 2017-09-25 15:37:01
    Java中使用Jedis操作Redis 文档比较详细, 具体的方法都进行了介绍了, 适合新手, 和老程序员进行复习, jedis api比较乱, 特此整理.
  • jedis使用pipline的方法

    千次阅读 2014-12-17 14:48:20
    在集中操作redis的地方,使用jedis的pipline的功能能够极大地提升效率,普通的redis操作形式都是下面这种: client ---request1---> redis client ---response1--> redis client ---request2---> redis client ---...
  • jedis简单实例

    2017-03-21 17:50:32
    jedis
  • jedis使用

    千次阅读 2017-08-21 10:37:42
    jedis是官方首选的java客户端开发包 Github地址:...下载 jedis-xxx.jar  (http://mvnrepository.com/artifact/redis.clients/jedis) 下载 commons-poolx.x.x.jar (http://mvnrepository.com/artifa
  • Jedis使用总结

    千次阅读 2013-08-22 15:19:32
    转载:...前段时间细节的了解了Jedis使用Jedis是redis的java版本的客户端实现。 本文做个总结,主要分享如下内容: 【pipeline】【分
  • jedis 使用示例

    千次阅读 2015-01-10 01:31:10
    jedis 是 Redis 官方首选的 Java 客户端开发包。上手比较容易。它提供了以下三种操作方式: 1.单机单连接方式。 2.单机连接池方式。 3.多机分布式+连接池方式。
  • redis使用过程中,jedis作为客户端使用说明文档,包括存储几种类型的数据以及各种使用场景下的对应实例
  • Jedis介绍及使用

    千次阅读 2019-04-30 20:10:14
    1、Jedis介绍 ...在官方网站里列一些Java的客户端,有Jedis、Redisson、Jredis、JDBC-Redis、等其中官方推荐使用Jedis和Redisson。 在企业中用的最多的就是JedisJedis提供了完整Redis命令,而Red...
  • Jedis简单使用

    千次阅读 2018-05-07 19:33:30
    Redis在Java中的实现是Jedis,需要导入jedis.jar、commons-net.jar(具体版本自己选择)以及commons-pool2x.jar(commons-pool用于Jedis连接池的创建,如果使用了连接池commons-pool包的版本不能低于2x,这是因为使用...
  • ...Jedis 是 Redis 官方首选的 Java 客户端开发包。 工作过程总结的一个示例,贴出来,如下: package com.wujintao.redis; import java.util.Date; import java.util.HashMap;
  • spring4使用jedis整合redis,教程见博客地址:https://blog.csdn.net/zhou870498/article/details/79904475
  • Jedis的基本使用

    万次阅读 2019-03-31 12:09:47
    前言 Redis在Java’中的客户端在GitHub上start最高的是Jedis和Redisson。...如何使用Jedis 1.导入依赖 首先通过Maven引入Jedis的依赖 <dependency> <groupId>redis.clients</groupId> &l...
  • Jedis使用API

    千次阅读 2017-01-22 17:32:52
    需要导入jedis.jar包 启动redis服务。 代码测试连接redis JedisPool jPool = new JedisPool("localhost",6379); Jedis jedis = jPool.getResource(); jedis.set("date", "2017-01-19"); jedis.set("work", "coding")...
  • Jedis使用连接池操作redis集群

    千次阅读 2019-02-25 15:56:39
    import java.util.HashSet; import java.util.Set; import org.apache.commons.pool2.impl.GenericObjectPoolConfig; import redis.clients.jedis.Host...import redis.clients.jedis.JedisCluster; public cl...
  • Springboot maven多模块项目中集成Jedis使用Redis项目结构添加maven依赖添加配置文件添加RedisConfig类加载配置文件内容在启动类中加注解扫描配置文件测试1. 在demo-iservice模块中添加接口ITestService类2. 在demo-...
  • Jedis使用

    万次阅读 2017-11-30 15:06:45
    redis的使用: 1)redis相比mysql,速度比较快,用户体验好。 2)不经常变化的数据,可以使用redis存储,比如公司介绍等。 3)在mysql中操作后,存储到数据库中;下次在获取数据的时候,先从redis中查询,如果有...
  • Jedis使用工具类

    千次阅读 2016-03-16 16:32:07
    Redis 使用工具类: package com.qlwb.business.common.redis;import org.apache.log4j.Logger;import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis....
  • Springboot集成Jedis使用

    千次阅读 2019-07-14 13:44:40
    1、增加Jedis的依赖 springboot本身支持的spring-boot-starter-data-redis, <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis...
  • 使用连接池如果只引入jedis-3.1.0-m1.jar和commons-pool2-2.6.2.jar 会报错java.lang.NoClassDefFoundError:org/slf4j/LoggerFactory 然后我照着提示引入了slf4j-api-1.8.0-beta4.jar 又提示 SLF4J: No SLF4J ...
  • Jedis工具类,使用后释放连接

    千次阅读 2019-12-26 15:45:21
    Jedis工具类,使用后释放连接代码为什么要释放连接 代码 import com.alibaba.fastjson.JSON; import com.google.common.collect.ImmutableList; import lombok.extern.slf4j.Slf4j; import org.apache.commons....
  • jedis使用入门(Docker环境下)

    千次阅读 2017-05-09 10:50:56
    docker环境下,jedis使用入门
  • jedis-3.3.0

    2020-11-03 10:48:14
    最新架包jedis-3.3.0.jar下载. jedis 是 redis推荐的java客户端。通过Jedis我们可以很方便地使用java代码的...jedis使用起来比较简单,它的操作方法与redis命令相类似。对于初次使用redis的人来说,上手更快,更能适应.
  • jedis使用api(2)

    2016-09-09 20:01:31
    /** * 获取连接池. * @return 连接池实例 ...private static JedisPool getPool(String ip,int port) { JedisPoolConfig config = new JedisPoolConfig(); config.setMaxActive(RedisConfig.getMaxactive

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 86,474
精华内容 34,589
关键字:

jedis使用