Jedis操作Redis数据库

添加Maven依赖:

     <dependencies>
         <!-- 单元测试 -->
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.11</version>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>redis.clients</groupId>
             <artifactId>jedis</artifactId>
             <version>2.8.0</version>
         </dependency>
     </dependencies>

联系Jedis操作redis的常用命令:

TestRedis.java

  import java.util.List;
  import org.junit.Test;
  import redis.clients.jedis.Jedis;
  import redis.clients.jedis.JedisPool;
  import redis.clients.jedis.JedisPoolConfig;
  import redis.clients.jedis.Pipeline;
  import redis.clients.jedis.Transaction;

  public class TestRedis {

      String host = "192.168.1.99";
      int port = 6379;
      Jedis jedis = new Jedis(host, port);
      /**
       * 单机单链接的方式
       * 这种获取连接的方式只在测试的时候使用
       * 注意需要关闭redis服务器的防火墙
       * @throws Exception
       */
      @Test
      public void test1() throws Exception {
          //获取redis连接
          //jedis.set("hehe", "aaaaaa");
          String value = jedis.get("hehe");
          System.out.println(value);
          jedis.close();
      }

      /**
       * 单机连接池方式
       * 实际工作中建议使用这种方式
       * @throws Exception
       */
      @Test
      public void test2() throws Exception {
          //指定连接池的参数
          JedisPoolConfig poolConfig = new JedisPoolConfig();
          //最大空闲连接数
          poolConfig.setMaxIdle(10);
          //连接池的最大连接数
          poolConfig.setMaxTotal(100);
          //设置获取连接的最大等待时间
          poolConfig.setMaxWaitMillis(1000);
          //从连接池中获取连接的时候是否需要校验，这样可以保证取出的连接都是可用的
          poolConfig.setTestOnBorrow(true);
          //获取jedis连接池
          JedisPool jedisPool = new JedisPool(poolConfig , host, port);
          //从连接池中取一个链接
          Jedis jedis = jedisPool.getResource();
          String value = jedis.get("hehe");
          System.out.println(value);
          //这个close并不是关闭连接，而是把连接还给连接池。
          jedis.close();
      }

      /**
       * 手工实现incr命令
       * @throws Exception
       */
      @Test
      public void testIncr() throws Exception {
         //监控键a的值,如果在事务开启(multi命令执行之间这个键的值被其他命令修改了
         //watch并不能取消其他线程的修改那么就会取消事务代码的执行,事务会返回一个null(nil))
          jedis.watch("a");
          String value = jedis.get("a");
          int parseInt = Integer.parseInt(value);
          parseInt++;
          System.out.println("休息一会....");
          Thread.sleep(5000);
          Transaction multi = jedis.multi();
          multi.set("a", parseInt+"");
          List<Object> exec = multi.exec();
          if(exec==null){//exec返回的是null说明键的值被其它线程修改了.
              System.out.println("值被修改了,事务没有执行。。。。");
              testIncr();
          }else{
              System.out.println("正常执行....");
          }
      }

      /**
       * 模拟恶意登陆的场景,
       * 限制一个IP的访问次数
       */
      private boolean testLogin(String ip) {
          String value = jedis.get(ip);
          if(value==null){
              jedis.set(ip, 1+"");
              jedis.expire(ip, 60);//如果不加这个设置这个ip只能访问10次
          }else{
              int parseInt = Integer.parseInt(value);
              if(parseInt>10){
                  System.out.println("访问受限！");
                  return false;
              }
              jedis.incr(ip);
          }

          return true;
      }

      /**
       * 不使用管道
       * 初始化1000条数据
       * 消耗时间：5365(老师机器)  122(我的机器)
       * @throws Exception
       */
      @Test
      public void test3() throws Exception {
          long start_time = System.currentTimeMillis();
          for(int i=0;i<1000;i++){
              jedis.set("he"+i, "hello");
          }
          System.out.println("消耗时间："+(System.currentTimeMillis()-start_time));
      }

      /**
       * 使用管道
       * 初始化1000条数据
       * 消耗时间：281(老师机器) 27(我的机器)
       * @throws Exception
       */
      @Test
      public void test4() throws Exception {
          long start_time = System.currentTimeMillis();
          Pipeline pipelined = jedis.pipelined();
          for(int i=0;i<1000;i++){
              pipelined.set("ha"+i, "hello");
          }

          pipelined.sync();//执行管道中的命令
          System.out.println("消耗时间："+(System.currentTimeMillis()-start_time));
      }
  }

一般通过一个工具类来从redis连接池中获得redis连接.

RedisUtil.java

 import redis.clients.jedis.Jedis;
 import redis.clients.jedis.JedisPool;
 import redis.clients.jedis.JedisPoolConfig;

 /**
  * 静态工具类
  * @author Administrator
  *
  */
 public class RedisUtils {

     private static JedisPool jedisPool = null;

     /**
      * 从连接池中获取一个redis链接
      * 如果两个线程,第一个线程先进来还没有new出来,第二个线程进入if了,这样就造
      * 线程的安全性问题.
      * @return
      */
     public static synchronized Jedis getJedis(){
         if(jedisPool==null){//第一次初始化的时候是null,第一次出事后之后就不再执行
             JedisPoolConfig poolConfig = new JedisPoolConfig();
             //最大空闲连接数
             poolConfig.setMaxIdle(10);
             //连接池中最大连接数
             poolConfig.setMaxTotal(100);
             //在获取链接的时候设置的超市时间
             poolConfig.setMaxWaitMillis(1000);
             //表示在向连接池中创建连接的时候会对链接进行测试，保证连接池中的链接都是可用的。
             poolConfig.setTestOnBorrow(true);
             jedisPool = new JedisPool(poolConfig, "192.168.1.170", 6379);
         }
         Jedis jedis = jedisPool.getResource();
         return jedis;
     }

     /**
      * 把redis链接返回连接池
      */
     public static void returnJedis(Jedis jedis){
         jedisPool.returnResourceObject(jedis);
     }
 }

通过Jedis来操作Redis集群.

ClusterTest.java

 import java.util.HashSet;
 import java.util.Set;

 import org.junit.Test;

 import redis.clients.jedis.HostAndPort;
 import redis.clients.jedis.JedisCluster;
 import redis.clients.jedis.JedisPoolConfig;

 public class ClusterTest {

     @Test
     public void test() throws Exception{
         JedisPoolConfig poolConfig = new JedisPoolConfig();
         //最大空闲连接数
         poolConfig.setMaxIdle(10);
         //连接池中最大连接数
         poolConfig.setMaxTotal(100);
         //在获取链接的时候设置的超市时间
         poolConfig.setMaxWaitMillis(1000);
         //表示在向连接池中创建连接的时候会对链接进行测试，保证连接池中的链接都是可用的。
         poolConfig.setTestOnBorrow(true);
         Set<HostAndPort> nodes = new HashSet<HostAndPort>();
         nodes.add(new HostAndPort("192.168.0.172", 7000));
         nodes.add(new HostAndPort("192.168.0.172", 7001));
         nodes.add(new HostAndPort("192.168.0.172", 7002));
         nodes.add(new HostAndPort("192.168.0.172", 7003));
         nodes.add(new HostAndPort("192.168.0.172", 7004));
         nodes.add(new HostAndPort("192.168.0.172", 7005));

         JedisCluster jedisCluster = new JedisCluster(nodes, poolConfig);
         jedisCluster.set("a", "1");
         String value = jedisCluster.get("a");
         System.out.println(value);
     }
 }