Redis 客户端 Jedis的使用

最新推荐文章于 2024-08-11 21:15:52 发布

程序员学习圈

最新推荐文章于 2024-08-11 21:15:52 发布

阅读量713

点赞数 1

分类专栏： # Redis 文章标签： nosql redis jedis 测试 class

本文链接：https://blog.csdn.net/Luomingkui1109/article/details/78402059

版权

Redis 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1.Jedis所需要的jar包

 
   Commons-pool-1.6.jar 
  
   Jedis-2.1.0.jar

2.Jedis常用操作

(1) 测试连通性

public class Demo01 {
  public static void main(String[] args) {
    //连接本地的 Redis 服务
    Jedis jedis = new Jedis("127.0.0.1",6379);
    //查看服务是否运行，打出pong表示OK
    System.out.println("connection is OK==========>: "+jedis.ping());
  }
}

(2) 五大数据类型和一个key的使用

import java.util.*;
import redis.clients.jedis.Jedis;
public class Test02{
  public static void main(String[] args){
     Jedis jedis = new Jedis("127.0.0.1",6379);
     //key
     Set<String> keys = jedis.keys("*");
     for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
       String key = (String) iterator.next();
       System.out.println(key);
     }
     System.out.println("jedis.exists====>"+jedis.exists("k2"));
     System.out.println(jedis.ttl("k1"));
     //String
     //jedis.append("k1","myreids");
     System.out.println(jedis.get("k1"));
     jedis.set("k4","k4_redis");
     System.out.println("----------------------------------------");
     jedis.mset("str1","v1","str2","v2","str3","v3");
     System.out.println(jedis.mget("str1","str2","str3"));
     //list
     System.out.println("----------------------------------------");
     //jedis.lpush("mylist","v1","v2","v3","v4","v5");
     List<String> list = jedis.lrange("mylist",0,-1);
     for (String element : list) {
       System.out.println(element);
     }
     //set
     jedis.sadd("orders","jd001");
     jedis.sadd("orders","jd002");
     jedis.sadd("orders","jd003");
     Set<String> set1 = jedis.smembers("orders");
     for (Iterator iterator = set1.iterator(); iterator.hasNext();) {
       String string = (String) iterator.next();
       System.out.println(string);
     }
     jedis.srem("orders","jd002");
     System.out.println(jedis.smembers("orders").size());
     //hash
     jedis.hset("hash1","userName","lisi");
     System.out.println(jedis.hget("hash1","userName"));
     Map<String,String> map = new HashMap<String,String>();
     map.put("telphone","13811814763");
     map.put("address","atguigu");
     map.put("email","abc@163.com");
     jedis.hmset("hash2",map);
     List<String> result = jedis.hmget("hash2", "telphone","email");
     for (String element : result) {
       System.out.println(element);
     }
     //zset
     jedis.zadd("zset01",60d,"v1");
     jedis.zadd("zset01",70d,"v2");
     jedis.zadd("zset01",80d,"v3");
     jedis.zadd("zset01",90d,"v4");
     Set<String> s1 = jedis.zrange("zset01",0,-1);
     for (Iterator iterator = s1.iterator(); iterator.hasNext();) {
       String string = (String) iterator.next();
       System.out.println(string);
     }
  }
}

(3) 事务提交

① 日常

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Response;
import redis.clients.jedis.Transaction;
public class Test03{

  public static void main(String[] args){

     Jedis jedis = new Jedis("127.0.0.1",6379);

     /*
     jedis.watch("serialNum");
     jedis.set("serialNum","s#####################");
     jedis.unwatch();
     */

     Transaction transaction = jedis.multi();//被当作一个命令进行执行
     Response<String> response = transaction.get("serialNum");
     transaction.set("serialNum","s002");
     response = transaction.get("serialNum");
     transaction.lpush("list3","a");
     transaction.lpush("list3","b");
     transaction.lpush("list3","c");
     //transaction.discard();
     transaction.exec();
     System.out.println("serialNum***********"+response.get());
  }
}

② 加锁

public class TestTransaction {
public boolean transMethod() {

     Jedis jedis = new Jedis( "127.0.0.1", 6379);
     int balance;// 可用余额
     int debt;// 欠额
     int amtToSubtract = 10;// 实刷额度
     jedis.watch("balance");
     //jedis.set("balance","5");//此句不该出现，为了方便。模拟其他程序已经修改了该条目
     balance = Integer.parseInt (jedis.get("balance" ));
     if (balance < amtToSubtract) {
       jedis.unwatch();
       System.out.println( "modify");
       return false;
     } else {
       System.out.println( "***********transaction");
       Transaction transaction = jedis.multi();
       transaction.decrBy("balance", amtToSubtract);
       transaction.incrBy("debt", amtToSubtract);
       transaction.exec();
       balance = Integer.parseInt (jedis.get("balance" ));
       debt = Integer.parseInt (jedis.get("debt" ));
       System.out.println( "*******" + balance);
       System.out.println( "*******" + debt);
       return true;
     }
  }

/**
   * 通俗点讲，watch命令就是标记一个键，如果标记了一个键， 在提交事务前如果该键被别人修改过，那事务就会失败，这种情况通常可以在程序中
   * 重新再尝试一次。
   * 首先标记了键balance，然后检查余额是否足够，不足就取消标记，并不做扣减； 足够的话，就启动事务进行更新操作，
   * 如果在此期间键balance被其它人修改， 那在提交事务（执行 exec）时就会报错， 程序中通常可以捕获这类错误再重新执行一次，直到成功。
   */

  public static void main(String[] args) {
     TestTransaction test = new TestTransaction();
     boolean retValue = test.transMethod();
     System.out.println("main retValue-------: " + retValue);
  }
}

(4) 主从复制

public static void main(String[] args) throws InterruptedException{
     Jedis jedis_M = new Jedis("127.0.0.1",6379);
     Jedis jedis_S = new Jedis("127.0.0.1",6380);
     jedis_S.slaveof("127.0.0.1",6379);
     jedis_M.set("k6","v6");
     Thread.sleep(500);
     System.out.println(jedis_S.get("k6"));
  }

3.JedisPool(使用连接池连接Redis )

(1) 获取Jedis实例需要从JedisPool中获取

(2) 用完Jedis实例需要返还给JedisPool

(3) 如果Jedis在使用过程中出错，则也需要还给JedisPool

(4) 案例见代码

JedisPoolUtil

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class JedisPoolUtil {
  private static volatile JedisPool jedisPool = null;
  private JedisPoolUtil() {}

  public static JedisPool getJedisPoolInstance(){
     if(null == jedisPool){
       synchronized (JedisPoolUtil.class){
          if(null == jedisPool)
          {
            JedisPoolConfig poolConfig = new JedisPoolConfig();
            poolConfig.setMaxActive(1000);
            poolConfig.setMaxIdle(32);
            poolConfig.setMaxWait(100*1000);
            poolConfig.setTestOnBorrow(true);
            jedisPool = new JedisPool(poolConfig,"127.0.0.1");
          }
       }
     }
     return jedisPool;
  }

  public static void release(JedisPool jedisPool,Jedis jedis){
     if(null != jedis){
       jedisPool.returnResourceObject(jedis);
     }
  }
}

JedisPool.getResource();

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
public class Test01 {
  public static void main(String[] args) {
     JedisPool jedisPool = JedisPoolUtil.getJedisPoolInstance();
     Jedis jedis = null;
     try{
       jedis = jedisPool.getResource();
       jedis.set("k18","v183");
     } catch (Exception e) {
       e.printStackTrace();
     }finally{
       JedisPoolUtil.release(jedisPool, jedis);
     }
  }
}

(5) 配置总结： JedisPool的配置参数大部分是由JedisPoolConfig的对应项来赋值的。

① maxActive：控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted。

② maxIdle：控制一个pool最多有多少个状态为idle(空闲)的jedis实例；

③ whenExhaustedAction：表示当pool中的jedis实例都被allocated完时，pool要采取的操作；默认有三种。

WHEN_EXHAUSTED_FAIL --> 表示无jedis实例时，直接抛出NoSuchElementException；

WHEN_EXHAUSTED_BLOCK --> 则表示阻塞住，或者达到maxWait时抛出 JedisConnectionException；

WHEN_EXHAUSTED_GROW --> 则表示新建一个jedis实例，也就说设置的maxActive无用；

④ maxWait：表示当borrow一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛 JedisConnectionException；

⑤ testOnBorrow：在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；

⑥ testOnReturn：在return给pool时，是否提前进行validate操作；

⑦ testWhileIdle：如果为true，表示有一个idle object evitor线程对idle object进行扫描，如果validate失败，此object会被从pool中drop掉；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；

⑧ timeBetweenEvictionRunsMillis：表示idle object evitor两次扫描之间要sleep的毫秒数；

⑨ numTestsPerEvictionRun：表示idle object evitor每次扫描的最多的对象数；

⑩ minEvictableIdleTimeMillis：表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；

softMinEvictableIdleTimeMillis：在minEvictableIdleTimeMillis基础上，加入了至少minIdle个对象已经在pool里面了。如果为-1，evicted不会根据idle time驱逐任何对象。如果minEvictableIdleTimeMillis>0，则此项设置无意义，且只有在timeBetweenEvictionRunsMillis大于0时才有意义；

⑫ lifo：borrowObject返回对象时，是采用DEFAULT_LIFO（last in first out，即类似cache的最频繁使用队列），如果为False，则表示FIFO队列；

说明：其中JedisPoolConfig对一些参数的默认设置如下：

testWhileIdle=true

minEvictableIdleTimeMills=60000

timeBetweenEvictionRunsMillis=30000

numTestsPerEvictionRun=-1

4.在谈使用 Jedis的Java客户端连接服务器端：

需要把jedis依赖的jar包添加到工程中。Maven工程中需要把jedis的坐标添加到依赖，推荐添加到服务层。

(1) 连接单机版

第一步：创建一个Jedis对象。需要指定服务端的ip及端口。

第二步：使用Jedis对象操作数据库，每个redis命令对应一个方法。

第三步：打印结果。

第四步：关闭Jedis

@Test
     public void testJedis() throws Exception {
          // 第一步：创建一个Jedis对象。需要指定服务端的ip及端口。
          Jedis jedis = new Jedis("192.168.25.153", 6379);
          // 第二步：使用Jedis对象操作数据库，每个redis命令对应一个方法。
          String result = jedis.get("hello");
          // 第三步：打印结果。
          System.out.println(result);
          // 第四步：关闭Jedis
          jedis.close();
     }

(2) 连接单机版使用连接池

第一步：创建一个JedisPool对象。需要指定服务端的ip及端口。

第二步：从JedisPool中获得Jedis对象。

第三步：使用Jedis操作redis服务器。

第四步：操作完毕后关闭jedis对象，连接池回收资源。

第五步：关闭JedisPool对象。

@Test
     public void testJedisPool() throws Exception {
          // 第一步：创建一个JedisPool对象。需要指定服务端的ip及端口。
          JedisPool jedisPool = new JedisPool("192.168.25.153", 6379);
          // 第二步：从JedisPool中获得Jedis对象。
          Jedis jedis = jedisPool.getResource();
          // 第三步：使用Jedis操作redis服务器。
          jedis.set("jedis", "test");
          String result = jedis.get("jedis");
          System.out.println(result);
          // 第四步：操作完毕后关闭jedis对象，连接池回收资源。
          jedis.close();
          // 第五步：关闭JedisPool对象。
          jedisPool.close();
     }

(3) 连接集群版

第一步：使用JedisCluster对象。需要一个Set<HostAndPort>参数。Redis节点的列表。

第二步：直接使用JedisCluster对象操作redis，在系统中单例存在。

第三步：打印结果

第四步：系统关闭前，关闭JedisCluster对象。

@Test
     public void testJedisCluster() throws Exception {
          // 第一步：使用JedisCluster对象。需要一个Set<HostAndPort>参数。Redis节点的列表。
          Set<HostAndPort> nodes = new HashSet<>();
          nodes.add(new HostAndPort("192.168.25.153", 7001));
          nodes.add(new HostAndPort("192.168.25.153", 7002));
          nodes.add(new HostAndPort("192.168.25.153", 7003));
          nodes.add(new HostAndPort("192.168.25.153", 7004));
          nodes.add(new HostAndPort("192.168.25.153", 7005));
          nodes.add(new HostAndPort("192.168.25.153", 7006));
          JedisCluster jedisCluster = new JedisCluster(nodes);
          // 第二步：直接使用JedisCluster对象操作redis。在系统中单例存在。
          jedisCluster.set("hello", "100");
          String result = jedisCluster.get("hello");
          // 第三步：打印结果
          System.out.println(result);
          // 第四步：系统关闭前，关闭JedisCluster对象。
          jedisCluster.close();
     }

程序员学习圈

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Redis 客户端 Jedis的使用

1.Jedis所需要的jar包Commons-pool-1.6.jarJedis-2.1.0.jar2.Jedis常用操作(1) 测试连通性public class Demo01 { public static void main(String[] args) { //连接本地的 Redis 服务 Jedis jedis = new Jedis("127.0.0.1",6379); //查看服务是否运行，打出pong表示OK System.out.printl
复制链接

扫一扫