1.Redis命令

1.1 入门案例操作

  1. @Test
  2.     public void testHash() throws InterruptedException {
  3.         Jedis jedis = new Jedis("192.168.126.129",6379);
  4.         jedis.hset("person", "id", "18");
  5.         jedis.hset("person", "name", "hash测试");
  6.         jedis.hset("person", "age", "2");
  7.         Map<String,String> map = jedis.hgetAll("person");
  8.         Set<String> set = jedis.hkeys("person");    //获取所有的key
  9.         List<String> list = jedis.hvals("person");
  10.     }
  11.     @Test
  12.     public void testList() throws InterruptedException {
  13.         Jedis jedis = new Jedis("192.168.126.129",6379);
  14.         jedis.lpush("list", "1","2","3","4");
  15.         System.out.println(jedis.rpop("list"));
  16.     }
  17.     @Test
  18.     public void testTx(){
  19.         Jedis jedis = new Jedis("192.168.126.129",6379);
  20.         //1.开启事务
  21.        Transaction transaction =  jedis.multi();
  22.        try {
  23.            transaction.set("a", "a");
  24.            transaction.set("b", "b");
  25.            transaction.set("c", "c");
  26.            transaction.exec();  //提交事务
  27.        }catch (Exception e){
  28.            transaction.discard();
  29.        }
  30.     }

2 SpringBoot整合Redis

2.1 编辑pro配置文件

由于redis的IP地址和端口都是动态变化的,所以通过配置文件标识数据. 由于redis是公共部分,所以写到common中.
13-Redis AOP实现 - 图1

2.2 编辑配置类

  1. package com.jt.config;
  2. import org.springframework.beans.factory.annotation.Value;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.PropertySource;
  6. import redis.clients.jedis.Jedis;
  7. @Configuration  //标识我是配置类
  8. @PropertySource("classpath:/properties/redis.properties")
  9. public class RedisConfig {
  10.     @Value("${redis.host}")
  11.     private String  host;
  12.     @Value("${redis.port}")
  13.     private Integer port;
  14.     @Bean
  15.     public Jedis jedis(){
  16.         return new Jedis(host, port);
  17.     }
  18. }

3 对象与JSON串转化

3.1 对象转化JSON入门案例

  1. package com.jt;
  2. import com.fasterxml.jackson.core.JsonProcessingException;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import com.jt.pojo.ItemDesc;
  5. import org.junit.jupiter.api.Test;
  6. import java.util.Date;
  7. public class TestObjectMapper {
  8.     private static final ObjectMapper MAPPER = new ObjectMapper();
  9.     /**
  10.      * 1.对象如何转化为JSON串的???
  11.      *  步骤:
  12.      *      1.获取对象的所有的getXXXX()方法.
  13.      *      2.将获取的getXXX方法的前缀get去掉 形成了json的key=xxx
  14.      *      3.通过getXXX方法的调用获取属性的值,形成了json的value的值.
  15.      *      4.将获取到的数据 利用json格式进行拼接 {key : value,key2:value2....}
  16.      * 2.JSON如何转化为对象???
  17.      *      {lyj:xxx}
  18.      *  步骤:
  19.      *      1. 根据class参数类型,利用java的反射机制,实例化对象.
  20.      *      2. 解析json格式,区分 key:value
  21.      *      3. 进行方法的拼接 setLyj()名称.
  22.      *      4.调用对象的setXXX(value) 将数据进行传递,
  23.      *      5.最终将所有的json串中的key转化为对象的属性.
  24.      *
  25.      *
  26.      * @throws JsonProcessingException
  27.      */
  28.     @Test
  29.     public void testTOJSON() throws JsonProcessingException {
  30.         ItemDesc itemDesc = new ItemDesc();
  31.         itemDesc.setItemId(100L).setItemDesc("测试数据转化")
  32.                 .setCreated(new Date()).setUpdated(new Date());
  33.         //1.将对象转化为JSON
  34.         String json = MAPPER.writeValueAsString(itemDesc);
  35.         System.out.println(json);
  36.         //2.将json转化为对象 src:需要转化的JSON串, valueType:需要转化为什么对象
  37.         ItemDesc itemDesc2 = MAPPER.readValue(json, ItemDesc.class);
  38.         /**
  39.          * 字符串转化对象的原理:
  40.          */
  41.         System.out.println(itemDesc2.toString());
  42.     }
  43. }

3.2 编辑ObjectMapper工具API

  1. package com.jt.util;
  2. import com.fasterxml.jackson.core.JsonProcessingException;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. public class ObjectMapperUtil {
  5.     private static final ObjectMapper MAPPER = new ObjectMapper();
  6.     //将对象转化为JSON
  7.     public static String toJSON(Object target){
  8.         try {
  9.            return MAPPER.writeValueAsString(target);
  10.         } catch (JsonProcessingException e) {
  11.             e.printStackTrace();
  12.             throw new RuntimeException(e);
  13.         }
  14.     }
  15.     //将JSON转化为对象
  16.     //需求: 如果用户传递什么类型,则返回什么对象
  17.     public static <T> T toObject(String json,Class<T> targetClass){
  18.         try {
  19.             return MAPPER.readValue(json, targetClass);
  20.         } catch (JsonProcessingException e) {
  21.             e.printStackTrace();
  22.             throw new RuntimeException(e);
  23.         }
  24.     }
  25. }

4 实现商品分类缓存实现

4.1 编辑ItemCatController

说明: 切换业务调用方法,执行缓存调用

  1. /**
  2.      * 业务: 实现商品分类的查询
  3.      * url地址: /item/cat/list
  4.      * 参数:   id: 默认应该0 否则就是用户的ID
  5.      * 返回值结果: List<EasyUITree>
  6.      */
  7.     @RequestMapping("/list")
  8.     public List<EasyUITree> findItemCatList(Long id){
  9.         Long parentId = (id==null)?0:id;
  10.         //return itemCatService.findItemCatList(parentId);
  11.         return itemCatService.findItemCatCache(parentId);
  12.     }

4.2 编辑ItemCatService

  1. package com.jt.service;
  2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  3. import com.jt.mapper.ItemCatMapper;
  4. import com.jt.pojo.ItemCat;
  5. import com.jt.util.ObjectMapperUtil;
  6. import com.jt.vo.EasyUITree;
  7. import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Service;
  10. import redis.clients.jedis.Jedis;
  11. import java.util.ArrayList;
  12. import java.util.List;
  13. @Service
  14. public class ItemCatServiceImpl implements ItemCatService{
  15.     @Autowired
  16.     private ItemCatMapper itemCatMapper;
  17.     @Autowired(required = false)    //程序启动是,如果没有改对象 暂时不加载
  18.     private Jedis jedis;
  19.     @Override
  20.     public String findItemCatName(Long itemCatId) {
  21.         return itemCatMapper.selectById(itemCatId).getName();
  22.     }
  23.     @Override
  24.     public List<EasyUITree> findItemCatList(Long parentId) {
  25.         //1.准备返回值数据
  26.         List<EasyUITree> treeList = new ArrayList<>();
  27.         //思路.返回值的数据从哪来? VO  转化 POJO数据
  28.         //2.实现数据库查询
  29.         QueryWrapper queryWrapper = new QueryWrapper();
  30.         queryWrapper.eq("parent_id",parentId);
  31.         List<ItemCat> catList = itemCatMapper.selectList(queryWrapper);
  32.         //3.实现数据的转化  catList转化为 treeList
  33.         for (ItemCat itemCat : catList){
  34.             long id = itemCat.getId();  //获取ID值
  35.             String text = itemCat.getName();    //获取商品分类名称
  36.             //判断:如果是父级 应该closed  如果不是父级 则open
  37.             String state = itemCat.getIsParent()?"closed":"open";
  38.             EasyUITree easyUITree = new EasyUITree(id,text,state);
  39.             treeList.add(easyUITree);
  40.         }
  41.         return treeList;
  42.     }
  43.     /**
  44.      * Redis:
  45.      *      2大要素:    key: 业务标识+::+变化的参数  ITEMCAT::0
  46.      *                  value: String  数据的JSON串
  47.      * 实现步骤:
  48.      *      1.应该查询Redis缓存
  49.      *          有:  获取缓存数据之后转化为对象返回
  50.      *          没有: 应该查询数据库,并且将查询的结果转化为JSON之后保存到redis 方便下次使用
  51.      * @param parentId
  52.      * @return
  53.      */
  54.     @Override
  55.     public List<EasyUITree> findItemCatCache(Long parentId) {
  56.         Long startTime = System.currentTimeMillis();
  57.         List<EasyUITree> treeList = new ArrayList<>();
  58.         String key = "ITEMCAT_PARENT::"+parentId;
  59.         if(jedis.exists(key)){
  60.             //redis中有数据
  61.             String json = jedis.get(key);
  62.             treeList = ObjectMapperUtil.toObject(json,treeList.getClass());
  63.             Long endTime = System.currentTimeMillis();
  64.             System.out.println("查询redis缓存的时间:"+(endTime-startTime)+"毫秒");
  65.         }else{
  66.             //redis中没有数据.应该查询数据库.
  67.             treeList = findItemCatList(parentId);
  68.             //需要把数据,转化为JSON
  69.             String json = ObjectMapperUtil.toJSON(treeList);
  70.             jedis.set(key, json);
  71.             Long endTime = System.currentTimeMillis();
  72.             System.out.println("查询数据库的时间:"+(endTime-startTime)+"毫秒");
  73.         }
  74.         return treeList;
  75.     }
  76. }

5. AOP实现Redis缓存

5.1 现有代码存在的问题

1.如果直接将缓存业务,写到业务层中,如果将来的缓存代码发生变化,则代码耦合高,必然重写编辑代码.
2.如果其他的业务也需要缓存,则代码的重复率高,开发效率低.
解决方案: 采用AOP方式实现缓存.

5.2 AOP

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

5.3 AOP实现步骤

公式: AOP(切面) = 通知方法(5种) + 切入点表达式(4种)

5.3.1 通知复习

1.before通知 在执行目标方法之前执行
2.afterReturning通知 在目标方法执行之后执行
3.afterThrowing通知 在目标方法执行之后报错时执行
4.after通知 无论什么时候程序执行完成都要执行的通知
上述的4大通知类型,不能控制目标方法是否执行.一般用来记录程序的执行的状态.
一般应用与监控的操作.
5.around通知(功能最为强大的) 在目标方法执行前后执行.
因为环绕通知可以控制目标方法是否执行.控制程序的执行的轨迹.

5.3.2 切入点表达式

1.bean(“bean的ID”) 粒度: 粗粒度 按bean匹配 当前bean中的方法都会执行通知.
2.within(“包名.类名”) 粒度: 粗粒度 可以匹配多个类
3.execution(“返回值类型 包名.类名.方法名(参数列表)”) 粒度: 细粒度 方法参数级别
4.@annotation(“包名.类名”) 粒度:细粒度 按照注解匹配

5.3.3 AOP入门案例

  1. package com.jt.aop;
  2. import lombok.extern.apachecommons.CommonsLog;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.ProceedingJoinPoint;
  5. import org.aspectj.lang.annotation.Around;
  6. import org.aspectj.lang.annotation.Aspect;
  7. import org.aspectj.lang.annotation.Before;
  8. import org.aspectj.lang.annotation.Pointcut;
  9. import org.springframework.stereotype.Component;
  10. import org.springframework.stereotype.Controller;
  11. import org.springframework.stereotype.Service;
  12. import java.util.Arrays;
  13. @Aspect //标识我是一个切面
  14. @Component  //交给Spring容器管理
  15. public class CacheAOP {
  16.     //切面 = 切入点表达式 + 通知方法
  17.     //@Pointcut("bean(itemCatServiceImpl)")
  18.     //@Pointcut("within(com.jt.service.ItemCatServiceImpl)")
  19.     //@Pointcut("within(com.jt.service.*)")   // .* 一级包路径   ..* 所有子孙后代包
  20.     //@Pointcut("execution(返回值类型 包名.类名.方法名(参数列表))")
  21.     @Pointcut("execution(* com.jt.service..*.*(..))")
  22.     //注释: 返回值类型任意类型   在com.jt.service下的所有子孙类   以add开头的方法,任意参数类型
  23.     public void pointCut(){
  24.     }
  25.     /**
  26.      * 需求:
  27.      *      1.获取目标方法的路径
  28.      *      2.获取目标方法的参数.
  29.      *      3.获取目标方法的名称
  30.      */
  31.     @Before("pointCut()")
  32.     public void before(JoinPoint joinPoint){
  33.         String classNamePath = joinPoint.getSignature().getDeclaringTypeName();
  34.         String methodName = joinPoint.getSignature().getName();
  35.         Object[] args = joinPoint.getArgs();
  36.         System.out.println("方法路径:"+classNamePath);
  37.         System.out.println("方法参数:"+ Arrays.toString(args));
  38.         System.out.println("方法名称:"+methodName);
  39.     }
  40.     @Around("pointCut()")
  41.     public Object around(ProceedingJoinPoint joinPoint){
  42.         try {
  43.             System.out.println("环绕通知开始");
  44.             Object obj = joinPoint.proceed();
  45.             //如果有下一个通知,就执行下一个通知,如果没有就执行目标方法(业务方法)
  46.             System.out.println("环绕通知结束");
  47.             return null;
  48.         } catch (Throwable throwable) {
  49.             throwable.printStackTrace();
  50.             throw new RuntimeException(throwable);
  51.         }
  52.     }
  53. }

5.4 AOP实现Redis缓存

5.4.1 业务实现策略

1).需要自定义注解CacheFind
2).设定注解的参数 key的前缀,数据的超时时间.
3).在方法中标识注解.
4).利用AOP 拦截指定的注解.
5).应该使用Around通知实现缓存业务.

5.4.2 编辑自定义注解

  1. @Target(ElementType.METHOD)         //注解对方法有效
  2. @Retention(RetentionPolicy.RUNTIME) //运行期有效
  3. public @interface CacheFind {
  4.     public String preKey(); //定义key的前缀
  5.     public int seconds() default 0;   //定义数据的超时时间.
  6. }

5.4.3 方法中标识注解

13-Redis AOP实现 - 图2

5.4.4 编辑CacheAOP

  1. package com.jt.aop;
  2. import com.jt.anno.CacheFind;
  3. import com.jt.util.ObjectMapperUtil;
  4. import lombok.extern.apachecommons.CommonsLog;
  5. import org.aspectj.lang.JoinPoint;
  6. import org.aspectj.lang.ProceedingJoinPoint;
  7. import org.aspectj.lang.annotation.Around;
  8. import org.aspectj.lang.annotation.Aspect;
  9. import org.aspectj.lang.annotation.Before;
  10. import org.aspectj.lang.annotation.Pointcut;
  11. import org.aspectj.lang.reflect.MethodSignature;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.stereotype.Component;
  14. import org.springframework.stereotype.Controller;
  15. import org.springframework.stereotype.Service;
  16. import redis.clients.jedis.Jedis;
  17. import java.lang.reflect.Method;
  18. import java.util.Arrays;
  19. @Aspect //标识我是一个切面
  20. @Component  //交给Spring容器管理
  21. public class CacheAOP {
  22.     @Autowired
  23.     private Jedis jedis;
  24.     /**
  25.      * 注意事项:  当有多个参数时,joinPoint必须位于第一位.
  26.      * 需求:
  27.      *      1.准备key= 注解的前缀 + 用户的参数
  28.      *      2.从redis中获取数据
  29.      *         有: 从缓存中获取数据之后,直接返回值
  30.      *         没有: 查询数据库之后再次保存到缓存中即可.
  31.      *
  32.      * 方法:
  33.      *      动态获取注解的类型,看上去是注解的名称,但是实质是注解的类型. 只要切入点表达式满足条件
  34.      *      则会传递注解对象类型.
  35.      * @param joinPoint
  36.      * @return
  37.      * @throws Throwable
  38.      */
  39.     @Around("@annotation(cacheFind)")
  40.     public Object around(ProceedingJoinPoint joinPoint,CacheFind cacheFind) throws Throwable {
  41.         Object result = null;   //定义返回值对象
  42.         String preKey = cacheFind.preKey();
  43.         String key = preKey + "::" + Arrays.toString(joinPoint.getArgs());
  44.         //1.校验redis中是否有数据
  45.         if(jedis.exists(key)){
  46.             //如果数据存在,需要从redis中获取json数据,之后直接返回
  47.             String json = jedis.get(key);
  48.             //1.获取方法对象,   2.获取方法的返回值类型
  49.             MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
  50.             //2.获取返回值类型
  51.             Class returnType = methodSignature.getReturnType();
  52.             result = ObjectMapperUtil.toObject(json,returnType);
  53.             System.out.println("AOP查询redis缓存!!!");
  54.         }else{
  55.             //代表没有数据,需要查询数据库
  56.             result = joinPoint.proceed();
  57.             //将数据转化为JSON
  58.             String json = ObjectMapperUtil.toJSON(result);
  59.             if(cacheFind.seconds() > 0){
  60.                 jedis.setex(key, cacheFind.seconds(), json);
  61.             }else{
  62.                 jedis.set(key,json);
  63.             }
  64.             System.out.println("AOP查询数据库!!!");
  65.         }
  66.         return result;
  67.     }
  68.    /* @Around("@annotation(com.jt.anno.CacheFind)")
  69.     public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
  70.         //1.获取目标对象的Class类型
  71.         Class targetClass = joinPoint.getTarget().getClass();
  72.         //2.获取目标方法名称
  73.         String methodName = joinPoint.getSignature().getName();
  74.         //3.获取参数类型
  75.         Object[] argsObj = joinPoint.getArgs();
  76.         Class[]  argsClass = null;
  77.         //4.对象转化为class类型
  78.         if(argsObj.length>0){
  79.            argsClass = new Class[argsObj.length];
  80.             for(int i=0;i<argsObj.length;i++){
  81.                 argsClass[i] = argsObj[i].getClass();
  82.             }
  83.         }
  84.         //3.获取方法对象
  85.         Method targetMethod = targetClass.getMethod(methodName,argsClass);
  86.         //4.获取方法上的注解
  87.         if(targetMethod.isAnnotationPresent(CacheFind.class)){
  88.             CacheFind cacheFind = targetMethod.getAnnotation(CacheFind.class);
  89.             String key = cacheFind.preKey() + "::"
  90.                          +Arrays.toString(joinPoint.getArgs());
  91.             System.out.println(key);
  92.         }
  93.         Object object = joinPoint.proceed();
  94.         System.out.println("环绕开始后");
  95.         return object;
  96.     }
  97. */
  98.    /* //切面 = 切入点表达式 + 通知方法
  99.     //@Pointcut("bean(itemCatServiceImpl)")
  100.     //@Pointcut("within(com.jt.service.ItemCatServiceImpl)")
  101.     //@Pointcut("within(com.jt.service.*)")   // .* 一级包路径   ..* 所有子孙后代包
  102.     //@Pointcut("execution(返回值类型 包名.类名.方法名(参数列表))")
  103.     @Pointcut("execution(* com.jt.service..*.*(..))")
  104.     //注释: 返回值类型任意类型   在com.jt.service下的所有子孙类   以add开头的方法,任意参数类型
  105.     public void pointCut(){
  106.     }*/
  107.     /**
  108.      * 需求:
  109.      *      1.获取目标方法的路径
  110.      *      2.获取目标方法的参数.
  111.      *      3.获取目标方法的名称
  112.      */
  113.    /* @Before("pointCut()")
  114.     public void before(JoinPoint joinPoint){
  115.         String classNamePath = joinPoint.getSignature().getDeclaringTypeName();
  116.         String methodName = joinPoint.getSignature().getName();
  117.         Object[] args = joinPoint.getArgs();
  118.         System.out.println("方法路径:"+classNamePath);
  119.         System.out.println("方法参数:"+ Arrays.toString(args));
  120.         System.out.println("方法名称:"+methodName);
  121.     }
  122.     @Around("pointCut()")
  123.     public Object around(ProceedingJoinPoint joinPoint){
  124.         try {
  125.             System.out.println("环绕通知开始");
  126.             Object obj = joinPoint.proceed();
  127.             //如果有下一个通知,就执行下一个通知,如果没有就执行目标方法(业务方法)
  128.             System.out.println("环绕通知结束");
  129.             return null;
  130.         } catch (Throwable throwable) {
  131.             throwable.printStackTrace();
  132.             throw new RuntimeException(throwable);
  133.         }
  134.     }*/
  135. }

6.总结

本节主要是进一步了解Redis的使用，对象和Json之间相互转换的过程，以及后续AOP实现redis缓存的基本流程步骤。