前言
之前我们介绍过了redis的五中基本类型以及在可视化界面进行操作,那么在开发中(在代码中)我们通常使用,jedis进行操作redis,要是springboot 项目,我们通常使用redisTemplte进行操作
首先将redis启动
方式一 Jredis
引入依赖,我们使用Jedis 来操作redis
<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>3.2.0</version></dependency>
1. 测试连接
@Testpublic void test11() {//测试连接Jedis jedis = new Jedis("localhost", 6379);String ping = jedis.ping();System.out.println(ping);}
执行结果:pong 表示连接成功
测试连接失败情况,这边随便改了个不存在的端口,结果报错
2. 基本操作
String
- 设置值
jedis.set("name","张三");
- 获取值
jedis.get("name")
@Testpublic void test11(){//连接Jedis jedis = new Jedis("localhost", 6379);//设置值jedis.set("name","张三");//获取String name = jedis.get("name");System.out.println(name);}
- 根据key 删除值
jedis.del("name");```java@Testpublic void test11() {//测试连接Jedis jedis = new Jedis("localhost", 6379);jedis.del("name");System.out.println(jedis.get("name"));}
List
- 从右边添加值 rpush
jedis.rpush("redisList","a","b","aa");
- 从左边添加值
jedis.lpush("redisList","la","lb","laa");
获取值就不是get(key) 了,,而是
List<String> list = jedis.lrange("redisList", 0, -1);
返回value集合,从0开始 到最后一个(-1)【包含最后一个】
@Testpublic void test11() {//测试连接Jedis jedis = new Jedis("localhost", 6379);jedis.rpush("redisList","a","b","aa");List<String> list = jedis.lrange("redisList", 0, -1);list.forEach(System.out::println);}
- 删除
jedis.del("redisList");
//测试连接Jedis jedis = new Jedis("localhost", 6379);jedis.del("redisList");//判断key是否存在Boolean redisList = jedis.exists("redisList");System.out.println(redisList);
- 删除指定元素
jedis.lrem("redisList",1,"a");
jedis.lrem(“key”,删除几个,要删除的元素);
删除key 为 redisList 中的 1个 元素 a
set
- 添加元素
jedis.sadd("redisSet","a","bb","ccc");
获取set 元素也与之前不同
Set<String> redisSet = jedis.smembers("redisSet");
返回set集合,不可重复
Jedis jedis = new Jedis("localhost", 6379);jedis.sadd("redisSet","a","a","bb","ccc");Set<String> redisSet = jedis.smembers("redisSet");System.out.println(redisSet);
删除key同理
//测试连接Jedis jedis = new Jedis("localhost", 6379);jedis.del("redisSet");System.out.println(jedis.exists("redisSet"));
删除指定元素
删除元素 “bb”
zset
- 添加元素
jedis.zadd("redisZSet",10,"aa");
jedis.zadd(“key”,score排序序号,“值”);
不太理解,可以回看 redis——基本介绍以及 五种 数据类型 (重要)
- 获取元素
Set<String> zSet = jedis.zrange("redisZSet",0,-1);
Hash
- 设置值,
因为存储的是hsah首先需要new 一个hashMap ,往我们new 出来的hash 存储数据,再将整个数据存储进redis hash 中
Jedis jedis = new Jedis("localhost", 6379);Map<String,String> hashMap = new HashMap<String,String>();hashMap.put("name","zhangsan");hashMap.put("age","18");jedis.hmset("redisHash", hashMap);
- 获取值
List<String> hmget = jedis.hmget("redisHash", "name", "age");
这边不太明白的,还是先去理解redis——基本介绍以及 五种 数据类型 ,这边不再过多赘述,都是些api的使用
其他常用api,什么自增自减这些又兴趣可以自己试试
这边介绍一个判断key是否存在
jedis.exists("key")
存在返回true,反之false ,开发中判断会用到
方式二 redisTemplate
依赖
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>
注入对象
@Resourceprivate RedisTemplate redisTemplate;
使用
可以看到有很多种方法,这边直接贴出一个通用工具类,仔细看代码中的注释就知道每个方法对应的数据类型使用了
package com.test1.demo;import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;/*** spring redis 工具类**/
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{@Resourcepublic RedisTemplate redisTemplate;/*** 缓存基本的对象,Integer、String、实体类等** @param key 缓存的键值* @param value 缓存的值*/public <T> void setCacheObject(final String key, final T value)
{redisTemplate.opsForValue().set(key, value);}/*** 缓存基本的对象,Integer、String、实体类等** @param key 缓存的键值* @param value 缓存的值* @param timeout 时间* @param timeUnit 时间颗粒度*/public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
{redisTemplate.opsForValue().set(key, value, timeout, timeUnit);}/*** 设置有效时间** @param key Redis键* @param timeout 超时时间* @return true=设置成功;false=设置失败*/public boolean expire(final String key, final long timeout)
{return expire(key, timeout, TimeUnit.SECONDS);}/*** 设置有效时间** @param key Redis键* @param timeout 超时时间* @param unit 时间单位* @return true=设置成功;false=设置失败*/public boolean expire(final String key, final long timeout, final TimeUnit unit)
{return redisTemplate.expire(key, timeout, unit);}/*** 获取有效时间** @param key Redis键* @return 有效时间*/public long getExpire(final String key)
{return redisTemplate.getExpire(key);}/*** 判断 key是否存在** @param key 键* @return true 存在 false不存在*/public Boolean hasKey(String key)
{return redisTemplate.hasKey(key);}/*** 获得缓存的基本对象。** @param key 缓存键值* @return 缓存键值对应的数据*/public <T> T getCacheObject(final String key)
{ValueOperations<String, T> operation = redisTemplate.opsForValue();return operation.get(key);}/*** 删除单个对象** @param key*/public boolean deleteObject(final String key)
{return redisTemplate.delete(key);}/*** 删除集合对象** @param collection 多个对象* @return*/public boolean deleteObject(final Collection collection)
{return redisTemplate.delete(collection) > 0;}/*** 缓存List数据** @param key 缓存的键值* @param dataList 待缓存的List数据* @return 缓存的对象*/public <T> long setCacheList(final String key, final List<T> dataList)
{Long count = redisTemplate.opsForList().rightPushAll(key, dataList);return count == null ? 0 : count;}/*** 获得缓存的list对象** @param key 缓存的键值* @return 缓存键值对应的数据*/public <T> List<T> getCacheList(final String key)
{return redisTemplate.opsForList().range(key, 0, -1);}/*** 缓存Set** @param key 缓存键值* @param dataSet 缓存的数据* @return 缓存数据的对象*/public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
{BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);Iterator<T> it = dataSet.iterator();while (it.hasNext()){setOperation.add(it.next());}return setOperation;}/*** 获得缓存的set** @param key* @return*/public <T> Set<T> getCacheSet(final String key)
{return redisTemplate.opsForSet().members(key);}/*** 缓存Map** @param key* @param dataMap*/public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
{if (dataMap != null) {redisTemplate.opsForHash().putAll(key, dataMap);}}/*** 获得缓存的Map** @param key* @return*/public <T> Map<String, T> getCacheMap(final String key)
{return redisTemplate.opsForHash().entries(key);}/*** 往Hash中存入数据** @param key Redis键* @param hKey Hash键* @param value 值*/public <T> void setCacheMapValue(final String key, final String hKey, final T value)
{redisTemplate.opsForHash().put(key, hKey, value);}/*** 获取Hash中的数据** @param key Redis键* @param hKey Hash键* @return Hash中的对象*/public <T> T getCacheMapValue(final String key, final String hKey)
{HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();return opsForHash.get(key, hKey);}/*** 获取多个Hash中的数据** @param key Redis键* @param hKeys Hash键集合* @return Hash对象集合*/public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
{return redisTemplate.opsForHash().multiGet(key, hKeys);}/*** 删除Hash中的某条数据** @param key Redis键* @param hKey Hash键* @return 是否成功*/public boolean deleteCacheMapValue(final String key, final String hKey)
{return redisTemplate.opsForHash().delete(key, hKey) > 0;}/*** 获得缓存的基本对象列表** @param pattern 字符串前缀* @return 对象列表*/public Collection<String> keys(final String pattern)
{return redisTemplate.keys(pattern);}/*** 生成唯一编号,没有过期时间*/public String getCode() {Long serialNum = redisTemplate.opsForValue().increment("JG", 1L);return "JG" +String.format("%06d",serialNum);}
}
以上就是redis 在开发中的使用了,欢迎讨论指正!!