深入学习redis-基于Jedis通过客户端操作Redis

已于 2023-11-30 17:27:59 修改
阅读量1.1k 收藏 19
点赞数 22
分类专栏： Redis 文章标签： redis 数据库 缓存
于 2023-11-30 17:26:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44985964/article/details/134034831
版权

目录

redis客户端（JAVA）

配置

引入依赖

建立连接

常用命令实现

get/set

exists/del

keys

expire和ttl

type

字符串（String）

mget和mset

getrange和setrange

append

incr和decr

列表（list）

lpush和lrange

rpush

lpop

rpop

blpop

llen

集合（set）

sadd和smembers

sismember

scard

spop

sinter

sinterstore

哈希（hash）

hset和hget

hexists

hdel

hkeys和hvals

hmget和hmset

有序集合（zset）

zadd和zrange

zcard

zrem

zscore

zrank

SpringDataRedis

RedisTemplate工具类

SpringDataRedis快速入门

引入依赖

配置文件

注入RedisTemplate

编写测试

SpringDataRedis的序列化方式

方案一

方案二

构建一个类来测试redis的方法

string

list

​编辑

set

hash

zset

Jedis的官网地址

redis客户端（JAVA）

java生态中，封装了RESP协议，在这里使用jedis实现redis客户端

配置

引入依赖

创建一个maven项目，引入jedis依赖

    <dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.4.2</version>
        </dependency>
    </dependencies>

进行简单配置，把云服务器的端口当成一个本地的端口使用

连接上云服务器上的 redis ，就需要开放 6379 端口：

  1. 将 java 程序打包成 jar 包，放到 linux 服务器上执行（过于麻烦，不推荐）;
  2. 匹配 ssh 端口转发，把云服务器的 redis 端口，映射到本地主机（推荐）.

点击会话，右键点击属性

查看ssh连接是否生效

建立连接

写出一个类来验证

public class RedisDemo {
    public static void main(String[] args) {
        //连接到Redis服务器上
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            //redis的各种命令，就都对应到jedis对象的各种方法
            String pong=jedis.ping();
            System.out.println(pong);
        }
    }
}

常用命令实现

get/set

public class RedisDemo {
    public static void test1(Jedis jedis){
        System.out.println("get和set的使用");
        //先清空数据库
        jedis.flushAll();

        //set
        jedis.set("key","111");
        jedis.set("key2","222");

        //get
        String value=jedis.get("key");
        System.out.println("value="+value);
    }

    public static void main(String[] args) {
        //连接到Redis服务器上
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test1(jedis);
        }
    }
}

设置超时时间

public class RedisDemo {
    public static void test1(Jedis jedis){
        System.out.println("get和set的使用");
        //先清空数据库
        jedis.flushAll();

        //set
        jedis.set("key","111");
        jedis.set("key2","222");
        SetParams params=new SetParams();
        params.ex(10);
        params.xx();
        jedis.set("key","333",params);

        //get
        String value=jedis.get("key");
        System.out.println("value="+value);
    }


    public static void main(String[] args) {
        //连接到Redis服务器上
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){

            test1(jedis);
        }
    }
}

exists/del

public class RedisDemo {

    public static void test2(Jedis jedis){
        System.out.println("exists和del");
        jedis.flushAll();

        jedis.set("key","111");
        jedis.set("key2","222");

        boolean result=jedis.exists("key");
        System.out.println("result:"+result);
        
        long result2=jedis.del("key");
        System.out.println("result2:"+result2);

        result=jedis.exists("key");
        System.out.println("result:"+result);
    }

    public static void main(String[] args) {
        //连接到Redis服务器上
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test2(jedis);
        }
    }
}

keys

public class RedisDemo {

    public static void test3(Jedis jedis){
        System.out.println("keys");
        jedis.flushAll();

        jedis.set("key","111");
        jedis.set("key2","222");
        jedis.set("key3","333");
        jedis.set("key4","444");

        Set<String> keys=jedis.keys("*");
        System.out.println(keys);
    }

    public static void main(String[] args) {
        //连接到Redis服务器上
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test3(jedis);
        }
    }
}

expire和ttl

public class RedisDemo {

    public static void test4(Jedis jedis){
        System.out.println("expire和ttl");
        jedis.flushAll();

        jedis.set("key","111");
        jedis.expire("key",10);

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Long time=jedis.ttl("key");
        System.out.println("time:"+time);
    }

    public static void main(String[] args) {
        //连接到Redis服务器上
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test4(jedis);
        }
    }
}

type

public class RedisDemo {

    public static void test5(Jedis jedis){
        System.out.println("type");
        jedis.flushAll();

        jedis.set("key","111");
        String type=jedis.type("key");
        System.out.println("type:"+type);

        jedis.lpush("key2","111","222","333");
        type=jedis.type("key2");
        System.out.println("type:"+type);

        jedis.hset("key3","f1","111");
        type=jedis.type("key3");
        System.out.println("type:"+type);

        jedis.sadd("key4","111","222","333");
        type=jedis.type("key4");
        System.out.println("type:"+type);

        jedis.zadd("key5",10,"zhangsan");
        type=jedis.type("key5");
        System.out.println("type:"+type);
    }

    public static void main(String[] args) {
        //连接到Redis服务器上
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test5(jedis);
        }
    }
}

字符串（String）

mget和mset

public class RedisDemoString {

    public static void test1(Jedis jedis){
        System.out.println("mget和mset");
        jedis.flushAll();

        jedis.mset("key1","111","key2","222","key3","333");

        List<String> values=jedis.mget("key1","key2","key3");
        System.out.println("values:"+values);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test1(jedis);
        }
    }
}

getrange和setrange

public class RedisDemoString {
    public static void test2(Jedis jedis){
        System.out.println("getrange和setrange");
        jedis.flushAll();

        jedis.set("key","abjskjdcd");
        String result=jedis.getrange("key",2,5);
        System.out.println("result:"+result);

        jedis.setrange("key",2,"xyz");
        String value=jedis.get("key");
        System.out.println("value:"+value);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test2(jedis);
        }
    }
}

append

public class RedisDemoString {
    public static void test3(Jedis jedis){
        System.out.println("append");
        jedis.flushAll();

        jedis.set("key","abcdef");
        jedis.append("key","ghij");

        String value=jedis.get("key");
        System.out.println("value:"+value);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test3(jedis);
        }
    }
}

incr和decr

public class RedisDemoString {
    public static void test4(Jedis jedis){
        System.out.println("incr和decr");
        jedis.flushAll();

        jedis.set("key","100");

        long result=jedis.incr("key");
        System.out.println("result:"+result);

        String value=jedis.get("key");
        System.out.println("value:"+value);

        result=jedis.decr("key");
        System.out.println("result:"+result);

        value=jedis.get("key");
        System.out.println("value:"+value);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test4(jedis);
        }
    }
}

列表（list）

lpush和lrange

public class RedisDemoList {

    public static void test1(Jedis jedis){
        System.out.println("lpush和lrange");
        jedis.flushAll();

        jedis.lpush("key","111","222","333");

        List<String> result=jedis.lrange("key",0,-1);
        System.out.println(result);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test1(jedis);
        }
    }
}

rpush

public class RedisDemoList {

    public static void test2(Jedis jedis){
        System.out.println("rpush");
        jedis.flushAll();

        jedis.rpush("key","111","222","333");

        List<String> result=jedis.lrange("key",0,-1);
        System.out.println(result);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test2(jedis);
        }
    }
}

lpop

public class RedisDemoList {

    public static void test3(Jedis jedis){
        System.out.println("lpop");
        jedis.flushAll();

        jedis.rpush("key","111","222","333");
        String result=jedis.lpop("key");
        System.out.println("result:"+result);

        result=jedis.lpop("key");
        System.out.println("result:"+result);

        result=jedis.lpop("key");
        System.out.println("result:"+result);

        result=jedis.lpop("key");
        System.out.println("result:"+result);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test3(jedis);
        }
    }
}

rpop

public class RedisDemoList {

    public static void test4(Jedis jedis){
        System.out.println("lpop");
        jedis.flushAll();

        jedis.rpush("key","111","222","333");
        String result=jedis.rpop("key");
        System.out.println("result:"+result);

        result=jedis.rpop("key");
        System.out.println("result:"+result);

        result=jedis.rpop("key");
        System.out.println("result:"+result);

        result=jedis.rpop("key");
        System.out.println("result:"+result);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test4(jedis);
        }
    }
}

blpop

public class RedisDemoList {

    public static void test5(Jedis jedis){
        System.out.println("blpop");
        jedis.flushAll();

        //返回结果是一个“二元组”，一个是从哪个key对应的list中删除的，一个是删除的元素是什么
        List<String> results=jedis.blpop(100,"key");
        System.out.println("result[0]:"+results.get(0));
        System.out.println("result[1]:"+results.get(1));
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test5(jedis);
        }
    }
}

llen

public class RedisDemoList {

    public static void test6(Jedis jedis){
        System.out.println("llen");
        jedis.flushAll();

        jedis.rpush("key","111","222","333");
        long len= jedis.llen("key");
        System.out.println("len:"+len);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test5(jedis);
        }
    }
}

集合（set）

sadd和smembers

public class RedisDemoSet {

    public static void test1(Jedis jedis){
        System.out.println("sadd和smembers");
        jedis.flushAll();

        jedis.sadd("key","111","222","333");
        Set<String> result=jedis.smembers("key");
        System.out.println("result:"+result);
    }


    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test1(jedis);
        }
    }
}

sismember

public class RedisDemoSet {

    public static void test2(Jedis jedis){
        System.out.println("sismember");
        jedis.flushAll();

        jedis.sadd("key","111","222","333");
        boolean result=jedis.sismember("key","111");
        System.out.println("result:"+result);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test2(jedis);
        }
    }
}

scard

public class RedisDemoSet {

    public static void test3(Jedis jedis){
        System.out.println("scard");
        jedis.flushAll();

        jedis.sadd("key","111","222","333");
        long result=jedis.scard("key");
        System.out.println("result:"+result);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test3(jedis);
        }
    }
}

spop

public class RedisDemoSet {

    public static void test4(Jedis jedis){
        System.out.println("spop");
        jedis.flushAll();

        jedis.sadd("key","111","222","333","444","555");
        String result=jedis.spop("key");
        System.out.println("result:"+result);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test4(jedis);
        }
    }
}

sinter

public class RedisDemoSet {

    //求交集
    public static void test5(Jedis jedis){
        System.out.println("sinter");
        jedis.flushAll();

        jedis.sadd("key","111","222","333");
        jedis.sadd("key2","111","222","444");

        Set<String> result=jedis.sinter("key","key2");
        System.out.println("result:"+result);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test5(jedis);
        }
    }
}

sinterstore

public class RedisDemoSet {

    public static void test6(Jedis jedis){
        System.out.println("sinterstore");
        jedis.flushAll();

        jedis.sadd("key","111","222","333");
        jedis.sadd("key2","111","222","444");

        long len=jedis.sinterstore("key3","key","key2");
        System.out.println("len:"+len);

        Set<String> result=jedis.smembers("key3");
        System.out.println("result:"+result);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test6(jedis);
        }
    }
}

哈希（hash）

hset和hget

public class RedisDemoHash {

    public static void test1(Jedis jedis){
        System.out.println("hset和hget");
        jedis.flushAll();

        jedis.hset("key","f1","111");
        Map<String,String> fields=new HashMap<>();
        fields.put("f2","222");
        fields.put("f3","333");
        jedis.hset("key",fields);

        String result=jedis.hget("key","f1");
        System.out.println("result:"+result);

        result=jedis.hget("key","f2");
        System.out.println("result:"+result);

        result=jedis.hget("key","f10");
        System.out.println("result:"+result);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test1(jedis);
        }
    }
}

hexists

public class RedisDemoHash {

    public static void test2(Jedis jedis){
        System.out.println("hexists");
        jedis.flushAll();

        jedis.hset("key","f1","111");
        jedis.hset("key","f2","222");
        jedis.hset("key","f3","333");

        boolean result=jedis.hexists("key","f1");
        System.out.println("result:"+result);

        result=jedis.hexists("key","f100");
        System.out.println("result:"+result);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test2(jedis);
        }
    }
}

hdel

public class RedisDemoHash {

    public static void test3(Jedis jedis){
        System.out.println("hdel");
        jedis.flushAll();

        jedis.hset("key","f1","111");
        jedis.hset("key","f2","111");
        jedis.hset("key","f3","111");

        long result=jedis.hdel("key","f1","f2");
        System.out.println("result:"+result);

        boolean exists= jedis.hexists("key","f1");
        System.out.println("exists:"+exists);
        exists= jedis.hexists("key","f2");
        System.out.println("exists:"+exists);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test3(jedis);
        }
    }
}

hkeys和hvals

public class RedisDemoHash {

    public static void test3(Jedis jedis){
        System.out.println("hkeys和hvals");
        jedis.flushAll();

        jedis.hset("key","f1","111");
        jedis.hset("key","f2","111");
        jedis.hset("key","f3","111");

        Set<String> fields=jedis.hkeys("key");
        List<String> vals=jedis.hvals("key");
        System.out.println("fields:"+fields);
        System.out.println("vals:"+vals);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test4(jedis);
        }
    }
}

hmget和hmset

public class RedisDemoHash {

    public static void test5(Jedis jedis){
        System.out.println("hmget和hmset");
        jedis.flushAll();

        Map<String,String> map=new HashMap<>();
        map.put("f1","111");
        map.put("f2","222");
        map.put("f3","333");
        jedis.hmset("key",map);

        List<String> values=jedis.hmget("key","f1","f2","f3");
        System.out.println("values:"+values);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test5(jedis);
        }
    }
}

有序集合（zset）

zadd和zrange

public class RedisDemoZSet {

    public static void test1(Jedis jedis){
        System.out.println("zadd和zrange");
        jedis.flushAll();

        jedis.zadd("key",10,"zhangsan");
        Map<String,Double> map=new HashMap<>();
        map.put("lisi",20.0);
        map.put("wangwu",30.0);
        jedis.zadd("key",map);

        List<String> members=jedis.zrange("key",0,-1);
        System.out.println("members:"+members);

        List<Tuple> memberWithScore=jedis.zrangeWithScores("key",0,-1);
        System.out.println("memberWithScore:"+memberWithScore);
        String member=memberWithScore.get(0).getElement();
        double score=memberWithScore.get(0).getScore();
        System.out.println("member:"+member+",score:"+score);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test1(jedis);
        }
    }
}

zcard

public class RedisDemoZSet {

    public static void test2(Jedis jedis){
        System.out.println("zcard");
        jedis.flushAll();

        jedis.zadd("key",10,"zhangsan");
        jedis.zadd("key",20,"lisi");
        jedis.zadd("key",30,"wangwu");
        
        long len=jedis.zcard("key");
        System.out.println("len:"+len);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test2(jedis);
        }
    }
}

zrem

public class RedisDemoZSet {

    public static void test3(Jedis jedis){
        System.out.println("zrem");
        jedis.flushAll();

        jedis.zadd("key",10,"zhangsan");
        jedis.zadd("key",20,"lisi");
        jedis.zadd("key",30,"wangwu");

        long n=jedis.zrem("key","zhangsan");
        System.out.println("n:"+n);

        List<Tuple> result=jedis.zrangeWithScores("key",0,-1);
        System.out.println("result:"+result);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test3(jedis);
        }
    }
}

zscore

public class RedisDemoZSet {

    public static void test4(Jedis jedis){
        System.out.println("score");
        jedis.flushAll();

        jedis.zadd("key",10,"zhangsan");
        jedis.zadd("key",20,"lisi");
        jedis.zadd("key",30,"wangwu");

        Double score=jedis.zscore("key","zhangsan");
        System.out.println("score:"+score);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test4(jedis);
        }
    }
}

zrank

public class RedisDemoZSet {

    public static void test5(Jedis jedis){
        System.out.println("zrank");
        jedis.flushAll();

        jedis.zadd("key",10,"zhangsan");
        jedis.zadd("key",20,"lisi");
        jedis.zadd("key",30,"wangwu");

        Long rank=jedis.zrank("key","zhangsan");
        System.out.println("rank:"+rank);
    }

    public static void main(String[] args) {
        JedisPool jedisPool=new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis=jedisPool.getResource()){
            test5(jedis);
        }
    }
}

SpringDataRedis

SpringDataRedis是Spring中数据操作的模块，包含对各种数据库的集成，其中Redis的集成模块就叫做SpringDataRedis，官网地址：https://spring.io/projects/spring-data-redis

  • 提供了对不同Redis客户端的整合（Lettuce和jedis）
  • 提供了RedisTemplate统一API来操作Redis
  • 支持Redis的发布订阅模式
  • 支持Redis哨兵和Redis集群
  • 支持基于Lettuce的响应式编程
  • 支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化
  • 支持基于Redis的JDKCollection实现

RedisTemplate工具类

其中封装了各中对Redis的操作，并且将不同数据类型的操作API封装到了不同的类型中

API返回值类型说明
redisTemplate.opsForValue()ValueOperations操作String类型数据
redisTemplate.opsForHash()HashOperations操作Hash类型数据
redisTemplate.opsForList()ListOperations操作List类型数据
redisTemplate.opsForSet()SetOperations操作Set类型数据
redisTemplate.opsForZSet()ZSetOperations操作ZSet类型数据
redisTemplate通用的命令

SpringDataRedis快速入门

引入依赖

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
		</dependency>

配置文件

spring:
  redis:
    host: 127.0.0.1
    port: 8888
    password:
    lettuce:
      pool:
        max-active: 8  #最大连接
        max-idle: 8  #最大空闲连接
        min-idle: 0  #最小空闲连接
        max-wait: 100  #连接等待时间

注入RedisTemplate

	@Autowired
	private RedisTemplate redisTemplate;

编写测试

	@Test
	void contextLoads() {
		//写入一条spring数据
		redisTemplate.opsForValue().set("name","baekhyun");
		//获取spring数据
		Object name=redisTemplate.opsForValue().get("name");
		System.out.println("name="+name);

SpringDataRedis的序列化方式

RedisTemplate可以接受任意Object作为值写入Redis，只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果如下所示：

这样可读性差而且内存占用较大

因此我们需要自定义RedisTemplate的序列化方式

方案一

1、自定义RedisTemplate；

2、修改RedisTemplate的序列化器GenericJackson2JsonRedisSerializer

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory connectionFactory){
        //创建RedisTemplate对象
        RedisTemplate<String,Object> template=new RedisTemplate<>();
        //设置连接工厂
        template.setConnectionFactory(connectionFactory);
        //创建JSON序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer=new GenericJackson2JsonRedisSerializer();
        //设置key的序列化
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        //设置value的序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        //返回
        return template;
    }

但是我们会发现存储后的数据 对象的类型占用内存大

为了节省空间，并不会使用JSON序列化器来处理value，而是统一使用String序列化器，要求只能存储String类型的key和value。当需要存储java对象时，手动完成对象的序列化和反序列化

方案二

1、使用StringRedisTemplate

2、写入Redis时，手动把对象序列化为json

3、读取Redis时，手动把读取到的JSON反序列化为对象

    @Autowired
	private StringRedisTemplate stringRedisTemplate;	

    private static final ObjectMapper mapper=new ObjectMapper();

	@Test
	void testSaveUser() throws JsonProcessingException {
		//创建对象
		User user=new User("do",30);
		//手动序列化
		String json=mapper.writeValueAsString(user);
		//写入数据
		stringRedisTemplate.opsForValue().set("user:200",json);
		//获取数据
		String jsonUser=stringRedisTemplate.opsForValue().get("user:200");
		//手动反序列化
		User user1=mapper.readValue(jsonUser,User.class);
		System.out.println("user1"+user1);
	}

构建一个类来测试redis的方法

string
//后续redis测试的各种方法，都通过这个Controller提供的http接口来触发
@RestController
public class MyController {

    @Autowired
    private StringRedisTemplate redisTemplate;

    @GetMapping("/testString")
    @ResponseBody
    public String testString(){
        redisTemplate.opsForValue().set("key","111");
        redisTemplate.opsForValue().set("key","222");
        redisTemplate.opsForValue().set("key","333");

        String value=redisTemplate.opsForValue().get("key");
        System.out.println("value:"+value);

        return "ok";
    }
}

界面效果

                                                

list
    @GetMapping("/testList")
    @ResponseBody
    public String testList(){
        //先清除之前的数据
        redisTemplate.execute((RedisConnection connection)->{
            connection.flushAll();
            return null;
        });
        redisTemplate.opsForList().leftPush("key","111");
        redisTemplate.opsForList().leftPush("key","222");
        redisTemplate.opsForList().leftPush("key","333");

        String value=redisTemplate.opsForList().rightPop("key");
        System.out.println("value:"+value);

        return "ok";
    }

set
    @GetMapping("/testSet")
    @ResponseBody
    public String testSet(){
        redisTemplate.execute((RedisConnection connection)->{
            connection.flushAll();
            return null;
        });
        redisTemplate.opsForSet().add("key","111","222","333");

        Set<String> result=redisTemplate.opsForSet().members("key");
        System.out.println("result:"+result);

        boolean exists=redisTemplate.opsForSet().isMember("key","111");
        System.out.println("exists:"+exists);

        Long count=redisTemplate.opsForSet().size("key");
        System.out.println("count:"+count);

        redisTemplate.opsForSet().remove("key","111","222");
        result=redisTemplate.opsForSet().members("key");
        System.out.println("result:"+result);
        return "ok";
    }

hash
    @GetMapping("/testHash")
    @ResponseBody
    public String testHash(){
        redisTemplate.execute((RedisConnection connection)->{
            connection.flushAll();
            return null;
        });
        redisTemplate.opsForHash().put("key","f1","111");
        redisTemplate.opsForHash().put("key","f2","222");
        redisTemplate.opsForHash().put("key","f3","333");

        String value= (String) redisTemplate.opsForHash().get("key","f1");
        System.out.println("value:"+value);

        Boolean exists=redisTemplate.opsForHash().hasKey("key","f1");
        System.out.println("exists:"+exists);

        Long size=redisTemplate.opsForHash().delete("key","f1","f2");
        System.out.println("size:"+size);

        return "ok";
    }

zset
    @GetMapping("/testZSet")
    @ResponseBody
    public String testZSet(){
        redisTemplate.execute((RedisConnection connection)->{
            connection.flushAll();
            return null;
        });
        redisTemplate.opsForZSet().add("key","zhangsan",10);
        redisTemplate.opsForZSet().add("key","lisi",20);
        redisTemplate.opsForZSet().add("key","wangwu",30);

        Set<String> members=redisTemplate.opsForZSet().range("key",0,-1);
        System.out.println("members:"+members);

        Set<ZSetOperations.TypedTuple<String>> memberWithScore=redisTemplate.opsForZSet().rangeWithScores("key",0,-1);
        System.out.println("memberWithScore:"+memberWithScore);

        Double score=redisTemplate.opsForZSet().score("key","zhangsan");
        System.out.println("score:"+score);

        redisTemplate.opsForZSet().remove("key","zhangsan");
        Long size=redisTemplate.opsForZSet().size("key");
        System.out.println("size:"+size);

        Long rank=redisTemplate.opsForZSet().rank("key","lisi");
        System.out.println("rank:"+rank);
        return "ok";
    }

啵啵虎的抽抽
关注
  • 22
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Zset如何操作Redis--基于Jedis，Java版
qq_44231797的博客
03-21 3012
文章目录1、Zset概念2、Zset语法3、Zset在Jedis的示例 1、Zset概念 Zset有序集合(sorted set)： 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员即元素唯一！ 每个元素都会关联一个double类型的分数(score)，redis正是通过这些分数(score)对集合中的元素进行排序。 有序集合的元素是唯一的,但分数(score)却可以重复。 集合中最大的元素数为 2^32 - 1 (4294967295, 每个集合可存储40多亿个元素)。 2
Redis - 5、Jedis操作Redis6
热门推荐
简单记录一下。
06-21 5万+
Jedis是java开发的操作redis的工具包。
Redis 基础 Jedis -- Jedis（Java程序操作Redis的工具）
天行健 君子以自强不息，地势坤 君子以厚德载物。
01-25 1万+
Jedis（Java程序操作Redis的工具）
springboot2.0整合redis--Jedis版本
我吃包菜
06-14 6385
springboot2.0整合redis–Jedis 本文讲解的客户端是使用Jedis springboot整合redis单机版 pom <!-- Spring Boot Redis依赖 --> <!-- 注意：1.5版本的依赖和2.0的依赖不一样，注意看哦 1.5我记得名字里面应该没有“data”, 2.0必须是“spring-boot-star...
Redis系列(一) --- Jedis 及 SpringDataRedis 快速入门
Fug_Lee的博客
10-19 1337
Jedis 及 SpringDataRedis 的使用, 快速入门.
Redis Java客户端Jedis 2.9.0 jar包（含common-pool2）
11-17
Redis的官方推荐Java客户端——Jedis 此Jar包为Jedis 2.9.0版（2016年7月22日发布） 支持Redis 3.0 （亲测有效） 使用方法： import redis.clients.jedis.Jedis; Jedis jedis = new Jedis("localhost"); jedis.set...
基于Jedis的Redis缓存操作SDK设计源码
05-30
本项目是基于Jedis的Redis缓存操作SDK设计源码，包含59个文件，主要文件类型为java、prefs、properties、classpath、gitignore、project、LICENSE和md。该项目适用于Redis缓存操作的开发和设计，为用户提供了一个...
tomcat-redis-session-manager-master-2.0.0
08-19
tomcat-redis-session-manager-2.0.0.jar jedis-2.5.2.jar commons-pool2-2.2.jar 2.修改 conf 目录下的 context.xml 文件 host="localhost" port="6379" database="0" maxInactiveInterval="60" /> ...
redis博客总集-jedis连接redis的所有操作
09-18
redis博客总集-jedis连接redis的所有操作
tomcat-redis-session-manager for tomcat8.5
11-14
压缩文件包括tomcat-redis-session-manager-master-2.0.0.jar、jedis-2.7.3.jar、commons-pool2-2.3.jar三个jar包使用方法请参照https://github.com/jcoleman/tomcat-redis-session-manager。apache-tomcat-8.5.33....
Spring Security实现用户认证四：使用JWT与Redis实现无状态认证
不做菜虚困的博客
06-12 730
在基本的通信流程中，我们一般采用Session去存储用户的认证状态。在Spring Security实现用户认证三中讲过，在拿到前端传输过来的用户名和密码之后，会有专门的过滤器处理这部分的需求，并且对认证成功的用户生成Token且存储在Session中。在下次发起请求时，直接从Session中取出同用户名的token进行密码哈希的比较要认证用户。对于无状态认证，则我们的认证不依赖与服务器端存储的Session的状态。所以无状态认证需要我们每次从前端传输一个包含完整认证信息的Token到服务器端进行自定义的认
Redis的一点入门了解
qq_41680016的博客
06-11 950
泛指非关系型数据库的，随着web2.0互联网的诞生，传统的关系型数据库很难对付web2.0时代，尤其是超大规模的高并发的社区，渐渐暴露出很多难以克服的问题，而NoSQL在当今大数据环境下发展的十分迅速，Redis是发展的最快的，而且是我们当下必须要掌握的一门技术。核心：redis是将所有的数据全部放在内存中，所以说使用单线程去操作效率就是最高的，多线程（CPU上下文切换消耗的时间相对就比较多），对于内存系统来说，如果没有上下文切换，效率就是最高的，多次读写都在一个CPU上，怎能不快呢。
Redis的监控与调优：工具使用和性能提升技巧
哎 你看的博客
06-11 1036
I. 引言 A. 介绍Redis的重要性，以及为什么需要对Redis进行监控和调优 B. 概述本文的主要内容和目的 II. Redis监控工具的使用 A. 介绍Redis自带的监控工具，如INFO命令、MONITOR命令等 B. 介绍第三方的Redis监控工具，如Redisson PRO、Redis Insight等 C. 提供使用各种监控工具的实践示例和解读 III. Redis性能问题的诊断 A. 介绍如何使用监控工具发现Redis的性能问题，如内存泄漏、瓶颈等 B. 提供诊断性能问题的实践示例和解读
026、工具_redis-server
细致-专业-实操
06-12 248
整个内存检测的时间比较长。通常无需每次开启Redis实例时都执行–test-memory选项，该功能更偏向 于调试和测试，例如，想快速占满机器内存做一些极端条件的测试，这个功 能是一个不错的选择。redis-server除了启动Redis外，还有一个 --test-memory选项。
redis windos修复版本
清风
06-10 424
【代码】redis windos修复版本。
如何保证Redis与数据库的数据一致性
杨杨杨~~的博客
06-11 366
如果您觉得有用的话，记得给，写作不易啊^ _ ^。而且听说，实在白嫖的话，那欢迎常来啊!!!
关于 Redis 中集群
Undefined__yu的博客
06-10 1346
节点之间通过心跳包通信，心跳包中包含了该节点持有哪些 slots。这个是使用位图的结构表示的，表示 16384(16k)个 slots，需要的位图大小是 2KB。如果给定的 slots 数更多了，则需要消耗更多的空间，8KB来表示。这样的空间虽然对于内存来说不算什么，但是在频繁的网络心跳包中，是一个不小的开销。另一方面，Redis 集群一般不建议超过 1000 个分片。所以 16K 对于最大 1000 个分片来说是足够用的，同时也会使对应的槽位配置位图体积不至于很大。
docker-compose部署mysql+nginx+redis
yy1209357299的博客
06-10 403
1、创建docker-compose-mysql.yml。1、创建docker-compose-nginx.yml。1、创建docker-compose-redis.yml。
【Redis 分布式锁】
最新发布
m0_50116974的博客
06-13 748
不同的进程需要以互斥的方式来访问共享资源，这里实现互斥就是分布式锁。简单来说就是：同一时间只有一个客户端对共享资源操作。举个实际例子，抢购茅台，如果不加锁就会发生超卖的事故。分布式锁实现方式有很多中， mysql，zookeeper，redis，本文主要讲 redis 的实现方式。
spring-data-starter-redis-2.1.1 jedis
05-19
`spring-data-starter-redis-2.1.1` 是 Spring Data Redis 的一个版本，用于在 Spring 框架中集成 Redis 数据库。`jedis` 是 Redis 官方推荐的 Java 客户端库之一，用于与 Redis 服务器进行通信。在 Spring Data ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值