乐趣区

关于java:Redis总结

作者：

jiezi

在

1.Redis介绍

redis是一个key-value存储系统。和Memcached相似，它反对存储的value类型绝对更多，包含string(字符串)、list(链表)、set(汇合)、zset(sorted set –有序汇合)和hash（哈希类型）。这些数据类型都反对push/pop、add/remove及取交加并集和差集及更丰盛的操作，而且这些操作都是原子性的。在此基础上，redis反对各种不同形式的排序。与memcached一样，为了保障效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把批改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它能够用作数据库、缓存和消息中间件。 它反对多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 汇合（sets）， 有序汇合（sorted sets） 与范畴查问， bitmaps， hyperloglogs 和 天文空间（geospatial） 索引半径查问。 Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘长久化（persistence）， 并通过 Redis哨兵（Sentinel）和主动 分区（Cluster）提供高可用性（high availability）。
Redis常见用法
1.Redis能够当做缓存应用
2.Redis能够当做数据库验证码应用
3.Redis能够当做消息中间件

1.1Redis装置

1)解压安装包
[root@localhost src]# tar -zxvf redis-5.0.4.tar.gz

2)装置Redis
阐明:在Redis根目录执行命令
1.make
2.make install

1.2批改Redis配置文件

命令:展示行号:set nu

批改地位1:正文IP绑定

批改地位2:敞开保护模式

批改地位3:开启后盾启动

1.3redis服务命令

1.启动命令:redis-server redis.conf
2.检索命令:ps-ef | grep redis
3.进入客户端:redis-cli -p 6379
4.敞开redis:kill-9 PID号 | redis-cli -p 6379 shutdown

2.Redis入门案例

2.1引入jar包文件

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

2.2编辑测试API

package com.jt.test;

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

public class TestRedis {

    /**
     * 1.测试redis程序链接是否失常
     * 步骤:
     *      1.实例化jedis工具API对象(host:port)
     *      2.依据实例 操作redis  办法就是命令
     *
     * 对于链接不通的阐明:
     *      1.查看Linux防火墙
     *      2.查看Redis配置文件批改项
     *          2.1 IP绑定
     *          2.2 保护模式
     *          2.3 后盾启动
     *      3.查看redis启动形式  redis-server redis.conf
     *      4.查看IP 端口 及redis是否启动...
     *
     *      */
    @Test
    public void test01(){
        String host = "192.168.126.129";
        int port = 6379;
        Jedis jedis = new Jedis(host,port);
        jedis.set("cgb2006","好好学习 天天向上");
        System.out.println(jedis.get("cgb2006"));

        //2.练习是否存在key
        if(jedis.exists("cgb2006")){
            jedis.del("cgb2006");
        }else{
            jedis.set("cgb2006", "xxxx");
            jedis.expire("cgb2006", 100);
        }


    }
}

2.3Redis常见用法

2.3.1setex学习


/**
     * 2.需要:
     *      1.向redis中插入数据  k-v
     *      2.为key设定超时工夫  60秒后生效.
     *      3.线程sleep 3秒
     *      4.获取key的残余的存活工夫.
     *
     *   问题形容: 数据肯定会被删除吗??????
     *   问题阐明: 如果应用redis 并且须要增加超时工夫时 个别须要满足原子性要求.
     *   原子性:   操作时要么胜利 要么失败.然而必须同时实现.
     */
    @Test
    public void test02() throws InterruptedException {
        Jedis jedis = new Jedis("192.168.126.129",6379);
        jedis.setex("宝可梦", 60, "小火龙 妙蛙种子");
        System.out.println(jedis.get("宝可梦"));

       /* Jedis jedis = new Jedis("192.168.126.129",6379);
        jedis.set("宝可梦", "小火龙 妙蛙种子");
        int a = 1/0;    //可能会出异样
        jedis.expire("宝可梦", 60);
        Thread.sleep(3000);
        System.out.println(jedis.ttl("宝可梦"));*/
    }

2.3.2setnx学习

/**
     * 3.需要如果发现key曾经存在时 不批改数据.如果key不存在时才会批改数据.
     *
     */
    @Test
    public void test03() throws InterruptedException {
        Jedis jedis = new Jedis("192.168.126.129", 6379);
        jedis.setnx("aaaa", "测试nx的办法");
        /*if(jedis.exists("aaa")){
            System.out.println("key曾经存在 不做批改");
        }else {
            jedis.set("aaa", "测试数据");
        }*/
        System.out.println(jedis.get("aaaa"));
    }

2.3.3set超时工夫原子性操作

 /**
     * 需要:
     *  1.要求用户赋值时,如果数据存在则不赋值.  setnx
     *  2.要求在赋值操作时,必须设定超时的工夫 并且要求满足原子性 setex
     */
    @Test
    public void test04() throws InterruptedException {
        Jedis jedis = new Jedis("192.168.126.129", 6379);
        SetParams setParams = new SetParams();
        setParams.nx().ex(20);
        jedis.set("bbbb", "实现业务操作AAAA", setParams);
        System.out.println(jedis.get("bbbb"));


    }

2.3.4list汇合练习

  @Test
    public void testList() throws InterruptedException {
        Jedis jedis = new Jedis("192.168.126.129", 6379);
        jedis.lpush("list", "1","2","3");
        System.out.println(jedis.rpop("list"));
    }

2.3.5redis事务管制

 @Test
    public void testTx() throws InterruptedException {
        Jedis jedis = new Jedis("192.168.126.129", 6379);
        //1.开启事务
        Transaction transaction = jedis.multi();
        try {
            transaction.set("aa", "aa");
            //提交事务
            transaction.exec();
        }catch (Exception e){
            e.printStackTrace();
            //回滚事务
            transaction.discard();
        }
    }

3.1惯例锁操作

3.1.1超卖的起因

3.1.2同步锁的问题

阐明同步锁只能解决tomcat外部问题,不能解决多个tomcat并发问题

3.1.3散布锁机制

思维
1.锁应该应用第三方操作,锁应该共用
2.准则:如果锁正在被人应用时,其余用户不能操作
3.策略:用户向redis中保留一个key,如果redis中有key示意正在有人应用这把锁,其余用户不容许操作,redis中没有key,则示意能够应用这把锁.
4.危险:如何解决死锁问题,设置超时工夫.

3.SpringBoot整合Redis

3.1编辑配置文件redis.pro

阐明:因为该配置被其余我的项目独特应用,则应该写入jt-common中.

3.2编辑配置类

阐明:编辑redis配置类将Jedis对象交给Spring容器治理
@Configuration
@PropertySource("classpath:/properties/redis.properties")
public class JedisConfig {

    @Value("${redis.host}")
    private String host;
    @Value("${redis.port}")
    private Integer port;

    @Bean
    public Jedis jedis(){

        return new Jedis(host,port);
    }
}

3.3对象与JSON转化 ObjectMapper介绍

3.3.1简略对象转化

/**
     * 测试简略对象的转化
     */
    @Test
    public void test01() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        ItemDesc itemDesc = new ItemDesc();
        itemDesc.setItemId(100L).setItemDesc("商品详情信息")
                .setCreated(new Date()).setUpdated(new Date());
        //对象转化为json
        String json = objectMapper.writeValueAsString(itemDesc);
        System.out.println(json);

        //json转化为对象
        ItemDesc itemDesc2 = objectMapper.readValue(json, ItemDesc.class);
        System.out.println(itemDesc2.getItemDesc());
    }

3.3.2汇合对象转化

 /**
     * 测试汇合对象的转化
     */
    @Test
    public void test02() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        ItemDesc itemDesc = new ItemDesc();
        itemDesc.setItemId(100L).setItemDesc("商品详情信息1")
                .setCreated(new Date()).setUpdated(new Date());
        ItemDesc itemDesc2 = new ItemDesc();
        itemDesc2.setItemId(100L).setItemDesc("商品详情信息2")
                .setCreated(new Date()).setUpdated(new Date());
        List<ItemDesc> lists = new ArrayList<>();
        lists.add(itemDesc);
        lists.add(itemDesc2);
        //[{key:value},{}]
        String json = objectMapper.writeValueAsString(lists);
        System.out.println(json);

        //将json串转化为对象
        List<ItemDesc> list2 = objectMapper.readValue(json, lists.getClass());
        System.out.println(list2);
    }

3.4编辑工具API

package com.jt.util;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jt.pojo.ItemDesc;
import org.springframework.util.StringUtils;

public class ObjectMapperUtil {

    /**
     * 1.将用户传递的数据转化为json串
     * 2.将用户传递的json串转化为对象
     */
    private static final ObjectMapper MAPPER = new ObjectMapper();

     //1.将用户传递的数据转化为json串
    public static String toJSON(Object object){

        if(object == null) {
            throw new RuntimeException("传递的数据为null.请查看");
        }

        try {
            String json = MAPPER.writeValueAsString(object);
            return json;
        } catch (JsonProcessingException e) {
            //将查看异样,转化为运行时异样
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    //需要: 要求用户传递什么样的类型,我返回什么样的对象  泛型的常识
    public static <T> T toObj(String json,Class<T> target){
        if(StringUtils.isEmpty(json) || target ==null){
            throw new RuntimeException("参数不能为null");
        }
        try {
           return  MAPPER.readValue(json, target);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}

3.5商品分类的缓存实现

3.5.1实现步骤

1.定义Redis中的key key必须是惟一不能反复的,存取key=”ITEM_CAT_PARENTID::70″
2.依据key去redis中进行查问 有数据 没有数据
3.没有数据 则查询数据库获取记录,之后将数据保留到redis中不便后续应用.
4.有数据 示意用户不是第一次查问 能够将缓存的数据间接返回即可.

3.5.2编辑ItemController

3.5.3编辑ItemCatService

@Override
    public List<EasyUITree> findItemCatListCache(Long parentId) {
        //0.定义公共的返回值对象
        List<EasyUITree> treeList = new ArrayList<>();
        //1.定义key
        String key = "ITEM_CAT_PARENTID::"+parentId;
        //2.检索redis服务器,是否含有该key

        //记录时间
        Long startTime = System.currentTimeMillis();
        if(jedis.exists(key)){
            //数据存在
            String json = jedis.get(key);
            Long endTime = System.currentTimeMillis();
            //须要将json串转化为对象
            treeList = ObjectMapperUtil.toObj(json,treeList.getClass());
            System.out.println("从redis中获取数据 耗时:"+(endTime-startTime)+"毫秒");
        }else{
            //3.数据不存在  查询数据库
            treeList = findItemCatList(parentId);
            Long endTime = System.currentTimeMillis();
            //3.将数据保留到缓存中
            String json = ObjectMapperUtil.toJSON(treeList);
            jedis.set(key, json);
            System.out.println("查询数据库 耗时:"+(endTime-startTime)+"毫秒");
        }
        return treeList;
    }

3.5.4应用Redis的速度差

4.AOP实现Redis缓存

4.1自定义缓存注解

1.注解名称:cacheFind
2.属性参数
2.1key:应该由用户本人手动增加个别增加业务名称之后动静拼接造成惟一的key
2.2seconds:用户能够指定数据的超时工夫
@Target(ElementType.METHOD) //注解对办法无效
@Retention(RetentionPolicy.RUNTIME)  //运行期无效
public @interface CacheFind {

    public String preKey();          //用户标识key的前缀.
    public int seconds() default 0;  //如果用户不写示意不须要超时. 如果写了以用户为准.
}

4.2编辑CacheAOP

package com.jt.aop;

import com.jt.anno.CacheFind;
import com.jt.config.JedisConfig;
import com.jt.util.ObjectMapperUtil;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;

import java.lang.reflect.Method;
import java.util.Arrays;

@Aspect     //我是一个AOP切面类
@Component  //将类交给spring容器治理
public class CacheAOP {

    @Autowired
    private Jedis jedis;

    /**
     * 切面 = 切入点 + 告诉办法
     *        注解相干 + 盘绕告诉  控制目标办法是否执行
     *
     *  难点:
     *      1.如何获取注解对象
     *      2.动静生成key  prekey + 用户参数数组
     *      3.如何获取办法的返回值类型
     */
    @Around("@annotation(cacheFind)")
    public Object around(ProceedingJoinPoint joinPoint,CacheFind cacheFind){
        Object result = null;
        try {
            //1.拼接redis存储数据的key
            Object[] args = joinPoint.getArgs();
            String key = cacheFind.preKey() +"::" + Arrays.toString(args);

            //2. 查问redis 之后判断是否有数据
            if(jedis.exists(key)){
                //redis中有记录,无需执行指标办法
                String json = jedis.get(key);
                //动静获取办法的返回值类型   向上造型  向下造型
                MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
                Class returnType = methodSignature.getReturnType();
                result = ObjectMapperUtil.toObj(json,returnType);
                System.out.println("AOP查问redis缓存");
            }else{
                //示意数据不存在,须要查询数据库
                result = joinPoint.proceed();  //执行指标办法及告诉
                //将查问的后果保留到redis中去
                String json = ObjectMapperUtil.toJSON(result);
                //判断数据是否须要超时工夫
                if(cacheFind.seconds()>0){
                    jedis.setex(key,cacheFind.seconds(),json);
                }else {
                    jedis.set(key, json);
                }
                System.out.println("aop执行指标办法查询数据库");
            }

        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return result;
    }

}

5.对于Redis配置阐明

5.1对于Redis长久化阐明

redis默认条件下反对数据的长久化操作,当redis中有数据时会定期将数据保留到磁盘中,当redis服务器重启时,会依据配置文件读取指定的长久化文件.实现内存数据的复原.

5.2长久化形式介绍

5.2.1RDB模式

特点
1.RDB模式是redis的默认的长久化策略.
2.RDB模式记录的是Redis内存数据的快照,最新的快照会笼罩之前的内容,所有RDB长久化文件占用空间更小,长久化效率高.
3.RDB模式因为是定期长久化,所以可能导致数据失落.
命令:
1. save 要求立刻马上长久化 同步的操作 其余的redis操作会陷入阻塞的状态.
2. bgsave 开启后盾运行 异步的操作 因为是异步操作,所以无奈保障rdb文件肯定是最新的须要期待.
配置
1.长久化文件名称:

2.长久化文件地位:

3.RDB模式长久化策略

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章