3.3 Java中操作redis

蟑螂恶霸不是恶霸

已于 2023-07-26 22:54:57 修改

阅读量3.4k

点赞数 6

分类专栏：零基础入门到就业--JAVA篇文章标签： redis java 缓存

于 2021-12-09 10:36:29 首次发布

本文链接：https://blog.csdn.net/whatfuswd/article/details/121806023

版权

零基础入门到就业--JAVA篇专栏收录该内容

224 篇文章 5 订阅

订阅专栏

文章目录

1.准备工作
2.Jedis的基本应用
3.RedisTemplate基本应用
4.基于Redis的项目业务分析及实践
5.SpringBoot工程中Redis与Aop技术的整合

1.准备工作

1.1 创建工程

创建maven父工程，例如redis,并在此工程下创建两个子工程，一个为sca-jedis（普通maven工程）,一个为sca-tempate（spring-boot工程）,例如：
在这里插入图片描述

1.2 添加项目依赖

修改父工程pom.xml文件，添加编译配置

<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

在sca-jedis 工程添加依赖

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

 <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
 </dependency>

 <dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.6</version>
 </dependency>
<dependencies>

在sca-template工程添加依赖

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.3.2.RELEASE</version>
                <scope>import</scope>
                <type>pom</type>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

1.3 项目背景

Jedis是redis的java版本的客户端实现，使用Jedis提供的Java API对Redis进行操作，是Redis官方推崇的方式；常用的五种数据类型，string、hash、set、zset/list并且，使用Jedis提供的对Redis的支持也最为灵活、全面；

而RedisTemplate是SpringDataRedis中对JedisAPI的高度封装，SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端，比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用；

2.Jedis的基本应用

2.1 简介

Jedis是Java中操作redis的一个客户端，类似通过jdbc访问mysql数据库。

2.2 准备工作

第一步:从redis.io官方下载对应版本的redis.conf文件,地址如下(假如下载不下来可以私聊我获取):：https://redis.io/topics/config/
第二步:停止redis并删除挂载目录下(/usr/local/docker/redis01/conf)的redis.conf配置文件.
第三步:将下载的redis.conf文件拷贝到redis挂载目录(/usr/local/docker/redis01/conf)
第四步:基于vim打开redis.conf文件,然后注释 bind 127.0.0.1这一行,并修改protected-mode的值修改为no.
第五步:重启redis服务,并检查启动日志(docker logs 容器id)

2.3 Jeids基本应用实践

在Jedis工程中的src/test/java目录创建单元测类,例如:

package com.jt;

import org.junit.Test;
import redis.clients.jedis.Jedis;

import java.util.concurrent.TimeUnit;

public class JedisTests {
	  /**
     * 测试能否连接到远端的redis
     * */
    @Test
    public void testGetConnection(){
        //假如不能连通,要注释掉redis.conf中 bind 127.0.0.1,
        //并将protected-mode的值修改为no,然后重启redis再试
        Jedis jedis=new Jedis("192.168.126.168",6379);
        //jedis.auth("123456");//假如在redis.conf中设置了密码
        String ping = jedis.ping();
        System.out.println(ping);	//输出PONG
    }

    //字符串类型练习
    @Test
    public void testStringOper() throws InterruptedException {
        //建立链接(与redis建立链接)
        Jedis jedis=new Jedis("192.168.126.168",6379);
        //存储数据(key/value)
        jedis.set("count","1");
        jedis.set("id","10001");
        jedis.set("content","aaaaaaaadfas");
        //更新数据
        jedis.expire("id",1);//设置key的有效时长
        jedis.incr("count");//对key的值进行自增操作
        jedis.set("name", "jack");//相同的key执行的是覆盖操作
        //获取数据
        String count = jedis.get("count");
        //TimeUnit是Java中枚举类型,SECONDS为枚举类型的实例,sleep底层会调用Thread.sleep()方法
        //TimeUnit.SECONDS.sleep(1);//休眠一秒
        Thread.sleep(1000);
        String id=jedis.get("id");
        Long num=jedis.strlen("content");
        System.out.println("cart.count="+count);
        System.out.println("id="+id);//有效期设置为1s，休眠1s，所以此时值为null
        System.out.println("num="+num);
        //释放资源
        jedis.close();
    }
//json数据练习
@Test
 public void testJsonOper(){
     //构建对象
      Map<String,Object> map=new HashMap<>();
      map.put("id",100);
      map.put("title","spring 认证");
      map.put("content","very good");
     //将对象转换为json格式字符串
      Gson gson=new Gson();
      String jsonStr=gson.toJson(map);
      //将json字符串写入到redis
      Jedis jedis=new Jedis("192.168.126.168",6379);
      jedis.set("user",jsonStr);
      //读取redis中数据
      jsonStr=jedis.get("user");
      System.out.println(jsonStr);
      //将其转换为Map格式
      Map<String,Object> obj=gson.fromJson(jsonStr,Map.class);
      System.out.println(obj);
      jedis.close();
 }
//hash类型练习
   @Test
    public void testHashOper01(){
        //1.建立连接
        Jedis jedis=new Jedis("192.168.126.168",6379);
        //2.基于hash类型存储对象信息
        jedis.hset("member","id","101");
        jedis.hset("member","username","jack");
        jedis.hset("member","mobile","3333333");
        //3.更新hash类型存储的数据
        jedis.hset("member","username","tony");
        //4.获取hash类型数据信息
        String username=jedis.hget("member","username");
        String mobile = jedis.hget("member", "mobile");
        System.out.println(username);
        System.out.println(mobile);
        //5.存储token信息
        String token = UUID.randomUUID().toString();
        jedis.hset(token,"id", "1");
        jedis.hset(token,"name", "tony");
        jedis.expire(token, 10);
        Map<String, String> userMap = jedis.hgetAll(token);
        System.out.println(userMap);
        //5.释放资源
        jedis.close();
    }
//hash类型练习（直接存储map对象）
@Test
public void testHashOper02(){
    //1.建立连接
    Jedis jedis=new Jedis("192.168.126.168",6379);
    //2.存储一篇博客信息
    Map<String,String> map=new HashMap<>();
    map.put("x","100");
    map.put("y","200");
    jedis.hset("point",map);
    //3.获取博客内容并输出
    map=jedis.hgetAll("point");
    System.out.println(map);
    //4.释放资源
    jedis.close();
}
   /**
     * 测试:redis中list结构的应用
     * 基于FIFO(First In First Out)算法,借助redis实现一个队列
     */
    @Test
    public void testListOper01(){
        //1.建立连接
        Jedis jedis=new Jedis("192.168.126.168",6379);
        //2.存储数据
        jedis.lpush("lst1","A","B","C","C");
        //3.更新数据
        Long pos=jedis.lpos("lst1","A");//获取A元素的位置
        jedis.lset("lst1",pos,"D");//将A元素位置的内容修改为D
        //4.获取数据
        int len=jedis.llen("lst1").intValue();//获取lst1列表中元素个数
        List<String> rpop = jedis.rpop("lst1",len);//获取lst1列表中所有元素
        System.out.println(rpop);
        //5.释放资源
        jedis.close();
    }



//list类型练习：实现一个阻塞式队列

@Test
public void testListOper02(){
    //1.连接redis
    Jedis jedis=new Jedis("192.168.126.128",6379);
    //2.向队列存数据
    //jedis.lpush("list1","A","B","C");
    //3.按先进先出的顺序从队列取数据
    List<String> list= jedis.brpop(40,"list1");
    System.out.println(list);
    jedis.brpop(40,"list1");
    jedis.brpop(40,"list1");
    jedis.brpop(40,"list1");
    //4.释放资源
    jedis.close();
}
//set类型练习
@Test
public void testSetOper01() {
    //1.连接redis
    Jedis jedis = new Jedis("192.168.126.128", 6379);
    //2.朋友圈点赞
    jedis.sadd("count", "1", "1", "2");
    //3.取出点赞数
    Set<String> set = jedis.smembers("count");
    System.out.println(set);
    //4.释放资源
    jedis.close();
}
}

2.4 连接池JedisPool连接池应用

我们直接基于Jedis访问redis时，每次获取连接，释放连接会带来很大的性能开销，可以借助Jedis连接池，重用创建好的连接，来提高其性能，在实际的开发中，涉及到数据库的操作，基本都会通过连接池来进行，其简易应用方式如下：

package com.jt;

import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;


public class JedisPoolTests {
    @Test
   public void testJedisPool(){
        //定义连接池的配置
        JedisPoolConfig config=new JedisPoolConfig();
        config.setMaxTotal(1000);//最大连接数
        config.setMaxIdle(60);//最大空闲数
        //创建连接池
        JedisPool jedisPool=
        new JedisPool(config,"192.168.126.168",6379);
        //从池中获取一个连接
        Jedis resource = jedisPool.getResource();
        //如果redis设置了密码则要输入密码
        resource.auth("123456");
        //通过jedis连接存取数据
        resource.set("class","study");
        String clazz=resource.get("class");
        System.out.println(clazz);
        //将链接返回池中
        resource.close();
        //关闭连接池
        jedisPool.close();	
    }
}

我们可以基于池对象，设计一个数据源，将来在业务中通过一个数据源对象，从池中获取连接，不用每次获取连接都要创建池对象，例如：

package com.jt.redis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisDataSource {

    private static final String IP="192.168.126.168";
    private static final int PORT=6379;//redis.conf 默认端口
    /**
     * volatile 关键字通常用于修饰属性:
     * 1)保证线程其可见性(一个线程改了,其它CPU线程立刻可见)
     * 2)禁止指令重排序 
     * 3)不能保证其原子性(不保证线程安全)
     */
    private static volatile JedisPool jedisPool;
    //方案1:饿汉式池对象的创建
    /*static{
        JedisPoolConfig config=new JedisPoolConfig();
        config.setMaxTotal(16);
        config.setMaxIdle(8);
        jedisPool=new JedisPool(config,IP,PORT);
    }
    public static Jedis getConnection(){
        return jedisPool.getResource();
    }*/
    //方案2:懒汉式池对象的创建
    public static Jedis getConnection(){
        if(jedisPool==null) {
            synchronized (JedisDataSource.class) {
                if (jedisPool == null) {
                    JedisPoolConfig config = new JedisPoolConfig();
                    config.setMaxTotal(16);
                    config.setMaxIdle(8);
                    jedisPool = new JedisPool(config, IP, PORT);
                    //创建对象分析
                    //1.开辟内存空间
                    //2.执行属性的默认初始化
                    //3.执行构造方法
                    //4.将创建的对象的内存地址赋值给jedisPool变量
                    //假如使用了volatile修饰jedisPool变量,可以保证如上几个步骤是顺序执行的
                }
            }
        }
        return jedisPool.getResource();
    }
    public static void close(){
        jedisPool.close();
    }
}

当执行jedisPool = new JedisPool(config, IP, PORT);创建对象可能有以下几个步骤：

开辟内存空间
执行属性的默认初始化
执行构造方法
将创建的对象的内存地址赋值给jedisPool变量

当使用饿汉式方式创建线程池时，可以不加volatile关键字，但当使用懒汉式创建方式时，需要添加；饿汉式创建只要类加载对象就会初始化创建对象，不会存在线程冲突问题；

而饿汉式在使用时才会创建，当执行线程创建时，JVM会自动对指令有重排序的优化机制，可能导致线程不按照顺序执行，可能会出现线程开辟内存空间后，直接将内存地址赋值给jedisPool变量，此时外层的变量判断已经不为空了，会去取连接，但是此时jedisPool引用变量还没来得及初始化，还无法正确获取连接；

使用volatile关键字可以禁止指令重排序，按照代码顺序进行执行，避免此类问题的出现；同时，其还可以保证可见性，一个线程修改了值后，其他线程可以立即获知，避免无谓的等待和重新执行；

3.RedisTemplate基本应用

3.1 简介

RedisTemplate为SpringBoot工程中操作redis数据库的一个Java对象，此对象封装了对redis的一些基本操作。

3.2 准备工作

第一步：创建工程配置文件application.yml,其内容如下：

spring:
  redis:
    host: 192.168.126.168  #写自己的ip
    port: 6379

第二步：创建工程启动类，例如：

package com.jt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RedisApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisApplication.class,args);
    }
}

3.3 RedisTemplate对象应用实践

RedisTemplate是一个专门用于实现对远端redis数据进行操作的对象，默认会采用JDK序列化方式存取数据，应用案例如下：

package com.jt;

import com.jt.pojo.Blog;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTemplateTests {
    /**
     * RedisTemplate是spring工程中提供的一个用于操作redis数据库的API
     * 此对象采用了模板方法模式，对操作redis的步骤进行了相关的封装
     * 定义了一些具体方法，后续就可以基于这些方法实现对redis数据库的读写操作
     * 在springboot工程的RedisAutoConfiguration类中已经做了配置
     * 在基于redis存取数据时默认采用的JDK的序列化方式
     * 此对象会在springboot工程启动时自动创建，但在测试类中，因为容器没有启动，所以此处注入的值为null
     * 需要添加添加`@RunWith(SpringRunner.class)`注解启动spring容器来执行测试
     * */
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testGetConnection(){
        RedisConnection connection = redisTemplate.getRequiredConnectionFactory().getConnection();
        String ping = connection.ping();
        System.out.println(ping);
    }

    /**
     * 测试字符串数据的存取
     */
    @Test
    public void testStringOper01(){
        //获取字符串操作对象，自己设定key/value序列化方式
        ValueOperations vo = redisTemplate.opsForValue();
        //key和value默认会采用JDK的序列化方式进行存储,我们将其改为序列化字符串对象
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setValueSerializer(RedisSerializer.string());
        vo.set("id", "1");
        vo.set("token", UUID.randomUUID().toString());
        vo.increment("id");
        Object token =vo.get("token");
        Object id =vo.get("id");
        System.out.printf("id=%s；token=%s",id,token);
    }

    /**通过此方法操作redis中的hash数据*/
    @Test
    public void testHashOper(){
        HashOperations hs = redisTemplate.opsForHash();
        HashMap<Object, Object> blog = new HashMap<>();
        blog.put("id", "1");
        blog.put("title", "hello redis");
        hs.putAll("blog", blog);
        hs.put("blog", "content", "redis is good");
        Object id = hs.get("blog", "id");
        System.out.println(id);
        Map entrie = hs.entries("blog");
        System.out.println(entrie);
    }

    /**通过此方法操作redis中的list数据*/
    @Test
    public void testListOper(){
        //向list集合放数据
        ListOperations listOperations = redisTemplate.opsForList();
        listOperations.leftPush("lstKey1", "100"); //lpush
        listOperations.leftPushAll("lstKey1", "200","300");
        listOperations.leftPush("lstKey1", "100", "105");
        listOperations.rightPush("lstKey1", "700");
        Object value= listOperations.range("lstKey1", 0, -1);
        System.out.println(value);
        //向list集合取数据
        Object v1=listOperations.leftPop("lstKey1");//lpop
        System.out.println("left.pop.0="+v1);
        value= listOperations.range("lstKey1", 0, -1);
        System.out.println(value);
    }

    /**通过此方法操作redis中的set数据*/
    @Test
    public void testSetOper(){
        SetOperations setOperations=redisTemplate.opsForSet();
        setOperations.add("setKey1", "A","B","C","C");
        Object members=setOperations.members("setKey1");
        System.out.println("setKeys="+members);
    }

    /**
     * 创建一个pojo类型，测试通过redis向对象中存入数据
     * */
    @Test
    public void testHashBlog(){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //基于hash操作对象读写redis数据
        Blog blog = new Blog();
        blog.setId(100);
        blog.setTitle("hello redis");
        valueOperations.set("blog", blog);
        System.out.println(blog);
    }

    //清除数据库中所有内容
    @Test
    public void testFlushdb() {
        redisTemplate.execute(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
                //redisConnection.flushDb();
                redisConnection.flushAll();
                return "flush ok";
            }
        });
    }
}

添加@RunWith(SpringRunner.class)注解是因为我们在注入RedisTemplate时，因为容器是没有启动的，所以单纯的测试无法注入，添加此注解后启动的话是启动spring容器来执行测试，这样可以避免RedisTemplate注入时的空指针异常；

3.4 StringRedisTemplate 对象应用实践

StringRedisTemplate 是一个特殊的RedisTemplate对象，继承了RedisTemplate，默认基于字符串序列化方式存取数据，其应用方式如下：

package com.jt;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@SpringBootTest
public class StringRedisTemplateTests {
    /**
     * 此对象为操作redis的一个客户端对象
     * 这个对象对key/value采用了字符串的序列化(StringRedisSerializer)方式进行,redis数据的读写操作.
     */
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testHashOper01(){
       //1.获取hash操作的对象
        HashOperations<String, Object, Object> vo =stringRedisTemplate.opsForHash();
       //2.读写redis数据
       //2.1存储一个对象
       vo.put("user", "id", "100");
       vo.put("user", "username", "tony");
       vo.put("user", "status", "1");
       //2.2获取一个对象
       //2.2.1获取对象某个属性值
       Object status =vo.get("user","status");
       System.out.println(status);
        //2.2.2获取对象的所有key
        Set<Object> userKey = vo.keys("user");
        System.out.println(userKey);
        //2.2.3获取对象某个key对应的所有值
        List<Object> userValue = vo.values("user");
        System.out.println(userValue);
    }
    @Test
    void testStringOper02() throws JsonProcessingException {
        //1.获取字符串操作对象(ValueOperations)
        ValueOperations<String, String> vo =
                stringRedisTemplate.opsForValue();
        //2.读写redis中的数据
        Map<String,String> map=new HashMap<>();
        map.put("id","100");
        map.put("title","StringRedisTemplate");
        //将map对象转换为json字符串写到redis数据库
        String jsonStr=//jackson (spring-boot-starter-web依赖中自带)
        new ObjectMapper().writeValueAsString(map);
        vo.set("blog", jsonStr);
        jsonStr=vo.get("blog");
        System.out.println(jsonStr);
        //将json字符串转换为map对象
        map=
        new ObjectMapper().readValue(jsonStr, Map.class);
        System.out.println(map);
    }
    @Test
    void testStringOper01(){
        //1.获取字符串操作对象(ValueOperations)
        ValueOperations<String, String> vo =
                stringRedisTemplate.opsForValue();
        //2.读写redis中的数据
        vo.set("x", "100");
        vo.increment("x");
        vo.set("y", "200", 1, TimeUnit.SECONDS);
        String x = vo.get("x");
        String y = vo.get("y");
        System.out.println("x="+x+",y="+y);
    }
    /**
     * 将Blog对象转换为json串的方式写入redis数据库并进行输出
     * */
    @Test
    public void testBlogJson(){
        //创建Blog对象
        Blog blog = new Blog();
        blog.setId(2);
        blog.setTitle("json格式写入");
        //将Blog对象以json方式写入redis
        redisTemplate.setValueSerializer(RedisSerializer.json());
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("blog", blog);
        //读取数据并进行输出
        Object blog1 = (Blog)valueOperations.get("blog");	//这里要使用强转，不然序列化中不带对象类型，容易导致反序列化失败
        System.out.println(blog1);
    }
}

3.5 基于业务定制RedisTemplate对象(拓展)

我们知道系统中的RedisTemplate默认采用的是JDK的序列化机制，假如我们不希望使用默认的JDK方式序列化，可以对RedisTemplate对象进行定制，指定自己的序列化方式，例如：

package com.jt;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import java.net.UnknownHostException;

@Configuration
public class RedisConfig {//RedisAutoConfiguration
    //自定义json序列化
    @Bean
    public RedisSerializer jsonSerializer(){
        //1.定义Redis序列化,反序列化规范对象(此对象底层通过ObjectMapper完成对象序列化和反序列化)
        Jackson2JsonRedisSerializer serializer= new Jackson2JsonRedisSerializer(Object.class);
        //2.创建ObjectMapper(由jackson api库提供)对象,基于此对象进行序列化和反序列化
        //2.1创建ObjectMapper对象
        ObjectMapper objectMapper=new ObjectMapper();
        //2.2设置按哪些方法规则进行序列化
        objectMapper.setVisibility(PropertyAccessor.GETTER,//get方法
                JsonAutoDetect.Visibility.ANY);//Any 表示任意方法访问修饰符
        //2.3对象属性值为null时,不进行序列化存储
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        //2.4激活序列化类型存储,对象序列化时还会将对象的类型存储到redis数据库
        //假如没有这个配置,redis存储数据时不存储类型,反序列化时会默认将其数据存储到map
        objectMapper.activateDefaultTyping(
                objectMapper.getPolymorphicTypeValidator(),//多态校验分析
                ObjectMapper.DefaultTyping.NON_FINAL,//激活序列化类型存储,类不能使用final修饰
                JsonTypeInfo.As.PROPERTY);//PROPERTY 表示类型会以json对象属性形式存储
        serializer.setObjectMapper(objectMapper);
        return serializer;
    }
    //高级定制
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        //设置key的序列化方式
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        //设置值的序列化方式，共会调用2次jsonSerializer对象，为了避免重复创建对象，所以在jsonSerializer类上添加@Bean注解
        template.setValueSerializer(jsonSerializer());
        template.setHashValueSerializer(jsonSerializer());
        //更新一下RedisTemplate对象的默认配置
        template.afterPropertiesSet();
        return template;
    }

    //简单定制
//    @Bean
//    public RedisTemplate<Object, Object> redisTemplate(
//            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
//        RedisTemplate<Object, Object> template = new RedisTemplate();
//        template.setConnectionFactory(redisConnectionFactory);
//        //设置key的序列化方式(hash为（key,value(key,value))结构，需要单独设置其中包裹的hash的key的序列化方式
//        template.setKeySerializer(RedisSerializer.string());
//        template.setHashKeySerializer(RedisSerializer.string());
//        //设置值的序列化方式
//        template.setValueSerializer(RedisSerializer.json());
//        template.setHashValueSerializer(RedisSerializer.json());
//        return template;
//    }
}

创建Blog对象,然后基于RedisTemplate进行序列化实践,Blog代码如下

package com.jt.redis.pojo;

import java.io.Serializable;

public class Blog implements Serializable {//{"id":10,"title":"redis"}
    private static final long serialVersionUID = -6721670401642138021L;
    private Integer id;
    private String title;
    public Blog(){
        System.out.println("Blog()");
    }
    public Blog(Integer id,String title){
        this.id=id;
        this.title=title;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
    @Override
    public String toString() {
        return "Blog{" +
                "id=" + id +
                ", title='" + title + '\'' +
                '}';
    }
}

在RedisTemplateTests类中添加如下单元测试方法,进行测试,例如:

@Test
void testJsonOper() throws JsonProcessingException {
    ValueOperations valueOperations = redisTemplate.opsForValue();
    Blog blog=new Blog(10,"study redis");
    valueOperations.set("blog",blog);//序列化
    blog=(Blog)valueOperations.get("blog");//反序列化
    System.out.println("blog="+blog);
}

4.基于Redis的项目业务分析及实践

4.1 简易分布式id设计及实现

业务描述
在分布式系统中，数据量将越来越大时，就需要对数据进行分表操作,但是,分表后，每个表中的数据都会按自己的节奏进行自增，很有可能出现ID冲突。这时就需要一个单独的机制来负责生成唯一ID，生成出来的ID也可以叫做分布式ID，这里我们借助redis实现一个简易的分布式id进行实现,当然还有一些第三方的系统,可以帮你生成这样的id,可以自己进行拓展学习.
关键代码实现

package com.jt.redis;

import redis.clients.jedis.Jedis;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 需求:生成一个分布递增的id
 * 多张表基于这个方法中生成的id作为主键id值(分布式环境不会采用数据库
 * 表中自带的自增策略-auto_increment)
 */
public class IdGeneratorDemo01 {
    public static Long getId(){
          Jedis jedis=new Jedis("192.168.126.168",6379);
          //jedis.auth("123456");//假如redis设置了密码,连接redis时需要指定密码
          Long id = jedis.incr("id");
          jedis.close();
          return id;
    }
    //自己创建线程执行任务
    static void execute01(){
         for(int i=0;i<10;i++) {
              new Thread(){
                  @Override
                  public void run() {
                      String tName=Thread.currentThread().getName();
                      System.out.println(tName+"->"+
                              IdGeneratorDemo01.getId());
                  }
              }.start();
          }
    }
     //基于线程池执行任务  
     static void execute02(){
      //构建一个最多只有3个线程的线程池
        ExecutorService es=
        Executors.newFixedThreadPool(3);
        for(int i=1;i<=10;i++){
            //从池中取线程执行任务
            es.execute(new Runnable() {//这个任务会存储到阻塞式任务队列中
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()
                            +"->"+getId());
                }
            });
        }
    }
    public static void main(String[] args) {
        //execute01();
          execute02();
    }
}

4.2 单点登陆系统设计及实现

业务描述
在分布式系统中,通过会有多个服务,我们登录了一个服务以后,再访问其它服务时,不想再登录,就需要有一套单独的认证系统,我们通常会称之为单点登录系统,在这套系统中提供一个认证服务器,服务完成用户身份认证,在一些中小型分布式系统中中,我们通常会借助redis存储用户的认证信息,例如:
关键代码实现

package com.jt.redis;

import redis.clients.jedis.Jedis;

import java.util.UUID;

/**
 * 基于redis的单点登录设计及实现
 * 1)用户登录成功以后将登录状态等信息存储到redis
 * 2)用户携带token去访问资源,资源服务器要基于token从redis查询用户信息
 */
public class SSODemo01 {
    /**
     * 基于用户名和密码执行登录认证,将来这样的业务要写到认证服务器，，登录成功将用户状态和权限信息都存储到redis
     * @param username
     * @param password
     * @return 令牌对象（随机字符串，具备唯一性）
     */
    static String doLogin(String username,String password){
       //1.检验数据的合法性(判定用户名,密码是否为空,密码的长度,是否有数字字母特殊符号构成)
       if(username==null||"".equals(username))
           throw new IllegalArgumentException("用户名不能为空");
       //2.基于用户名查询用户信息,并判定密码是否正确
       if(!"tony".equals(username))
           throw new RuntimeException("此用户不存在");
       if(!"123456".equals(password))
           throw new RuntimeException("密码不正确");
       //3.用户存在且密码正确,将用户信息写入到redis
        Jedis jedis=new Jedis("192.168.126.168", 6379);
        String token= UUID.randomUUID().toString();
        jedis.hset(token, "username", username);
        jedis.hset(token, "permission", "sys:resource:create");
        jedis.expire(token, 10);//设置key的有效时间
        jedis.close();
       //4.将token返回给客户端(将来使用response对象响应到客户端).
        return token;
    }
    
    static String token;

    /**
     * 演示资源访问过程
     * 1)允许匿名访问(无需登录)
     * 2)登录后访问(认证通过了)
     * 3)登录后必须有权限才可以访问
     */
    static Object doGetResource(String token){
        //1.校验token是否为空
        if(token==null)
            throw new IllegalArgumentException("请先登录");
        //2.基于token查询redis数据,假如有对应数据说明用户登录了
        //Jedis jedis=new Jedis("192.168.126.168", 6379);
        Jedis jedis= JedisDataSource.getConnection();
        //String username=jedis.hget(token, "username");
        Map<String,String> user = jedis.hgetAll(token);
        //if(username==null)
        if(user==null || user.size()==0)
            throw new RuntimeException("登录超时,请重新登录");
        String permission=jedis.hget(token, "permission");
        jedis.close();
        //3.检查用户是否有访问资源的权限,假如有则允许访问
        if(!"sys:resource:create".equals(permission))
            throw new RuntimeException("你没有权限访问这个资源");
        //4.返回要访问的资源.
        return "your resource";
    }
    public static void main(String[] args) {
        //1.登录操作(用户身份认证)
        token=doLogin("tony", "123456");
        System.out.println(token);
        //2.携带token访问资源服务器
        Object result=doGetResource(token);
        System.out.println(result);
    }
}

运行main方法可以测试其正常登录的状态；

设置main方法中的返回值为null，可以测试未登录的状态：
在这里插入图片描述

我们对token设置超时时间后，可以通过对main方法设置休眠时间来测试登录超时；
在这里插入图片描述

可以通过设置要访问的权限，来测试当前登录用户是否有访问权限：
在这里插入图片描述

4.3 简易秒杀队列设计及实现

业务描述
在设计一个秒杀或抢购系统时,为了提高系统的响应速度,通常会将用户的秒杀或抢购请求先存储到一个redis队列,这里我们就基于redis实现一个先进先出队列,例如:
关键代码实现

package com.jt.redis;

import redis.clients.jedis.Jedis;

//秒杀队列演示
//描述逻辑中会将商品抢购信息先写到redis(以队列形式进行存储),
//因为写redis内存数据库要比写你的mysql数据库快很多倍
//算法:先进先出(FIFO)-体现公平性
public class SecondKillDemo01 {

    //商品抢购首先是入队
    static void enque(String msg){//入队
         Jedis jedis=new Jedis("192.168.126.168",6379);
         jedis.auth("123456");//没有认证不需要写这个语句
         jedis.lpush("queue",msg);
         jedis.close();
    }

    //底层异步出队(基于这个消息,生成订单,扣减库存,...)
    static String deque(){//出队
        Jedis jedis=new Jedis("192.168.126.168",6379);
        jedis.auth("123456");//没有认证不需要写这个语句
        String result=jedis.rpop("queue");
        jedis.close();
        return result;
    }
    public static void main(String[] args){
        //1.多次抢购(模拟在界面上多次点击操作)
        new Thread(){
            @Override
            public void run() {
                for(int i=1;i<=10;i++){//模拟页面上按钮点击
                    enque(String.valueOf(i));
                    try{Thread.sleep(100);}catch(Exception e){}
                }
            }
        }.start();

        //2.从队列取内容(模拟后台从队列取数据)
        new Thread(){
            @Override
            public void run() {
                for(;;){
                    String msg=deque();
                    if(msg==null)continue;
                    System.out.print(msg);
                }
            }
        }.start();

    }
}

4.4 简易投票系统设计及实现

业务描述

在很多系统中设计中,都会有一个活动设计,开启一个活动之前,可以对这个活动的支持力度先进行一个调查,例如基于这个活动设计一个投票系统,在此系统中，一个用户只能给一个活动投一票；例如:
在这里插入图片描述

关键代码实现

package com.jt.redis;

import com.jt.JedisDataSource;
import redis.clients.jedis.Jedis;
import java.util.Set;

/**
 * 基于某个活动的简易投票系统设计
 * 1.投票数据存储到redis (key为活动id,多个用户id的集合)
 * 2.同一个用户不能执行多次投票
 * 3.具体业务操作(投票,获取总票数,获取哪些人参与了投票)
 */
public class VoteDemo01 {

    /**
     * 获取哪些人执行了这个活动的投票
     * @param activityId
     * @return
     */
    static  Set<String> doGetMembers(String activityId){
        //创建新的jedis连接
        //Jedis jedis=new Jedis("192.168.126.168", 6379);
        //1.建立连接(使用我们此前创建的连接池）
        Jedis jedis= JedisDataSource.getConnection();
        //2.获取当前活动的总票数
        Set<String> smembers = jedis.smembers(activityId);
        //3.释放资源
        jedis.close();
        return smembers;
    }
    /**
     * 获取指定活动的投票总数
     * @param activityId
     * @return
     */
    static Long doCount(String activityId){
        //创建新的jedis连接
        //Jedis jedis=new Jedis("192.168.126.168", 6379);
        //1.建立连接(使用我们此前创建的连接池）
        Jedis jedis= JedisDataSource.getConnection();
        //2.获取当前活动的总票数
        Long count=jedis.scard(activityId);
        //3.释放资源
        jedis.close();
        return count;
    }
    /**
     * 执行投票操作
     * @param activityId
     * @param userId
     */
    static void doVote(String activityId,String userId){
        //创建新的jedis连接
        //Jedis jedis=new Jedis("192.168.126.168", 6379);
        //1.建立连接(使用我们此前创建的连接池）
        Jedis jedis= JedisDataSource.getConnection();
        //2.执行投票
        //2.1检查是否投过票
        Boolean flag = jedis.sismember(activityId, userId);
        //2.2执行投票或取消投票
        if(flag){
            //假如已经投过票,再投票就取消投票
            jedis.srem(activityId, userId);
        }else{
            //没有投过票则执行投票
            jedis.sadd(activityId, userId);
        }
        //3.释放资源
        jedis.close();
    }
    public static void main(String[] args) {
        //定义活动、用户ID（假设其为登录用户）
        String activityId1="101";
        String activityId2="102";
        String userId1="1";
        String userId2="2";
        String userId3="3";
        //执行投票动作
        doVote(activityId1, userId1);
        doVote(activityId1, userId2);
        doVote(activityId1, userId3);
        doVote(activityId2, userId1);
        doVote(activityId2, userId2);
        doVote(activityId2, userId2);
        doVote(activityId2, userId3);
        //获取投票的总票数
        Long getCount1 = doCount(activityId1);
        Long getCount2 = doCount(activityId2);
        System.out.printf("getCount1:%s;\ngetCount2:%s;\n",getCount1,getCount2);
        //获取参与投票的成员
        Set<String> members1= doGetMembers(activityId1);
        System.out.println(members1);
        Set<String> members2= doGetMembers(activityId2);
        System.out.println(members2);
    }
}

4.5 简易购物车系统设计及实现

业务描述
简易购物车业务设计如图所示:

基础指令操作,例如:

向购物车添加商品

hset cart:101 2001 1
hset cart:101 2002 1
hset cart:101 2003 2

查看购物车商品

hgetall cart:101

删除购物车商品

hdel cart:101 2003

改变购物车某个商品的购买数量

hincrby cart:101 2002 2

关键代码实现

package com.jt.redis;

import redis.clients.jedis.Jedis;

import java.util.Map;

/**
 * 作业:基于redis存储商品购物车信息
 */
public class CartDemo01 {

    public static void addCart(Long userId,Long productId,int num){
        //1.建立redis链接
        Jedis jedis=new Jedis("192.168.126.168",6379);
        jedis.auth("123456");
        //2.向购物车添加商品
        //hincrBy这个函数在key不存在时会自动创建key
        jedis.hincrBy("cart:" + userId, String.valueOf(productId),num);
        //3.释放redis链接
        jedis.close();
    }
    //查看我的购物车
    public static Map<String, String> listCart(Long userId){
        //1.建立redis链接
        Jedis jedis=new Jedis("192.168.126.168",6379);
        jedis.auth("123456");
        //2.查看购物车商品
        Map<String, String> map = jedis.hgetAll("cart:" + userId);
        //3.释放redis链接
        jedis.close();
        return map;
    }
    public static void main(String[] args) {
        //1.向购物车添加商品
        addCart(101L,201L,1);
        addCart(101L,202L,1);
        addCart(101L,203L,2);
        //2.查看购物车商品
        Map<String, String> map = listCart(101L);
        System.out.println(map);
    }

}

5.SpringBoot工程中Redis与Aop技术的整合

5.1 业务描述

基于AOP与Redis技术实现mysql,redis数据库中数据操作.

5.2 项目准备工作

第一步:打开sca-template工程,添加访问MySql数据库的依赖(两个)

<!--mysql依赖-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--mybatis plus (简化mybatis操作)-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.2</version>
    </dependency>

第二步:修改sca-template工程的配置文件,添加连接mysql数据库的配置

spring:
  datasource:
    url: jdbc:mysql:///jt-sso?serverTimezone=Asia/Shanghai&characterEncoding=utf8
    username: root
    password: root

5.3 Pojo逻辑对象定义

定义一个Menu对象,用户封装tb_menus表中的数据,例如:

package com.jt.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import org.springframework.data.annotation.Id;
import java.io.Serializable;

@TableName(value = "tb_menus")
public class Menu implements Serializable {
    private static final long serialVersionUID = -577747732166248365L;
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private String permission;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPermission() {
        return permission;
    }

    public void setPermission(String permission) {
        this.permission = permission;
    }

    @Override
    public String toString() {
        return "Menu{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", permission='" + permission + '\'' +
                '}';
    }
}

5.4 Dao逻辑对象设计及实现

创建用于操作数据库中tb_menus表中数据的Mapper对象,例如:

package com.jt.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.pojo.Menu;
import org.apache.ibatis.annotations.Mapper;

/**
 * 访问菜单表的数据层对象
 */
 
@Mapper
public interface MenuMapper extends BaseMapper<Menu> {
}

5.5 Service逻辑对象设计及实现

第一步:定义用于处理菜单业务的业务接口,例如:

package com.jt.service;

import com.jt.pojo.Menu;

public interface MenuService {
    /**
     * 基于id查找菜单对象,先查redis,redis没有再查数据库
     * @param id
     * @return
     */
    Menu selectById(Long id);
    /**
     * 向表中写入一条菜单信息,与此同时也要向redis写入一样的数据
     * @param menu
     * @return
     */
    Menu insertMenu(Menu menu);
    /**
     * 更新表中数据,与此同时也要更新redis中的数据
     * @param menu
     * @return
     */
    Menu updateMenu(Menu menu);
    //.....
}

第二步:定义用于处理菜单业务的业务接口实现类,
在这个实现类中自己基于RedisTemplate对象操作Redis缓存,例如:

package com.jt.service;

import com.jt.dao.MenuMapper;
import com.jt.pojo.Menu;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.time.Duration;

@Service
public class MenuServiceImpl implements MenuService{
    @Autowired
    private MenuMapper menuMapper;

    //@Autowired
    //private RedisTemplate redisTemplate;

    
    /**
     * 可以通过这种方式注入redisTemplate对象，省略上方redisTemplate对象的注入以及下方代码中valueOperations对象的创建
     */
    @Resource(name="redisTemplate")
    private ValueOperations valueOperations;
    
    /**
     * 基于id查询菜单信息,要求:
     * 1)先查redis,redis没有去查mysql
     * 2)将从mysql查询到的数据存储到redis
     * @param id
     * @return
     */
    @Override
    public Menu selectById(Long id) {
        //先在redis中基于id进行查询，有数据直接返回，如果没有再去数据库进行查询
        //ValueOperations valueOperations = redisTemplate.opsForValue();
        Object obj=valueOperations.get(String.valueOf(id));
        if(obj!=null){
            System.out.println("Get Data from redis");
            return (Menu)obj;
        }
        Menu menu=menuMapper.selectById(id);
        valueOperations.set(String.valueOf(id), menu, Duration.ofSeconds(120));
        return menu;
    }
    @Override
    public Menu insertMenu(Menu menu) {
        menuMapper.insert(menu);
        // ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set(String.valueOf(menu.getId()), menu, Duration.ofSeconds(120));
        return menu;
    }
    @Override
    public Menu updateMenu(Menu menu) {
        menuMapper.updateById(menu);
        // ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set(String.valueOf(menu.getId()), menu, Duration.ofSeconds(120));
        return menu;
    }
}

说明,启动AOP方式的缓存应用,需要在启动类上添加@EnableCaching注解:

第四步:定义单元测试类,基于单元测试类测试缓存应用.例如:

package com.jt;

import com.jt.pojo.Menu;
import com.jt.service.MenuService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;

@SpringBootTest
public class MenuServiceTests {
    @Autowired
    @Qualifier("defaultMenuService")
    //@Resource(name="defaultMenuService")
    private MenuService menuService;
    @Test
    void testSelectById(){
        Menu menu = menuService.selectById(1L);
        System.out.println(menu);
    }
    @Test
    void testUpdateMenu(){
        Menu menu = menuService.selectById(1L);
        menu.setName("select res");
        menuService.updateMenu(menu);
    }
    @Test
    void testInertMenu(){
        Menu menu = new Menu();
        menu.setName("insert res");
        menu.setPermission("sys:res:insert");
        menuService.insertMenu(menu);
    }
}

5.6 使用AOP的方式改造redis缓存操作

在5.5小节中，我们使用redisTemplate对redis缓存进行了操作；我们也可以定义一个用于处理菜单业务接口的实现类，基于AOP的方式操作redis缓存，首先，我们使用其官方提供的默认AOP方式进行实现：

package com.jt.service.impl;

import com.jt.dao.MenuMapper;
import com.jt.pojo.Menu;
import com.jt.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class DefaultMenuService implements MenuService {
    /*
        @Cacheable 注解描述的方法为一个缓存切入点查询方法
        这里表示将查询到的结果写入到缓存中
        有redis配置，写入redis缓存中，没有redis配置写入本地缓存
        同样的，还有 @CachePut插入更新方法
     */
    @Autowired
    private MenuMapper menuMapper;

    /*
        因为在存入数据时，很多不同的方法间都有相同的id值，例如之后角色ID
        例如我们下面的方法，使用ID作为key，在缓存中写入内容时无法准确找到写入位置
        所以我们可以使用value作为一个标识，自己命名一个独特的标识
        这样就可以准确的将数据存入redis的缓存中
     */
    @Cacheable(value="menuCache",key = "#id")
    @Override
    public Menu selectById(Long id) {
        return menuMapper.selectById(id);
    }

    @CachePut(value="menuCache",key = "#menu.id")
    @Override
    public Menu insertMenu(Menu menu) {
        menuMapper.insert(menu);
        /*
        * 我们这里执行完insert以后，会将对象持久化到数据库中
        * 同时会将数据库中自增长的ID存储到menu对象中
        * 所以这里返回的menu已经有ID了
        */
        return menu;
    }

    @CachePut(value="menuCache",key = "#menu.id")
    @Override
    public Menu updateMenu(Menu menu) {
        menuMapper.updateById(menu);
        return menu;
    }
}

代码完成后，我们需要在启动类添加@EnableCaching注解来启动切面编程方式；并且，因为此时我们已经有俩个实现类实现了MenuService接口，当使用MenuServiceTest测试类进行测试时，会找到spring注入的俩个实现类，我们需要使用 @Qualifier注解指定注入哪一个bean对象；
在这里插入图片描述

上方默认key的序列化方式为string的序列化方式，但是值的序列化方式为jdk的序列化方式，当然，我们也可以借助CacheManager对象,重构CacheManager对象自定义AOP操作redis缓存数据时的序列化方式：

package com.jt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;

/**
 * 重构CacheManager对象,其目的是改变AOP方式应用redis的序列化和反序列化的方式.
 */
@Configuration
public class CacheManagerConfig {
    /**
     * 重构CacheManager对象
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        //定义RedisCache配置
        RedisCacheConfiguration cacheConfig=
                RedisCacheConfiguration.defaultCacheConfig()
        //定义key的序列化方式
        .serializeKeysWith(
                RedisSerializationContext.
                   SerializationPair.fromSerializer(RedisSerializer.string()))
        //定义value的序列化方式
        .serializeValuesWith(
                RedisSerializationContext.SerializationPair
                .fromSerializer(RedisSerializer.json()));

        return  RedisCacheManager.builder(redisConnectionFactory)
               .cacheDefaults(cacheConfig)
               .build();//建造者模式(复杂对象的创建,建议使用这种方式,封装了对象的创建细节)
    }
}

写好这个对象后,可以再次基于MenuService中的方法进行单元测试,检测redis数据的存储.

5.7 Service逻辑对象测试类的实现

我们完成测试类来测试上方三种实现redis数据存储的方式的差异；

package com.jt;

import com.jt.pojo.Menu;
import com.jt.service.MenuService;
import com.jt.service.MenuServiceImpl;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class MenuServiceTest {

    @Autowired
    private MenuService menuService;

    @Test
    void testSelectById(){
        Menu menu = menuService.selectById(4L);
        System.out.println(menu);
    }

    @Test
    void testInsertById(){
        Menu menu = new Menu();
        menu.setName("insert resource");
        menu.setPermission("sys:resource:insert");
        menuService.insertMenu(menu);
    }

    @Test
    void testIUpdateById(){
        Menu menu = menuService.selectById(4l);
        menu.setPermission("sys:resource:update");
        menuService.updateMenu(menu);
    }
}

操作数据后，在docker中查看具体数据类型：
在这里插入图片描述

5.8 Controller逻辑对象设计及实现

第一步:定义Controller处理,处理客户端对菜单数据的请求操作,例如:

package com.jt.controller;

import com.jt.pojo.Menu;
import com.jt.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/menu")
public class MenuController{
    @Autowired
    @Qualifier("defaultMenuService")
    private MenuService menuService;

    @GetMapping("/{id}")
    public Menu doSelectById(@PathVariable("id") Long id){
        return menuService.selectById(id);
    }
    @PutMapping
    public String doUpdate(@RequestBody Menu menu){
         menuService.updateMenu(menu);
         return "update ok";
    }
    @PostMapping
    public String doInsert(@RequestBody Menu menu){
        menuService.insertMenu(menu);
        return "insert ok";
    }
}

第二步:运行启动类，打开postman进行访问测试.检测redis数据存储与更新
在这里插入图片描述

我们可以在控制台看到，第一次查询时是使用查询数据库获取数据的，但是当我们再次运行查询操作第二次就没有查询数据库操作的日志了，是在redis缓存中直接获取的：

在这里插入图片描述

同样的，我们也可以执行插入和更新操作：
在这里插入图片描述

在这里插入图片描述

此时我们在数据库中可以看到插入的数据：
在这里插入图片描述

我们可以尝试查询插入的数据，看其是查询数据库获取还是查询redis缓存获取的数据；

蟑螂恶霸不是恶霸

关注

6
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
3.3 Java中操作redis

1 准备工作1.1 创建工程创建maven父工程，例如03-redis,并在此工程下创建两个子工程，一个为sca-jedis,一个为sca-tempate,例如：1.2 添加项目依赖修改父工程pom.xml文件，添加编译配置<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId>
复制链接

扫一扫