想必Redis这个缓存已经无人不知了，在代理的配合下已经在分布式缓存中的得到了很好的肯定，现在我们一起通过一个Java的例子全面了解Redis缓存。
首先需要安装redis，下载地址： https://github.com/MSOpenTech/redis
安装完后，在自己的安装目录 下进入cmd输入 redis-server --maxmemroy 200m ；之所以需要加这个指令“--maxmemroy
200m”，因为不少人会出现莫名的内存问题，正常打开后的界面是：
下面需要下载jar包：
现在开始写自己的代码：
代码第一部分：
<span style="font-size:18px;">package com.test.redis;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
import redis.clients.jedis.SortingParams;
public class RedisClient {
private Jedis jedis;<span style="color:#009900;">// 非切片额客户端连接</span>
private JedisPool jedisPool;<span style="color:#009900;">// 非切片连接池</span>
private ShardedJedis shardedJedis;<span style="color:#009900;">// 切片额客户端连接</span>
private ShardedJedisPool shardedJedisPool;<span style="color:#009900;">// 切片连接池</span>
<span style="color:#009900;">// 地址</span>
private static final String HOST = "127.0.0.1";
<span style="color:#009900;">// 端口</span>
private static final int PORT = 6379;
public RedisClient() {
initialPool();
initialShardedJedisPool();
<span style="color:#009900;">// 通过切片连接池实例一个客户端连接；</span>
shardedJedis = shardedJedisPool.getResource();
<span style="color:#009900;">// 通过非切片连接池实例一个客户端连接；</span>
jedis = jedisPool.getResource();
}
<span style="color:#6600cc;">/**
* 初始化非切片连接池
*/</span>
private void initialPool() {
<span style="color:#009900;">// 池水配置</span>
JedisPoolConfig config = new JedisPoolConfig();
<span style="color:#009900;">// 连接池在同一时刻内所提供的最大活动连接数。</span>
config.setMaxActive(20);
<span style="color:#009900;">// 连接池在空闲时刻保持的最大连接数.</span>
config.setMaxIdle(5);
<span style="color:#009900;">// 当发生异常时数据库等待的最大毫秒数 (当没有可用的连接时).</span>
config.setMaxWait(10001);
<span style="color:#009900;">// 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；</span>
config.setTestOnBorrow(false);
<span style="color:#009900;">// 构造池水</span>
jedisPool = new JedisPool(config, HOST, PORT);
}
<span style="color:#6600cc;">/**
* 初始化切片连接池
*/</span>
private void initialShardedJedisPool() {
<span style="color:#009900;">// 池基本配置</span>
JedisPoolConfig config = new JedisPoolConfig();
<span style="color:#009900;">// 连接池在同一时刻内所提供的最大活动连接数。</span>
config.setMaxActive(20);
<span style="color:#009900;">// 连接池在空闲时刻保持的最大连接数.</span>
config.setMaxIdle(5);
<span style="color:#009900;">// 当发生异常时数据库等待的最大毫秒数 (当没有可用的连接时).</span>
config.setMaxWait(1000l);
<span style="color:#009900;">// 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；</span>
config.setTestOnBorrow(false);
<span style="color:#009900;">// slave链接</span>
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
shards.add(new JedisShardInfo(HOST, PORT, "master"));
<span style="color:#009900;">// 构造池</span>
shardedJedisPool = new ShardedJedisPool(config, shards);
}
public void show() {
KeyOperate();
StringOperate();
ListOperate();
SetOperate();
SortedSetOperate();
HashOperate();
jedisPool.returnResource(jedis);
shardedJedisPool.returnResource(shardedJedis);
}</span>
第二部分：测试类
<span style="font-size:18px;">package com.test.redis;
public class Main {
public static void main(String[] args) {
new RedisClient().show();
}
}</span>
关于key的操作以及解释
<span style="color:#6600cc;"> /**
* Key操作
*/
@Test</span>
private void KeyOperate() {
System.out.println("====key===");
<span style="color:#009900;">/**
* exists(key)：确认一个key是否存在
* del(key)：删除一个key
* type(key)：返回值的类型
* keys(pattern)：返回满足给定pattern的所有key
* randomkey：随机返回key空间的一个
* keyrename(oldname, newname)：重命名key
* dbsize：返回当前数据库中key的数目
* expire：设定一个key的活动时间（s）
* ttl：获得一个key的活动时间
* select(index)：按索引查询
* move(key, dbindex)：移动当前数据库中的key到dbindex数据库
* flushdb：删除当前选择数据库中的所有key
* flushall：删除所有数据库中的所有key
*/</span>
System.out.println("removeAll data :" + jedis.flushDB());
<span style="color:#009900;">// 判断是否该key存在</span>
System.out.println("check 'key999' exists or not " + shardedJedis.exists("key999"));
System.out.println("add new key001,value001 " + shardedJedis.set("key001", "key001"));
System.out.println("判断key001是否存在：" + shardedJedis.exists("key001"));
<span style="color:#009900;">// 输出系统中所有的key</span>
System.out.println("新增key002,value002键值对：" + shardedJedis.set("key002", "value002"));
System.out.println("系统中所有键如下：");
Set<String> keys = jedis.keys("*");
Iterator<String> it = keys.iterator();
while (it.hasNext()) {
String key = it.next();
System.out.println(key);
}
<span style="color:#009900;">// 删除某个key,若key不存在，则忽略该命令。</span>
System.out.println("系统中删除key002: " + jedis.del("key002"));
System.out.println("判断key002是否存在：" + shardedJedis.exists("key002"));
<span style="color:#009900;">// 设置Key001过期时间</span>
System.out.println("设置 key001的过期时间为5秒:" + jedis.expire("key001", 5));
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
<span style="color:#009900;">// 查看某个key的剩余生存时间，单位秒，永久生存或不存在都是返回-1；</span>
System.out.println("查看key001的剩余生存时间" + jedis.ttl("key001"));
<span style="color:#009900;">// 移除某个key的生存时间</span>
System.out.println("移除key001的生存时间" + jedis.persist("key001"));
<span style="color:#009900;">// 查看key所储存的值的类型</span>
System.out.println("查看key所储存的值的类型：" + jedis.type("key001"));
}
运行结果：
关于String的操作以及解释
<span style="color:#3333ff;">/**
* String功能
*/</span>
private void StringOperate() {
System.out.println();
System.out.println("====String的功能===");
<span style="color:#009900;"> /**
* set(key, value)：给数据库中名称为key的string赋予值value
* get(key)：返回数据库中名称为key的string的value
* getset(key, value)：给名称为key的string赋予上一次的value
* mget(key1, key2,…, key N)：返回库中多个string的value
* setnx(key, value)：添加string，名称为key，值为value
* setex(key, time, value)：向库中添加string，设定过期时间time
* mset(key N, value N)：批量设置多个string的值
* msetnx(key N, value N)：如果所有名称为key i的string都不存在
* incr(key)：名称为key的string增1操作
* incrby(key, integer)：名称为key的string增加integer
* decr(key)：名称为key的string减1操作
* decrby(key, integer)：名称为key的string减少integer
* append(key, value)：名称为key的string的值附加value
* substr(key, start, end)：返回名称为key的string的value的子串
*/</span>
System.out.println("removeAll data :" + jedis.flushDB());
System.out.println("===========增加数据===========");
<span style="color:#009900;">// redis缓存增加都使用set，获取都是get</span>
jedis.set("key001", "value001");
jedis.set("key002", "value002");
jedis.set("key003", "value003");
System.out.println("已新增的3个键值对如下：");
System.out.println(jedis.get("key001"));
System.out.println(jedis.get("key002"));
System.out.println(jedis.get("key003"));
System.out.println("============删除数据===========");
System.out.println("删除key003键值对：" + jedis.del("key003"));
System.out.println("获取key003键值对：" + jedis.get("key003"));
System.out.println("============修改数据===========");
<span style="color:#009900;">// 1、直接覆盖原来的数据</span>
System.out.println("直接覆盖key001原来的数据：" + jedis.set("key001", "value001-update"));
System.out.println("获取key001对应的新值：" + jedis.get("key001"));
<span style="color:#009900;">// 2、追加原来的数据</span>
System.out.println("【 在key002原来值后面追加：" + jedis.append("key002", "+appendString"));
System.out.println("【 获取key002对应的新值" + jedis.get("key002"));
System.out.println("=============增，删，查（多个）=============");
<span style="color:#009900;"> /**
* mset,mget同时新增，修改，查询多个键值对Mutiple批量操作
* 等价于：
* jedis.set("name","ssss");
* jedis.set("jarorwar","xxxx");
*/</span>
System.out.println("一次性新增key201,key202,key203,key204及其对应值："
+ jedis.mset("key201", "value201", "key202", "value202", "key203", "value203", "key204", "value204"));
System.out.println("一次性获取key201,key202,key203,key204各自对应的值：" + jedis.mget("key201", "key202", "key203", "key204"));
System.out.println("一次性删除key201,key202：" + jedis.del(new String[] { "key201", "key202" }));
System.out.println("一次性获取key201,key202,key203,key204各自对应的值：" + jedis.mget("key201", "key202", "key203", "key204"));
System.out.println();
}
运行结果：
关于List的操作以及解释
<span style="color:#6600cc;"> /**
* List操作
*/</span>
private void ListOperate() {
System.out.println();
System.out.println("======================list==========================");
<span style="color:#009900;">// 清空数据</span>
System.out.println("清空库中所有数据：" + jedis.flushDB());
System.out.println("===========增加元素===========");
<span style="color:#009900;">/*
* key指的是list的名称，这里的list类似与栈的结构，所以先lpush进去的话，实际下标是最后那个
* rpush(key, value)：在名称为key的list尾添加一个值为value的元素
* lpush(key, value)：在名称为key的list头添加一个值为value的 元素
* lrange(key, start, end)：返回名称为key的list中start至end之间的元素
* ltrim(key, start, end)：删除start-end以外的元素
* lset(key, index, value)：给名称为key的list中index位置的元素赋值
* lrem(key, count, value)：删除count个key的list中值为value的元素，可以直接根据value删除
* lpop(key)：返回并删除名称为key的list中的首元素
* rpop(key)：返回并删除名称为key的list中的尾元素
* llen(key)：返回list'的长度
* sort(key)：list进行排序
*/</span>
shardedJedis.lpush("stringlists", "vector");
shardedJedis.lpush("stringlists", "ArrayList");
shardedJedis.lpush("stringlists", "vector");
shardedJedis.lpush("stringlists", "vector");
shardedJedis.lpush("stringlists", "LinkedList");
shardedJedis.lpush("stringlists", "MapList");
shardedJedis.lpush("stringlists", "SerialList");
shardedJedis.lpush("stringlists", "HashList");
shardedJedis.lpush("numberlists", "3");
shardedJedis.lpush("numberlists", "1");
shardedJedis.lpush("numberlists", "5");
shardedJedis.lpush("numberlists", "2");
System.out.println("所有元素-stringlists：" + shardedJedis.lrange("stringlists", 0, -1));
System.out.println("所有元素-numberlists：" + shardedJedis.lrange("numberlists", 0, -1));
System.out.println("=============删除元素===========");
<span style="color:#009900;">// 删除列表指定的值 ，第二个参数为删除的个数（有重复时），后add进去的值先被删，类似于出栈</span>
System.out.println("成功删除指定元素个数-stringlists：" + shardedJedis.lrem("stringlists", 2, "vector"));
<span style="color:#009900;">// 删除后的结果</span>
System.out.println("删除指定元素之后-stringlists：" + shardedJedis.lrange("stringlists", 0, -1));
<span style="color:#009900;">// 删除区间以外的数据</span>
System.out.println("[ 删除下标0-3区间之外的元素：" + shardedJedis.ltrim("stringlists", 0, 3));
System.out.println("[ 删除指定区间之外元素后-stringlists：" + shardedJedis.lrange("stringlists", 0, -1));
<span style="color:#009900;">// 列表元素出栈</span>
System.out.println("出栈元素：" + shardedJedis.lpop("stringlists"));
System.out.println("元素出栈后-stringlists：" + shardedJedis.lrange("stringlists", 0, -1));
System.out.println("=============改=============");
<span style="color:#009900;">// 修改列表中指定下标的值</span>
shardedJedis.lset("stringlists", 0, "hello list!");
System.out.println("下标为0的值修改后-stringlists：" + shardedJedis.lrange("stringlists", 0, -1));
System.out.println("=============查=============");
<span style="color:#009900;">// 数组长度</span>
System.out.println("长度-stringlists：" + shardedJedis.llen("stringlists"));
System.out.println("长度-numberlists：" + shardedJedis.llen("numberlists"));
<span style="color:#009900;">// 排序
/*
* list中存字符串时必须指定参数为alpha，如果不使用SortingParams，而是直接使用sort("list")，
* 会出现"ERR One or more scores can't be converted into double"
*/</span>
SortingParams sortingParameters = new SortingParams();
sortingParameters.alpha();
sortingParameters.limit(0, 3);
System.out.println("返回排序后的结果-stringlists：" + shardedJedis.sort("stringlists", sortingParameters));
//
System.out.println("返回排序后的结果-numberlists：" + shardedJedis.sort("numberlists"));
<span style="color:#009900;">// 子串： start为元素下标，end也为元素下标；-1代表倒数一个元素，-2代表倒数第二个元素</span>
System.out.println("子串-第二个开始到结束：" + shardedJedis.lrange("stringlists", 1, -1));
<span style="color:#009900;">// 获取列表指定下标的值</span>
System.out.println("获取下标为2的元素：" + shardedJedis.lindex("stringlists", 2) + "\n");
}
运行结果
关于Set的操作以及解释
<span style="color:#6600cc;"> /**
* set操作
*/</span>
private void SetOperate() {
System.out.println();
System.out.println("======================set==========================");
<span style="color:#009900;">// 清空数据</span>
System.out.println("清空库中所有数据：" + jedis.flushDB());
<span style="color:#009900;">/**
* sadd(key, member)：向名称为key的set中添加元素member
* srem(key, member) ：删除名称为key的set中的元素member
* spop(key) ：随机返回并删除名称为key的set中一个元素
* smove(srckey, dstkey, member) ：移到集合元素
* scard(key) ：返回名称为key的set的基数
* sismember(key, member) ：member是否是名称为key的set的元素,
* sinter(key1, key2,…key N) ：求交集
* sinterstore(dstkey, (keys)) ：求交集并将交集保存到dstkey的集合
* sunion(key1, (keys)) ：求并集
* sunionstore(dstkey, (keys)) ：求并集并将并集保存到dstkey的集合
* sdiff(key1, (keys)) ：求差集
* sdiffstore(dstkey, (keys)) ：求差集并将差集保存到dstkey的集合
* smembers(key) ：返回名称为key的set的所有元素，返回一个set
* srandmember(key) ：随机返回名称为key的set的一个元素
*/</span>
System.out.println("=============增=============");
System.out.println("向sets集合中加入元素element001：" + jedis.sadd("sets", "element001"));
System.out.println("向sets集合中加入元素element002：" + jedis.sadd("sets", "element002"));
System.out.println("向sets集合中加入元素element003：" + jedis.sadd("sets", "element003"));
System.out.println("查看sets集合中的所有元素:" + jedis.smembers("sets"));
System.out.println("=============删=============");
System.out.println("集合sets中删除元素element003：" + jedis.srem("sets", "element003"));
System.out.println("查看sets集合中的所有元素:" + jedis.smembers("sets"));
<span style="color:#009900;">/*
* System.out.println("sets集合中任意位置的元素出栈："+jedis.spop("sets"));//注：出栈元素位置居然不定？--无实际意义
* System.out.println("查看sets集合中的所有元素:"+jedis.smembers("sets"));
*/</span>
System.out.println("=============查=============");
System.out.println("【 判断element001是否在集合sets中：" + jedis.sismember("sets", "element001"));
System.out.println("循环查询获取sets中的每个元素：");
Set<String> set = jedis.smembers("sets");
Iterator<String> it = set.iterator();
while (it.hasNext()) {
Object obj = it.next();
System.out.println(obj);
}
System.out.println();
System.out.println("=============集合运算=============");
System.out.println("sets1中添加元素element001：" + jedis.sadd("sets1", "element001"));
System.out.println("sets1中添加元素element002：" + jedis.sadd("sets1", "element002"));
System.out.println("sets1中添加元素element003：" + jedis.sadd("sets1", "element003"));
System.out.println("sets1中添加元素element002：" + jedis.sadd("sets2", "element002"));
System.out.println("sets1中添加元素element003：" + jedis.sadd("sets2", "element003"));
System.out.println("sets1中添加元素element004：" + jedis.sadd("sets2", "element004"));
System.out.println("查看sets1集合中的所有元素:" + jedis.smembers("sets1"));
System.out.println("查看sets2集合中的所有元素:" + jedis.smembers("sets2"));
System.out.println("sets1和sets2交集：" + jedis.sinter("sets1", "sets2"));
System.out.println("sets1和sets2并集：" + jedis.sunion("sets1", "sets2"));
System.out.println("sets1和sets2差集：" + jedis.sdiff("sets1", "sets2"));<span style="color:#009900;">// 差集：set1中有，set2中没有的元素</span>
}
运行结果
关于ZSet的操作以及解释
<span style="color:#6600cc;"> /**
* 有序Set
*/</span>
private void SortedSetOperate() {
System.out.println("======================zset==========================");
<span style="color:#009900;">// 清空数据</span>
System.out.println(jedis.flushDB());
<span style="color:#009900;">/**
* zadd.(key,score,value);增加等于该key的set得分等于score的元素value
* zrem(key,value);删除等于该key的set中value该元素
* zrange(key,start,end);返回等于该key的set中下标等于start-end之间的所有元素；
* zcard(key);返回等于该key的set的集合长度;
* zscore(key);查看等于该key的set集合中value元素的权重
*/</span>
System.out.println("=============增=============");
System.out.println("zset中添加元素element001：" + shardedJedis.zadd("zset", 7.0, "element001"));
System.out.println("zset中添加元素element002：" + shardedJedis.zadd("zset", 8.0, "element002"));
System.out.println("zset中添加元素element003：" + shardedJedis.zadd("zset", 2.0, "element003"));
System.out.println("zset中添加元素element004：" + shardedJedis.zadd("zset", 3.0, "element004"));
System.out.println("zset集合中的所有元素：" + shardedJedis.zrange("zset", 0, -1));// 按照权重值排序
System.out.println();
System.out.println("=============删=============");
System.out.println("zset中删除元素element002：" + shardedJedis.zrem("zset", "element002"));
System.out.println("zset集合中的所有元素：" + shardedJedis.zrange("zset", 0, -1));
System.out.println();
System.out.println("=============查=============");
System.out.println("统计zset集合中的元素中个数：" + shardedJedis.zcard("zset"));
System.out.println("统计zset集合中权重某个范围内（1.0——5.0），元素的个数：" + shardedJedis.zcount("zset", 1.0, 5.0));
System.out.println("查看zset集合中element004的权重：" + shardedJedis.zscore("zset", "element004"));
System.out.println("查看下标1到2范围内的元素值：" + shardedJedis.zrange("zset", 1, 2));
}
运行结果
关于Hash的操作以及解释
<span style="color:#6600cc;"> /**
* Hash操作
*/</span>
private void HashOperate() {
System.out.println("======================hash==========================");
<span style="color:#009900;">// 清空数据</span>
System.out.println(jedis.flushDB());
<span style="color:#009900;">/**
* hset(key, field, value)：向名称为key的hash中添加元素field<—>value
* hget(key, field)：返回名称为key的hash中field对应的value
* hmget(key, field1, …,field N)：返回名称为key的hash中field i对应的value
* hmset(key, field1, value1,…,field N, value N)：向名称为key的hash中添加元素field i<—>value i
* hincrby(key, field, integer)：将名称为key的hash中field的value增加integer
* hexists(key, field)：名称为key的hash中是否存在键为field的域
* hdel(key, field)：删除名称为key的hash中键为field的域
* hlen(key)：返回名称为key的hash中元素个数
* hkeys(key)：返回名称为key的hash中所有键
* hvals(key)：返回名称为key的hash中所有键对应的value
* hgetall(key)：返回名称为key的hash中所有的键（field）及其对应的value
*/</span>
System.out.println("=============增=============");
System.out.println("hashs中添加key001和value001键值对：" + shardedJedis.hset("hashs", "key001", "value001"));
System.out.println("hashs中添加key002和value002键值对：" + shardedJedis.hset("hashs", "key002", "value002"));
System.out.println("hashs中添加key003和value003键值对：" + shardedJedis.hset("hashs", "key003", "value003"));
System.out.println("新增key004和4的整型键值对：" + shardedJedis.hincrBy("hashs", "key004", 4l));
System.out.println("hashs中的所有值：" + shardedJedis.hvals("hashs"));
System.out.println();
System.out.println("=============删=============");
System.out.println("hashs中删除key002键值对：" + shardedJedis.hdel("hashs", "key002"));
System.out.println("hashs中的所有值：" + shardedJedis.hvals("hashs"));
System.out.println();
System.out.println("=============改=============");
System.out.println("key004整型键值的值增加100：" + shardedJedis.hincrBy("hashs", "key004", 100l));
System.out.println("hashs中的所有值：" + shardedJedis.hvals("hashs"));
System.out.println();
System.out.println("=============查=============");
System.out.println("判断key003是否存在：" + shardedJedis.hexists("hashs", "key003"));
System.out.println("获取key004对应的值：" + shardedJedis.hget("hashs", "key004"));
System.out.println("批量获取key001和key003对应的值：" + shardedJedis.hmget("hashs", "key001", "key003"));
System.out.println("获取hashs中所有的key：" + shardedJedis.hkeys("hashs"));
System.out.println("获取hashs中所有的value：" + shardedJedis.hvals("hashs"));
System.out.println();
}
运行结果
版权声明：本文为博主原创文章，未经博主允许不得转载。
时间： 2024-10-09 17:50:01