前言

之前我们介绍过了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);}
}