# java-jedis

**Repository Path**: msulu/java-jedis

## Basic Information

- **Project Name**: java-jedis
- **Description**: java使用jedis连接redis存取数据及jedis常用的API整理
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 2
- **Created**: 2025-05-14
- **Last Updated**: 2025-05-14

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# java-jedis

#### 一、介绍
java使用jedis连接redis存取数据及jedis常用的API整理

二、导入jedis依赖jar包（jedis-3.3.0.jar）

三、连接redis

```java
public class TestRedis {
	@Test
 public void testRedis() {
		Jedis jedis=new Jedis("127.0.0.1",6379);
		String s=jedis.ping();
		System.out.println(s);
 }
}
//若输出PONG，则表示连接成功
```

### 3.1、测试String字符串类型

###### 3.1.1、jedis中对字符串的操作

| 方法                                                         | 描述                                                         |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| Jedis.set(String key,String value)                           | 新增健值对（key, value)                                      |
| Jedis.get(String key)                                        | 获取key所对应的value值                                       |
| Jedis.mset(String key1,String value1,String key2,String value2.....) | 新增多个健值对（key, value)                                  |
| Jedis.mget(String key1,String key2.....)                     | 获取多个key所对应的value值                                   |
| Jedis.append(String key,String value)                        | 在指定的key后面增加一个字符串，若该key不存在就相当于新增一个健值对 |
| jedis.strlen(String key)                                     | 获取指定key的长度                                            |
| jedis.del(String key)                                        | 从redis中移除指定的key                                       |
| Set<String> set=jedis.keys("*")                              | 查看所有的key                                                |
| jedis.exists(String key)                                     | 判断某个key是否存在                                          |
| jedis.type(String key)                                       | 查看某个key属于什么类型                                      |
| jedis.expire(String key,second)                              | 设置某个key的过期时间                                        |
| jedis.incr(String key)                                       | 将指定的key自增1                                             |
| Jedis.decr(String key)                                       | 将指定的key自减1                                             |
| Jedis.incrby(String key,int count)                           | 将指定的key的值以指定的步长增长                              |
| Jedis.decrby(String key,int count)                           | 将指定的key的值以指定的步长减少                              |
| Jedis.getrange(String key,int start,int end)                 | 截取字符串                                                   |
| Jedis.setrange(String key,int start,String value)            | 从指定的位置开始提换字符串（String的长度有多长将替换多长     |
| Jedis.ttl(String key)                                        | 查看key剩余的时间                                            |
|                                                              |                                                              |

###### 3.1.2、测试

```java

import java.util.Iterator;
import java.util.Set;

import org.junit.Test;

import redis.clients.jedis.Jedis;

public class TestRedis {
	@Test
 public void testRedis() {
		Jedis jedis=new Jedis("127.0.0.1",6379);
		String s=jedis.ping();
		System.out.println(s);
		//向redis添加key-value值
		jedis.set("name", "zhangsan");
		jedis.set("age","20");
		
		//根据key来获取值
		String name=jedis.get("name");
		String age=jedis.get("age");
		System.out.println(name+":"+age);
		
	    //获取字符串长度
		System.out.println("name:"+jedis.strlen("name"));
		System.out.println("age:"+jedis.strlen("age"));
		
		//从redis移除某个key
		jedis.del("salary");
		
		//查看所有的key
		Set<String> set=jedis.keys("*");
		//使用迭代器遍历set集合
		Iterator<String> iterator=set.iterator();
		while(iterator.hasNext()) {
			String str=iterator.next();
			System.out.println(str);
		}
		
		//判断某个key是否存在redis中--->true:存在  flase:不存在
		Boolean b=jedis.exists("name");
		System.out.println(b);
		
		//查看当前key的类型
		System.out.println(jedis.type("name"));
		
		//设置key的过期时间
		jedis.expire(age, 30);
		//查看当前key的剩余时间
		System.out.println(jedis.ttl("age"));
		 
		//追加字符串
		jedis.append("name", "hello");
		String name1=jedis.get("name");
		String age1=jedis.get("age");
		System.out.println(name1+":"+age1);
		
		//将key的值自增1
		jedis.incr("age");
		System.out.println(jedis.get("age"));
		
		//将keyd的值自减1
		jedis.decr("age");
		System.out.println(jedis.get("age"));
		 
		//将某个key的值指定增长
		jedis.incrByFloat("age", 10);
		System.out.println(jedis.get("age"));
		
		//将某个key的值指定减少
		jedis.decrBy("age", 5);
		System.out.println(jedis.get("age"));
		
		//截取字符串
		String str1=jedis.getrange("name", 0, 7);
		System.out.println(str1);
		
		//替换指定的字符
		jedis.setrange("name", 5, "zh");
		System.out.println(jedis.get("name"));
		
		//添加多个值
		jedis.mset("name1","lisi","name2","zhaoliu","name3","wangwu");
		System.out.println(jedis.get("name3"));
		
 }
}

```

### 3.2、测试redis-list类型（基本的数据类型，底层是列表）

###### 3.2.1、jedis对list的操作

| 方法                                                         | 描述                                                         |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| Jedis.lpush(String key,String value1,String value2......)    | 向列表中添加值，注意：如果已经有该List对应的key, 则按顺序在左边追加 一个或多个 |
| jedis.rpush(String key , String value)                       | 从列表的右边添加值                                           |
| jedis.lrange(String key,int i,int j)                         | 获取key对应list区间[i,j]的元素，注：从左边0开始，包头包尾    |
| jedis.lrem(String key,int n , String value)                  | 删除list中 n个元素                                           |
| jedis.lpop(String key)                                       | key对应list ,左弹出栈一个元素                                |
| jedis.rpop(String key)                                       | key对应list ,右弹出栈一个元素                                |
| jedis.lset(String key,int index,String value)                | 修改key对应的list指定下标index的元素的值                     |
| jedis.llen(String key)                                       | 获取key对应list的长度                                        |
| jedis.lindex(String key,int index)                           | 获取key对应list下标为index的元素                             |
| jedis.sort(String key)                                       | 把key对应list里边的元素从小到大排序                          |
| jedis.rpoplpush(String key,String key2)                      | 移除key列表中的最后一个元素，将它添加到新的key2列表中        |
| Jedis.linsert(String key, ListPosition where, String pivot,String value) | 在指定的值String pivot的前面或后面添加一个String value元素   |
|                                                              |                                                              |



###### 3.2.2、测试

```java
import org.junit.Test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.ListPosition;

public class TestJedisList {
	private ListPosition AFTER;

	@Test
	public void testJedisList() {
		Jedis jedis=new Jedis("127.0.0.1",6379);
		System.out.println(jedis.ping());
		
		//向list集合中添加值，插入到列表的头部（左）
		jedis.lpush("list","zhangsan","jiagou","lisi","wangwu");
		//获取list集合中的元素
		System.out.println(jedis.lrange("list", 0, -1));
		
		//移除列表中的第一个元素（左）
		jedis.lpop("list");
		System.out.println(jedis.lrange("list", 0, -1));
		
		//移除列表中的最后一个元素(右)
		jedis.rpop("list");
		System.out.println(jedis.lrange("list", 0, -1));
		
		//通过下标获取对应的值
		String srt=jedis.lindex("list", 1);
		System.out.println(srt);
		
		//获取列表中的元素个数
		System.out.println(jedis.llen("list"));
		
		//经列表中的某个元素移除
		jedis.lrem("list", 1, "lisi");
		System.out.println(jedis.lrange("list", 0, -1));
		
		
		//截取字符串
		jedis.lpush("list1","hellojedis","key1","key2","key3","key4");
		System.out.println(jedis.ltrim("list1", 0, 2));
		System.out.println("截取后的字符串	"+jedis.lrange("list1", 0, -1));
		
		//将列表中的指定下标的值替换为另外的值，相当于更新操作
		System.out.println(jedis.lrange("list1", 0, -1));
		jedis.lset("list",1, "key5");
		System.out.println("替换后的字符串是"+jedis.lrange("list1", 0, -1));
		
		//在指定的值的前面或后面插入一个值
		jedis.linsert("list1",AFTER, "key3", "key5");
		System.out.println(jedis.lrange("list1", 0, -1));
		
		//移除列表中的最后一个元素，将它添加到新的列表中
		jedis.rpoplpush("list1", "list2");
		System.out.println(jedis.lrange("list2", 0, -1));
		
		
	}

}

```

### 3.3、测试redis-set类型

###### 3.3.1、jedis对set的操作

| 方法                                                   | 描述                                                |
| ------------------------------------------------------ | --------------------------------------------------- |
| jedis.sadd(String key,String value1,String value2....) | 向set集合中添加一个或多个值                         |
| jedis.smembers(String key)                             | 查看置顶key里面的元素                               |
| jedis.sismember(String key,String value)               | 查看value值在集合中是否存在，true:存在 flash:不存在 |
| Jedis.scard(String key)                                | 查看set集合中元素个数                               |
| Jedis.srem(String key,String value1,String value2...)  | 从集合中删除一个或多个元素                          |
| jedis.srandmember(String key,int count)                | 从集合中随机取出count个元素                         |
| jedis.spop(String key,int count)                       | 随机从集合中移除count个元素                         |
| jedis.smove(String key,String key2,String value)       | 将key中指定的元素value移到集合key2中                |
| jedis.sdiff(String key,String key2)                    | key于key2的差集                                     |
| jedis.sinter(String key,String key2)                   | key与key2的交集                                     |
| jedis.sunion(String key,String key2)                   | key与key2的并集                                     |
|                                                        |                                                     |



###### 3.3.2、测试

```java
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.junit.Test;

import redis.clients.jedis.Jedis;

public class TestJedisSet {
   @Test
	public void testJedisSet() {
	   Jedis jedis=new Jedis("127.0.0.1",6379);
		System.out.println(jedis.ping());
		
		//向set集合中添加值
		jedis.sadd("set","1","2","3","4","5");
		
		//查看set集合中的值
		Set<String> set=jedis.smembers("set");
		Iterator<String> iterator=set.iterator();
		while(iterator.hasNext()) {
			String str=iterator.next();
			System.out.print(str);
		}
		
		//查看某个值是否在集合中
	
		System.out.println(jedis.sismember("set","6"));
		
		//查看set集合中元素的个数
		
		System.out.println(jedis.scard("set"));
		
		//将指定元素从集合中移除
		jedis.srem("set", "1");
		System.out.println(jedis.smembers("set"));
		
		//随机从集合中取出值
		List<String> list=jedis.srandmember("set",2);
		Iterator iterator1=list.iterator();
		while(iterator1.hasNext()) {
			String str2=(String) iterator1.next();
			System.out.println(str2);
		}
		
		//随机移除集合中的元素
		jedis.spop("set", 1);
		System.out.println(jedis.smembers("set"));
		
		//将指定的元素移到另一个集合中
		jedis.smove("set","set1","5");
		System.out.println(jedis.smembers("set"));
		System.out.println(jedis.smembers("set1"));
		
		
		jedis.sadd("set2","1","2","3","4");
		jedis.sadd("set3","1","2","5","6","7");
		System.out.println(jedis.sdiff("set2","set3"));
		System.out.println(jedis.sinter("set2","set3"));
		System.out.println(jedis.sunion("set2","set3"));
		
	}
}

```

### 3.4、测试Redis-hash(相当于一个MAP集合，这时候的value就是一个map集合)

###### 3.4.1、jedis对set的操作

| 方法                                              | 描述                           |
| ------------------------------------------------- | ------------------------------ |
| jedis.hmset(String key,Map map)                   | 添加duogHash                   |
| jedis.hset(String key , String key, String value) | 向Hash中插入一个元素（K-V）    |
| jedis.hgetAll(String key)                         | 获取Hash的所有（K-V） 元素     |
| jedis.hkeys（String key）                         | 获取Hash所有元素的key          |
| jedis.hvals(String key)                           | 获取Hash所有元素 的value       |
| jedis.hincrBy(String key , String k, int i)       | 把Hash中对应的k元素的值 val+=i |
| jedis.hdel(String key , String k1, String k2,…)   | 从Hash中删除一个或多个元素     |
| jedis.hlen(String key)                            | 获取Hash中元素的个数           |
| jedis.hexists(String key,String K1)               | 判断Hash中是否存在K1对应的元素 |
| jedis.hmget(String key,String K1,String K2)       | 获取Hash中一个或多个元素value  |
|                                                   |                                |

###### 3.4.2、测试

```java
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

import redis.clients.jedis.Jedis;

public class TestJedisHash {
	@Test
	public void testJedisHash() {
		Jedis jedis=new Jedis("127.0.0.1",6379);
		//向Hash中插入一个元素（K-V）
		jedis.hset("student","name","zhangsan");
		jedis.hset("student","age","18");
		jedis.hset("student","address","yunnan");		
		System.out.println(jedis.hget("student", "age"));
		
		//获取全部数据
		Map<String,String> map=jedis.hgetAll("student");
		Set<Map.Entry<String,String>> set=map.entrySet();
		Iterator iterator=set.iterator();
		while(iterator.hasNext()) {
			Map.Entry<String,String> map1=(Entry<String, String>) iterator.next();
			System.out.println("key:"+map1.getKey()+" "+"value:"+map1.getValue());
		}
		
		//向hash中添加多个值
		Map<String,String> map3=new HashMap<String,String>();
		map3.put("name","lisi");
		jedis.hmset("person",map3);
		
		//获取Hash的所有（K-V） 元素
		Map<String,String> map2=jedis.hgetAll("person");
	  for(String v:map2.keySet()) {
		  System.out.println(v+":"+map2.get(v));
	  }
	  
	  //获取Hash所有元素 的value
	  System.out.println(jedis.hvals("student"));
	  
	  //获取Hash所有元素的key
	  System.out.println(jedis.hkeys("student"));
	  
	  //把Hash中对应的k元素的值 val+=i
	  jedis.hincrBy("student" , "age",5 );
	  System.out.println(jedis.hvals("student"));
	  
	 
	}

}

```

### 3.5、测试redis-zset(有序集合)

###### 3.5.1、jedis对zset的操作

| 方法                                             | 描述                                            |
| ------------------------------------------------ | ----------------------------------------------- |
| jedis.zadd(String key,int score,String value)    | 添加一个ZSet                                    |
| jedis.zrange(String key, int i , int j)          | 获取ZSet 里下表[i,j] 区间元素Value              |
| jedis. zrangeWithScore(String key,int i , int j) | 获取ZSet 里下表[i,j] 区间元素Score - Val        |
| jedis.zrangeByScore(String , int i , int j)      | 获取ZSet里score[i,j]分数区间的元素（Score-Val） |
| jeids.zscore(String key,String value)            | 获取ZSet里value元素的Score                      |
| jedis.zrank(String key,String value)             | 获取ZSet里value元素的score的排名                |
| jedis.zrem(String key,String value)              | 删除ZSet里的value元素                           |
| jedis.zcard(String key)                          | 获取ZSet的元素个数                              |
| jedis.zcount(String key , int i ,int j)          | 获取ZSet总score在[i,j]区间的元素个数            |
| jedis.zincrby(String key,int n , String value)   | 把ZSet中value元素的score+=n                     |
| Jedis.zrevrange(String key,int i,int j)          | 查看Zset中（i,j）里的元素（从大到小排序）       |
|                                                  |                                                 |

###### 3.5.2、测试

```java
import java.util.Set;

import org.junit.Test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;

public class TestJedisZSet {
	@Test
	public void testJedisZSet() {
		Jedis jedis=new Jedis("127.0.0.1",6379);
		//向zset中插入元素
		jedis.zadd("salary",2600,"xiaohong");
		jedis.zadd("salary",2100,"xiaozhang");
		jedis.zadd("salary",3000,"xiaobai");
		jedis.zadd("salary",2600,"xiaohei");
		jedis.zadd("salary",2500,"xiaolan");
		
		//查看zset集合的元素
		Set<String> set=jedis.zrange("salary", 0, -1);
		for(String v:set) {
			System.out.println(v);
		}
		
		//查看zset集合的元素并带有数据
		Set<Tuple> set1=jedis.zrangeWithScores("salary", 0, -1);
		for(Tuple v:set1) {
			System.out.println(v);
		}
		
		//获取ZSet里value元素的Score
		System.out.println(jedis.zscore("salary","xiaohong"));
		
		//获取ZSet里value元素的score的排名
		System.out.println(jedis.zrank("salary","xiaohong"));
		
		//删除ZSet里的value元素
		jedis.zrem("salary","xiaohei");
		
		//获取ZSet的元素个数
		System.out.println(jedis.zcard("salary"));
		
		//获取ZSet总score在[i,j]区间的元素个数
		System.out.println(jedis.zcount("salary" ,2500,3000));
		
		//把ZSet中value元素的score+=n
		jedis.zincrby("salary",400 , "xiaohong");
		
		Set<String> set3=jedis.zrevrange("salary", 0, -1);
		for(String v:set3) {
			System.out.println(v);
		}
	
	}

}

```

### 3.6、 排序操作

###### 3.6.1、使用排序， 首先需要生成一个排序对象

```java
SortingParams  sortingParams =  new SortingParams();
```

###### 3.6.2、排序操作

| 方法                                          | 描述                 |
| --------------------------------------------- | -------------------- |
| jedis.sort(String key,sortingParams.alpha())  | 队列按首字母a-z 排序 |
| jedis.sort(String key, sortingParams.asc() )  | 队列按数字升序排列   |
| jedis.sort(String key , sortingParams.desc()) | 队列按数字降序排列   |

###### 3.6.2、测试

```java
import java.util.List;

import org.junit.Test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.SortingParams;

public class TestJedisSort {
	@Test
	public void testJedisSort() {
		Jedis jedis=new Jedis("127.0.0.1",6379);
		SortingParams  sortingParams =  new SortingParams();
		jedis.lpush("shi","q","d","z","a","t","p","f");
		List<String> list=jedis.lrange("shi", 0, -1);
		for(String v:list) {
			System.out.print(v);
		}
		
		System.out.println();
		List<String> list1=jedis.sort("shi", sortingParams.alpha());
		for(String v:list1) {
			System.out.print(v);
		}
	}

}

```

### 四、三种特殊数据类型（Geospatial、Hyperloglog、Bitmap)

###       1、Geospatial(地理空间)底层实现原理就是Zset，所以我们可以用Zset的命令来操作geo

######                 1.1.1、jedis操作geospatial

| 方法                                                         | 描述                                                         |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| Jedis.geoadd(String key,double longitude,double latitude,String member) | 添加一个地理坐标（经纬度）                                   |
| jedis.zrange(String key,int i,int j)                         | 查看地图中的元素（0，-1）查看所有的元素                      |
| jedis.geopos(String key,String value)                        | 获取指定地点的经纬度                                         |
| jedis.geodist(String key,String value1,Stirng value2,GeoUnit unit) | 计算地图中两地的距离GeoUnit.km,单位是km                      |
| jedis.georadius(String key,double longitude,double latitude,double radius,  *GeoUnit* unit, GeoRadiusParam param) | 指定经纬度指出某一半径内的所有元素，param.withCoord():显示经纬度；param.withDist():显示距给定经纬度的距离 |
| jedis.georadiusByMember(String key, String member, double radius,GeoUnit unit) | 找出位于指定元素以半径为radis以内的元素；GeoUnit.km单位是km  |
| jedis.zrem(String key,String value)                          | 移除地图中指定的元素                                         |
|                                                              |                                                              |

######         1.1.2、测试

```java
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.junit.Test;

import redis.clients.jedis.GeoCoordinate;
import redis.clients.jedis.GeoRadiusResponse;
import redis.clients.jedis.GeoUnit;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.GeoRadiusParam;

public class TestJedisGeospatial {
	
	@Test
	public void testJedisGeopatial() {
		Jedis jedis=new Jedis("127.0.0.1",6379);
		jedis.geoadd("chian:city", 102.716416, 25.051562,"yunnan");
		jedis.geoadd("chian:city", 116.512885,39.847469,"beijing");
		jedis.geoadd("chian:city", 120.215512,30.253083,"hangzhou");
		jedis.geoadd("chian:city", 106.558434,29.568996,"chongqin");
		jedis.geoadd("chian:city", 121.486801,31.24257,"shanghai");
		jedis.geoadd("chian:city", 106.714476,26.60403,"guizhou");
		jedis.geoadd("chian:city", 104.073467,30.577543,"sichuan");
		
		//获取相应地点的经纬度
		List<GeoCoordinate> list=jedis.geopos("chian:city","yunnan");
		System.out.println(list);
		
		//计算两地的距离
		Double dubole =jedis.geodist("chian:city","beijing","yunnan",GeoUnit.KM);
		System.out.println(dubole);
		
		//以给定的经纬度为中心， 找出某一半径内的元素
		List<GeoRadiusResponse> list1=jedis.georadius("chian:city", 110, 39, 1000, GeoUnit.KM,GeoRadiusParam.geoRadiusParam().withCoord().withDist().count(1));
		for(GeoRadiusResponse g:list1) {
			System.out.println(g);
		}
			
		//查看地图中所有的元素
		Set<String> set=jedis.zrange("chian:city", 0, -1);
		Iterator<String> iterator=set.iterator();
		while(iterator.hasNext()) {
			String string=iterator.next();
			System.out.println(string);
		}
		
		//找出位于地图中指定位置的其他元素
		List<GeoRadiusResponse> list2=jedis.georadiusByMember("chian:city","yunnan",1000,GeoUnit.KM);
		
		System.out.println("=========");
		
		//将地图中的元素移除
		jedis.zrem("chian:city","beijing");
		Set<String> set1=jedis.zrange("chian:city", 0, -1);
		Iterator<String> iterator1=set.iterator();
		while(iterator1.hasNext()) {
			String string=iterator1.next();
			System.out.println(string);
		}
	}

}

```

###  2、Hyperloglog（数据结构：用于统计基数的算法）

######         2.1.1、jedis操作Hyperloglog

| 方法                                               | 描述                           |
| -------------------------------------------------- | ------------------------------ |
| Jedis.pfadd(String key,String value.....)          | 添加数据                       |
| jedis.pfmerge(String key3,String key2,String key1) | 将key1和key2的数据合并到key3中 |
| jedis.pfcount(String key)                          | 统计个数                       |

######        2.1.2、测试

```java
import org.junit.Test;

import redis.clients.jedis.Jedis;

public class TestJedisHyperloglog {
	@Test
	public void testJedisHyperloglog() {
		Jedis jedis=new Jedis();
		//添加元素
		jedis.pfadd("hll","a","b","c");
		jedis.pfadd("hll1","d","e","f");
		
		//和并数据到另一个数据库中
		jedis.pfmerge("hll2","hll","hll1");
		
		//统计个数
		System.out.println(jedis.pfcount("hll"));
		System.out.println(jedis.pfcount("hll1"));
		System.out.println(jedis.pfcount("hll2"));
		
	}

}

```

### 3、Bitmap位图（数据结构，都是操作二进制位来进行记录，只有0和1两个状态）

######          3.1.1、jedis操作Bitmap

​          

| 方法                                                 | 描述     |
| ---------------------------------------------------- | -------- |
| Jedis.setbit( String key,  long offset,String value) | 添加数据 |
| Jedis.getbit(String key, long offset)                | 获取数据 |
| Jedis.bitcount(String key)                           | 统计数量 |

######         3.1.2、测试

```java
import org.junit.Test;

import redis.clients.jedis.Jedis;

public class TestJedisBitmap {
	@Test
	public void testJedisBitmap() {
	    Jedis jedis=new Jedis();
	    //添加数据
	    jedis.setbit("sign", 0,"1");
	    jedis.setbit("sign", 1,"1");
	    jedis.setbit("sign", 2,"0");
	    jedis.setbit("sign", 3,"1");
	    jedis.setbit("sign", 4,"0");
	    
	    //获取数据
	    System.out.println(jedis.getbit("sign", 2));
	    
	    //统计数量
	    System.out.println(jedis.bitcount("sign"));
	}

}

```