分布式day14

1. Redis入门案例

1.1 导入jar包

  <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </dependency>

1.2 入门案例

我们如果需要容器干预的话，我们才加@SpringBootTest,不需要容器干预的话则不需要加这个注解

但是刚才的代码有个问题，如果用户数据刚刚插入进去，然后服务器就异常了，那么这个数据是不是永久的存到库中了，为了解决这个问题，我们jedis开发了一个方法setex，他将赋值和失效整合到了一起


结果是111，因为只有数据不存在的时候，他才会赋值，存在的话就不会赋值
nx()数据不存在时，才会进行赋值
xx()数据存在的时候，才会进行赋值

Hash类型

测试结果

List类型

队列

栈


redis事务命令
按照redis的事务控制的方式考虑，那么我们a如果存进去的话，然后存b的时候报错了，那么我们的a和b要么同时成功，要么同时失败

注意：一次开始一次结束，代表本次事务结束

面试问题：Redis中是否有事务控制？
有事务控制的，但是该事务控制是通过队列的方式实现的，和mysql的事务控制不是一个性质的，redis中的事务是弱事务
说明:redis中操作可以添加事务的支持.一项任务可以由多个redis命令完成,如果有一个命令失败导致入库失败时.需要实现事务回滚.

2. SpringBoot整合Redis

2.1 编辑pro配置文件

2.2 编辑配置类

package com.hc.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import redis.clients.jedis.Jedis;

@Configuration //标识为一个配置类 用于整合第三方
@PropertySource("classpath:/properties/redis.properties")
public class RedisConfig {
    @Value("${redis.host}")
    private String host;

    @Value("${redis.port}")
    private Integer port;
    @Bean //将方法的返回值交给spring容器管理
    public Jedis jedis(){
        return new Jedis(host,port);
    }
}

业务需求：我们后台项目哪里用到缓存比较好
我们可不可以将商品分页查询做缓存呢，其实不是特别好的，因为我们商品分页的总记录数和相关参数比较多，缓存起来十分麻烦，所以我们可以将新增商品中的选择类目板块作为缓存处理
json和对象之间转化

2.3 Json转化工具API

说明：在hcds-common中添加工具API

反射之间的关系

package com.hc.util;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class ObjectMapperUtil {
    private static final ObjectMapper MAPPER=new ObjectMapper();

    //1.对象转JSON
    public static String toJSON(Object obj){
        try{
            return MAPPER.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            //将检查异常，转化为运行时异常
            e.printStackTrace();
            throw new RuntimeException();
        }
    }
    //2.JSON转化为对象 传递什么样的类型，返回什么样的对象
    
    public static <T>T toObject(String json,Class<T> target){
        try {
            return MAPPER.readValue(json, target);

        } catch (JsonProcessingException e) {
            e.printStackTrace();
            throw new RuntimeException();
        }
    }
}

3. 商品分类缓存实现

package com.hc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.hc.mapper.ItemCatMapper;
import com.hc.pojo.ItemCat;
import com.hc.util.ObjectMapperUtil;
import com.hc.vo.EasyUITree;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;

import java.util.ArrayList;
import java.util.List;

@Service
public class ItemCatServiceImpl implements ItemCatService{
    @Autowired
    private ItemCatMapper itemCatMapper;

    @Autowired(required = false)
    private Jedis jedis;   //因为该参数不是最终结构，后期需要优化 ，该参数不是必须的

    @Override
    public ItemCat findItemCatById(Long id) {
        return itemCatMapper.selectById(id);
    }

    /**
     * 1.根据parentId查询商品分类列表信息  一级商品分类信息
     * 2.将商品分类列表转化为vo对象
     * 3.返回vo对象的List集合
     * sql： select * from tb_item_cat where parentId=0
     * @param parentId
     * @return
     */
    @Override
    public List<EasyUITree> findItemCatList(long parentId) {
        //1.根据父级id查询子级信息
        QueryWrapper<ItemCat> queryWrapper=new QueryWrapper<>();
        queryWrapper.eq("parent_id", parentId);
        List<ItemCat> itemCatList=itemCatMapper.selectList(queryWrapper);
        //2.将itemCat对象转换为vo对象
        List<EasyUITree> voList=new ArrayList<>(itemCatList.size());
        for(ItemCat itemCat:itemCatList){
            long id=itemCat.getId();
            String text=itemCat.getName();
            //如果是父级则关闭，否则打开
            String state=itemCat.getIsParent()?"closed":"open";
            EasyUITree tree=new EasyUITree(id, text, state);
            voList.add(tree);
        }

        return voList;
    }

    /*
     * 1.将商品分类信息添加进缓存中
     * 2.数据结构 k-v 结构 redis语法结构中key后面跟一个变量 通过::连接
     * key ITEM_CAT_PARENT::0-JSON
     * 业务流程：
     * 1.先查缓存  true/flase
     * 2.true 查询缓存
     * 3.false 查询数据库，并且将结果保存到redis缓存中
     * @param parentId
     * @return
     */
    @Override
    public List<EasyUITree> findItemCatCache(long parentId) {
        long startTime=System.currentTimeMillis();
        List<EasyUITree> treeList=new ArrayList<>();
        //1.定义key
        String key="ITEM_CAT_PARENT::"+parentId;
        //2.判断数据存不存在
        if(jedis.exists(key)){
            String json=jedis.get(key);
            treeList= ObjectMapperUtil.toObject(json, treeList.getClass());
            long endTime=System.currentTimeMillis();
            System.out.println("redis查询！耗时："+(endTime-startTime));
        }else{
            //数据不存在，查询数据库
            treeList=findItemCatList(parentId);
            //将数据库记录转化为json
            String json=ObjectMapperUtil.toJSON(treeList);
            jedis.set(key, json);
            long endTime=System.currentTimeMillis();
            System.out.println("查询数据库！耗时："+(endTime-startTime));
        }
        return treeList;
    }
}