准备
如果项目为maven项目，要添加Redis需要使用的包,下面是pom.xml配置文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.hyx</groupId>
<artifactId>test</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.10.2</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.3.1</version>
<scope>compile</scope>
</dependency>
</dependencies>
<build>
<pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
<plugins>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.0.0</version>
</plugin>
<!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.20.1</version>
</plugin>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>建立工具类与配置信息，使用连接池连接Redis数据库
配置文件
redis.maxTotal=100
redis.maxIdle=30
redis.minIdle=10
redis.url=主机名
redis.port=6379工具类
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class JedisPoolUtil {
private static JedisPool pool = null;
static {
//加载配置文件
InputStream in = JedisPoolUtil.class.getClassLoader().getResourceAsStream("redis.properties");
Properties pro = new Properties();
try {
pro.load(in);
} catch (IOException e) {
e.printStackTrace();
System.out.println("加载文件失败");
}
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(Integer.parseInt( pro.get("redis.maxTotal").toString()));
poolConfig.setMaxIdle(Integer.parseInt( pro.get("redis.maxIdle").toString()));
poolConfig.setMinIdle(Integer.parseInt( pro.get("redis.minIdle").toString()));
pool = new JedisPool(poolConfig, pro.get("redis.url").toString(),Integer.parseInt( pro.get("redis.port")
.toString()));
}
public static Jedis getJedis(){
return pool.getResource();
}
public static void release(Jedis jedis){
if(null != jedis){
jedis.close();
}
}
}实现对String的操作
import org.junit.jupiter.api.Test;
import uilts.JedisPoolUtil;
import redis.clients.jedis.Jedis;
public class StringDemo {
private static Jedis jedis = JedisPoolUtil.getJedis();
//添加和获取
@Test
public void fun1(){
jedis.set( "num","1" );
System.out.println(jedis.get( "num" ));
}
//删除
@Test
public void fun2(){
jedis.del( "num" );
System.out.println(jedis.get( "num" ));
}
//自增和自减
@Test
public void fun3(){
jedis.set( "num","1" );
jedis.decr( "num" ); //i--
System.out.println(jedis.get( "num" ));
jedis.incr( "num" );//i++
}
//自增和自减 一个数
@Test
public void fun4(){
jedis.set( "num","1" );
jedis.decrBy( "num" ,5); //i=i-5
System.out.println(jedis.get( "num" ));
jedis.incrBy( "num",10 );//i= i+10;
System.out.println(jedis.get( "num" ));
}
//字符串拼接
@Test
public void fun5(){
jedis.set( "name","yx" );
Long append = jedis.append( "name", "h" ); //返回长度
System.out.println(append);
System.out.println(jedis.get( "name" ));//feisong
}
}实现对Hash的操作
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;
import uilts.JedisPoolUtil;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
//Hash操作和JavaMap是一样
public class HashDemo {
private static Jedis jedis = JedisPoolUtil.getJedis();
//存储和获取
@Test
public void fun1(){
Long aLong = jedis.hset( "user", "uname", "sun");
System.out.println(aLong);
Long bLong = jedis.hset( "user", "age", "18" );
System.out.println(bLong);
String uname = jedis.hget( "user", "uname" );
System.out.println(uname);
}
//一次性存储多个key
@Test
public void fun2(){
HashMap<String, String> user = new HashMap<>();
user.put( "name","zs" );
user.put( "age","88" );
jedis.hmset( "user1",user );
}
//一次性或所有值
@Test
public void fun3(){
Map<String, String> user1 = jedis.hgetAll( "user1" );
System.out.println(user1);
}
//删除、增长,判定是否存储,获取键值对个数
@Test
public void fun4(){
Long hdel = jedis.hdel( "user1", "name" );
jedis.hincrBy( "user1","age",10 );
jedis.hexists( "user1","age" );
Long hlen = jedis.hlen( "user1" );
System.out.println(hdel);
}
//获取所有Keys、value
@Test
public void fun5(){
Set<String> keys = jedis.hkeys( "user" );
List<String> valus = jedis.hvals( "user" );
System.out.println(keys);
System.out.println(valus);
}
}实现对List 的操作
import org.junit.jupiter.api.Test;
import redis.clients.jedis.BinaryClient;
import redis.clients.jedis.Jedis;
import uilts.JedisPoolUtil;
import java.util.List;
public class ListTest {
public static Jedis jedis = JedisPoolUtil.getJedis();
// lpush头部添加
// rpush尾部添加
@Test
public void fun1(){
jedis.lpush("mylist","list00","list01","list02");
jedis.rpush("mylist","list00","list01","list02");
}
@Test
// 查看列表 参数 名字 start end -1代表最后一个元素 -2倒数第二个
public void fun2(){
List<String> mylist = jedis.lrange("mylist", 0, -1);
System.out.println(mylist);
}
//查看第一个
@Test
public void fun3(){
String ltop = jedis.lpop("mylist");
System.out.println(ltop);
}
//查看最后一个
@Test
public void fun4(){
String llast = jedis.rpop("mylist");
System.out.println(llast);
}
@Test
//判断有没有存在的键有就插入没有就不插入，不会创建
public void fun5(){
List<String> mylist = jedis.lrange("mylist", 0, -1);
System.out.println(mylist);
Long num = jedis.lpushx("mylist", "1");
mylist = jedis.lrange("mylist1", 0, -1);
System.out.println(num);
System.out.println(mylist);
}
@Test
// 移除元素返回移除的个数>0从前往后删除 <0从后往前删除
//返回删除元素个数
public void fun6(){
Long num = jedis.lrem("mylist", 5, "list00");
System.out.println(num);
}
@Test
// 设置值
public void fun7(){
jedis.lset("mylist",2,"abasdfasdf");
List<String> mylist = jedis.lrange("mylist", 0, -1);
System.out.println(mylist);
}
@Test
// 在中间插入值 如果该值不存在则返回-1
// 如果存在返回这个list的长度
public void fun8(){
Long num = jedis.linsert("mylist", BinaryClient.LIST_POSITION.BEFORE, "123", "list01" );
System.out.println(num);
jedis.lset("mylist",3,"abasdfasdf");
List<String> mylist = jedis.lrange("mylist", 0, -1);
System.out.println(mylist);
}
@Test
// 在第一个列表尾巴中弹出，在第二个列表中压入头
/*
* 使用场景，这样做可以保证原有数据的安全性，如果
* 从第一个列表中拆出来，直接释放掉那么一旦发生了异常
* 数据就不能回复了，我们还可以加上一个守护进程，更加确保
* 数据的安全性
* */
public void fun9(){
String rpoplpush = jedis.rpoplpush("mylist", "mylist1");
List<String> mylist = jedis.lrange("mylist", 0, -1);
System.out.println(mylist);
List<String> mylist1 = jedis.lrange("mylist1", 0, -1);
System.out.println(mylist1);
System.out.println(rpoplpush);
}
}操作Set
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;
import uilts.JedisPoolUtil;
import java.util.Set;
public class SetTest {
public static Jedis jedis = JedisPoolUtil.getJedis();
@Test
/*添加元素删除元素*/
public void fun(){
Long sadd = jedis.sadd("myset", "set1", "set3", "set2","5","set6");
System.out.println(sadd);
Long set1 = jedis.srem("myset","set1");
System.out.println(set1);
}
@Test
/*获得元素*/
public void fun1(){
Set<String> myset = jedis.smembers("myset");
System.out.println(myset);
}
@Test
/*移除元素*/
public void fun2(){
Long set1 = jedis.srem("myset","set1");
System.out.println(set1);
}
@Test
//判断是否这个set中存在某个值
public void fun3(){
Boolean sismember = jedis.sismember("myset", "set2");
System.out.println(sismember);
}
@Test
//获得A-B 获得差集合
public void fun4(){
Set<String> sdiff = jedis.sdiff("myset", "myadd");
System.out.println(sdiff);
}
@Test
//获得交集
public void fun5(){
Set<String> sinter = jedis.sinter("myset", "myadd");
System.out.println(sinter);
}
@Test
// 获得并集合
public void fun6(){
Set<String> sunion = jedis.sunion("myset", "myadd");
System.out.println(sunion);
}
@Test
// 成员数量
public void fun7(){
Set<String> smenmber = jedis.smembers("myset");
System.out.println("smenmber="+smenmber);
}
@Test
// 获得随机的一个成员
public void fun8(){
String srandmember = jedis.srandmember("myset");
System.out.println("srandmember= "+srandmember);
}
@Test
// 将相差的成员放到一个新的set中同理交集和并集都可以后面均
// 加上一个store即可
// 并返回新的长度
public void fun9(){
Set<String> sdiff = jedis.sdiff("myset", "myadd");
for(String s :sdiff){
Long sadd = jedis.sadd("newset", s);
System.out.println(sadd);
}
Set<String> newset = jedis.smembers("newset");
System.out.println(newset.size());
}
}操作SortSet
import org.junit.Assert;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.Tuple;
import uilts.JedisPoolUtil;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
和set极为的类似，他们是字符串的集合，没有重复的数据
差别是sortedset每个成员中都会有一个分数（score）与之关联
，redis正是通过分数来为集合中的成员进行从小到大的排序
sortedset中数据必须单一但是他的score可以是重复的
*/
public class SortedsetTest {
public static Jedis jedis = JedisPoolUtil.getJedis();
// 添加元素
@Test
public void fun(){
Map<String,Double> map = new HashMap<String,Double>();
for(int i=0;i<=10;i++){
map.put("value:"+i,Double.valueOf(i)); //覆盖了上面的赋值
}
jedis.zadd("sortedSet",map);
//返回共有多少元素
Long sortedSet = jedis.zcard("sortedSet");
//返回指定区域元素
Long sortedSet1 = jedis.zcount("sortedSet", 2, 6);
//返回指定区域所有键与值
Set<String> sortedSet2 = jedis.zrange("sortedSet", 0l, 10l);
System.out.println(sortedSet);
System.out.println(sortedSet1);
System.out.println(sortedSet2);
}
@Test
public void testZAddAndZCardAndZScore(){
//zadd 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
//zcard 返回有序集 key 的基数。
//zscore 返回有序集 key 中，成员 member 的 score 值。
jedis.zadd("sortedSet",1111,"value:10");
Map<String,Double> map = new HashMap<String,Double>();
for(int i=0;i<=10;i++){
map.put("value:"+i,Double.valueOf(i)); //覆盖了上面的赋值
}
jedis.zadd("sortedSet",map);
Assert.assertTrue(jedis.zscore("sortedSet","value:10")==10);
Assert.assertTrue(jedis.zcard("sortedSet")==11);
Assert.assertTrue(jedis.del("sortedSet")==1);
}
@Test
public void testZCount(){
//zcount 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
Map<String,Double> map = new HashMap<String,Double>();
for(int i=0;i<10;i++){
map.put("value:"+i,Double.valueOf(i));
}
jedis.zadd("sortedSet",map);
Long count = jedis.zcount("sortedSet",0,9);
System.out.println(count);
Assert.assertTrue(count==10);
Assert.assertTrue(jedis.del("sortedSet")==1);
}
@Test
public void testZincrby(){
//zincrby 为有序集 key 的成员 member 的 score 值加上增量 increment 。
jedis.zadd("sortedSet",1111,"value:10");
jedis.zincrby("sortedSet",-111.1,"value:10");
Assert.assertTrue(jedis.zscore("sortedSet","value:10")==999.9);
Assert.assertTrue(jedis.del("sortedSet")==1);
}
@Test
public void testZRangeAndZRevRange(){
/** zrange
* 返回有序集 key 中，指定区间内的成员。
其中成员的位置按 score 值递增(从小到大)来排序。 rev则相反
具有相同 score 值的成员按字典序(lexicographical order )来排列。
*/
Map<String,Double> map = new HashMap<String,Double>();
for(int i=0;i<10;i++){
map.put("value:"+i,Math.random()*100);
}
jedis.zadd("sortedSet",map);
Set<String> set = jedis.zrange("sortedSet",0,-1); //递增
Set<String> revSet = jedis.zrevrange("sortedSet",0,-1); //递减
for(String ss:set){
System.out.println(ss+":"+jedis.zscore("sortedSet",ss));
}
System.out.println("rev----------");
for(String ss:revSet){
System.out.println(ss+":"+jedis.zscore("sortedSet",ss));
}
Assert.assertTrue(jedis.del("sortedSet")==1);
}
@Test
public void testZRangeByScoreAndZRevRangeByScore(){
//返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
//有序集成员按 score 值递增(从小到大)次序排列。 rev递减
Map<String,Double> map = new HashMap<String,Double>();
for(int i=0;i<10;i++){
map.put("value:"+i,Math.random()*100);
}
jedis.zadd("sortedSet",map);
Set<String> set = jedis.zrangeByScore("sortedSet",25,75);
Set<String> revSet = jedis.zrevrangeByScore("sortedSet",75,25);
for(String ss:set){
System.out.println(ss+":"+jedis.zscore("sortedSet",ss));
}
System.out.println("rev----------");
for(String ss:revSet){
System.out.println(ss+":"+jedis.zscore("sortedSet",ss));
}
Assert.assertTrue(jedis.del("sortedSet")==1);
}
@Test
public void testZRankAndZRevRank(){
//zrank 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。从0开始，rev表示从大到小
Map<String,Double> map = new HashMap<String,Double>();
for(int i=0;i<10;i++){
map.put("value:"+i,Double.valueOf(i));
}
jedis.zadd("sortedSet",map);
Assert.assertTrue(jedis.zrank("sortedSet","value:5")==5);
Assert.assertTrue(jedis.zrevrank("sortedSet","value:5")==4);
Assert.assertTrue(jedis.del("sortedSet")==1);
}
@Test
public void testZRem(){
//zrem 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
Map<String,Double> map = new HashMap<String,Double>();
for(int i=0;i<10;i++){
map.put("value:"+i,Double.valueOf(i));
}
jedis.zadd("sortedSet",map);
Assert.assertTrue(jedis.zrem("sortedSet","value:0","value:1","dertcfghvjbk")==2);
Assert.assertTrue(jedis.zcard("sortedSet")==8);
Assert.assertTrue(jedis.del("sortedSet")==1);
}
@Test
public void testZRemRangeByRank(){
//zremrangeByRank 移除有序集 key 中，指定排名(rank)区间内的所有成员。
Map<String,Double> map = new HashMap<String,Double>();
for(int i=0;i<10;i++){
map.put("value:"+i,Double.valueOf(i));
}
jedis.zadd("sortedSet",map);
jedis.zremrangeByRank("sortedSet",1,3);
Assert.assertTrue(jedis.zcard("sortedSet")==7);
Assert.assertTrue(jedis.del("sortedSet")==1);
}
@Test
public void testZRemRangeByScore(){
//zremrangeByScore 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
Map<String,Double> map = new HashMap<String,Double>();
for(int i=0;i<10;i++){
map.put("value:"+i,Double.valueOf(i));
}
jedis.zadd("sortedSet",map);
jedis.zremrangeByScore("sortedSet",1,3);
Assert.assertTrue(jedis.zcard("sortedSet")==7);
Assert.assertTrue(jedis.del("sortedSet")==1);
}
@Test
public void testZUnionStore(){
//计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。
Map<String,Double> map = new HashMap<String,Double>();
for(int i=0;i<10;i++){
map.put("value:"+i,Double.valueOf(i));
}
jedis.zadd("keya",map);
for(int i=0;i<10;i++){
map.put("value:"+i,Double.valueOf(i+3));
}
map.put("adsad",123d);
jedis.zadd("keyb",map);
jedis.zunionstore("destination","keya","keyb");
Assert.assertTrue(jedis.zcard("destination")==11);
Assert.assertTrue(jedis.del("keya","keyb","destination")==3);
}
@Test
public void testZInterStore(){
//计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination
Map<String,Double> map = new HashMap<String,Double>();
for(int i=0;i<10;i++){
map.put("value:"+i,Double.valueOf(i)); //覆盖了上面的赋值
}
jedis.zadd("keya",map);
for(int i=0;i<10;i++){
map.put("value:"+i,Double.valueOf(i+3)); //覆盖了上面的赋值
}
map.put("adsad",123d);
jedis.zadd("keyb",map);
jedis.zinterstore("destination","keya","keyb");
Assert.assertTrue(jedis.zcard("destination")==10);
Assert.assertTrue(jedis.del("keya","keyb","destination")==3);
Assert.assertTrue(jedis.del("keya","keyb","destination")==3);
}
@Test
public void testZRangeByLex(){
//当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序（lexicographical ordering）来进行排序，
// 而这个命令则可以返回给定的有序集合键 key 中， 值介于 min 和 max 之间的成员。
jedis.zadd("中文",123d,"a");
jedis.zadd("中文",123d,"b");
jedis.zadd("中文",123d,"c");
jedis.zadd("中文",123d,"d");
jedis.zadd("中文",123d,"e");
Set<String> set = jedis.zrangeByLex("中文","(b","[e");
// Set<String> set = jedis.zrangeByLex("中文","-","+");
// System.out.println(set.toString());
Assert.assertTrue(set.size()==3);
Assert.assertTrue(jedis.del("中文")==1);
}
@Test
public void testZLexCount(){
//对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会返回该集合中， 成员介于 min 和 max 范围内的元素数量。
jedis.zadd("key",123d,"a");
jedis.zadd("key",123d,"b");
jedis.zadd("key",123d,"c");
jedis.zadd("key",123d,"d");
jedis.zadd("key",123d,"e");
Assert.assertTrue(jedis.zlexcount("key","-","+")==5);
Assert.assertTrue(jedis.zlexcount("key","(b","[e")==3);
Assert.assertTrue(jedis.del("key")==1);
}
@Test
public void testZRemRangeByLex(){
//对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会移除该集合中， 成员介于 min 和 max 范围内的所有元素。
jedis.zadd("key",123d,"a");
jedis.zadd("key",123d,"b");
jedis.zadd("key",123d,"c");
jedis.zadd("key",123d,"d");
jedis.zadd("key",123d,"e");
Assert.assertTrue(jedis.zremrangeByLex("key","(b","[e")==3);
Assert.assertTrue(jedis.zlexcount("key","-","+")==2);
}
@Test
public void testZScan(){
Pipeline pipeline = jedis.pipelined();
for(int i=0;i<1000;i++){
pipeline.zadd("key",Math.random()*100,"value:"+i);
}
pipeline.sync();
int cursor = 0;
int count = 0;
do{
ScanResult<Tuple> result = jedis.zscan("key",cursor);
cursor = Integer.valueOf(result.getStringCursor());
for(Tuple tuple :result.getResult()){
// System.out.print(new String(tuple.getBinaryElement())+":"+tuple.getScore());
count++;
}
}
while (cursor!=0);
System.out.println(count);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
