Redis的简单笔记

一、Redis的事务二、Java连接Redis：Jedis

2.1 连接2.2 事务三、SpringBoot整合Redis

3.1 导入依赖3.2 配置连接3.3 创建RedisConfig3.4 RedisUtil:封装RedisConfig 四、redis.conf文件五、Redis的持久化

5.1 RDB（默认）

流程触发方式恢复rdb文件持久化设置优缺点 5.2 AOF

修复AOF文件AOF重写持久化设置优缺点六、Redis发布订阅七、Redis的主从复制

命令行配置主机写从机读Redis主从同步策略八、哨兵模式

模式实现九、缓存穿透、击穿以及雪崩

9.1 缓存穿透9.2 缓存击穿9.3 缓存雪崩

前言

本文章只是简单的记录，仅是入门的文章。

学习视频：【狂神说Java】Redis最新超详细版教程通俗易懂
截图均来来自于视频。文中还穿插着其他大佬的文章。

最后，感谢大佬们的分享。★,°:.☆(￣▽￣)/$:.°★ 。

一、Redis的事务

Redis事务：一系列命令的集合，一个事务中所有的命令都会被序列化，在事务执行的过程中顺序执行

Redis的事务没有隔离级别的概念

Redis的事务

开启事务（multi）命令入队执行事务（exec）

Redis单条命令是原子性的；多条命令不具备原子性

编译型异常（代码出错，命令出错），事务中的命令都不会执行

运行时异常（1/0，存在语法错误）,事务中的错误命令会不执行，其他命令依旧执行。

什么是乐观锁，什么是悲观锁

Redis测试监控：watch（乐观锁）

注意watch不是监视对象的值，是监视对象有没有被改动，哪怕改动的数据和原来的数据一样，那也是不成功的！！！

如果执行了exec和discard，就不用执行unwatch了

模拟线程正常监控的情况：

模拟事务在监控的时候，对数据进行了改动。

当事务在监控的时候，对数据进行了改动的情况，只需要获取最新的值，再进行改动即可

二、Java连接Redis：Jedis

导入依赖

    
        
        
            redis.clients
            jedis
            4.1.1
        
        
        
            com.alibaba
            fastjson
            1.2.79

2.1 连接

 public class TestConn {

    public static void main(String[] args) {
        // 1. new Jedis
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        // Jedis所有的命令就是Redis的命令行的命令
        // 测试是否连接成功
        System.out.println(jedis.ping());
    }
}

输出：

2.2 事务

正常事务运行

public class TestTransaction {

    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        JSonObject jsonObject = new JSONObject();
        jsonObject.put("hello","world");
        jsonObject.put("name","admin");
        String string = jsonObject.toJSONString();
        // 开启事务
        Transaction multi = jedis.multi();
        try {
            // 设置命令
            multi.set("user01",string);
            multi.set("user02",string);

            // 执行命令
            multi.exec();
        } catch (Exception e) {
            // 放弃事务
            multi.discard();
            e.printStackTrace();
        }finally {
            System.out.println(jedis.get("user01"));
            System.out.println(jedis.get("user02"));
            // 关闭连接
            jedis.close();
        }
    }
}

输出：

运行异常的事务处理

public class TestTransaction {

    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();

        JSonObject jsonObject = new JSONObject();
        jsonObject.put("hello","world");
        jsonObject.put("name","admin");
        String string = jsonObject.toJSONString();
        // 开启事务
        Transaction multi = jedis.multi();
        try {
            // 设置命令
            multi.set("user01",string);
            multi.set("user02",string);
            int i = 1/0;
            // 执行命令
            multi.exec();
        } catch (Exception e) {
            // 放弃事务
            // 运行时异常，但是catch里面放弃了事物
            multi.discard();
            e.printStackTrace();
        }finally {
            System.out.println(jedis.get("user01"));
            System.out.println(jedis.get("user02"));
            // 关闭连接
            jedis.close();
        }
    }
}

三、SpringBoot整合Redis

前言

点击查看Redis依赖


    org.springframework.boot
    spring-boot-starter-data-redis

在SpringBoot2.0.x之后，原来的Jedis替换为Lettuce

Jedis：使用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，使用jedis pool 连接池！更像 BIO 模式

Lettuce：采用的是netty，实例可以在多个线程中共享，减少线程数量。更像 NIO 模式

SpringBoot为我们自动装配了Redis。如下图可以搜索到默认装配的配置：

点击 RedisAutoConfiguration

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class}) // 自动装配了RedisProperties.class文件。
@import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean( name = {"redisTemplate"} )
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 默认的 RedisTemplate 没有过多的设置，缺少redis对象序列化
        // 还需要强制转化
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    // 由于String是Redis常用的数据类型，所以单独写出来了一个Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        return new StringRedisTemplate(redisConnectionFactory);
    }

点击RedisProperties，会看到Redis的默认数据库、主机、端口号

@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
    private int database = 0;
    private String url;
    private String host = "localhost";
    private String username;
    private String password;
    private int port = 6379;
    private boolean ssl;

3.1 导入依赖


    org.springframework.boot
    spring-boot-starter-data-redis

3.2 配置连接

spring:
  redis:
    host: 127.0.0.1
    port: 6379

测试

@SpringBootTest
class Redis02SpringbootApplicationTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads(){
        redisTemplate.opsForValue().set("myKey01","helen");
        System.out.println(redisTemplate.opsForValue().get("myKey01"));

        redisTemplate.opsForValue().set("myKey02","海伦娜");
        System.out.println(redisTemplate.opsForValue().get("myKey02"));
    }
}

控制台打印：

在Redis存储的 key 与 Value （乱码：需要进行序列化）

解决乱码

点击 RedisTemplate ，会看到有好几种序列化。

会看到上述的几种，都默认使用的是JDK的序列化

此时，我们都使用的是 SpringBoot 自己整合的 RedisTemplate ：会出现存储的时候乱码。

因此，我们需要自己去实现

3.3 创建RedisConfig

@Configuration
public class RedisConfig {
    
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
        
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(factory);

        
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        objectMapper.activateDefaultTyping(
                LaissezFaireSubTypevalidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL,
                JsonTypeInfo.As.WRAPPER_ARRAY);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        
        template.afterPropertiesSet();
        return template;
    }
}

此时，再运行测试类，查看在Redis里面的存储：

3.4 RedisUtil:封装RedisConfig

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;


@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    // =============================================================== common

    
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
        }
    }

    
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete((Collection) CollectionUtils.arrayToList(key));
            }
        }
    }

    // =============================================================== String

    
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                redisTemplate.opsForValue().set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("The increment factor must be greater than 0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("The decrement factor must be greater than 0");
        }
        return redisTemplate.opsForValue().decrement(key, delta);
    }

    // ======================================================================== Map

    
    public Object hget(String key, String item) {
        if (key.isEmpty() || item.isEmpty()) {
            throw new RuntimeException("key or item Can't be empty ");
        }
        return redisTemplate.opsForHash().get(key, item);
    }

    
    public Map hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    
    public boolean hmset(String key, Map map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    
    public boolean hHashKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // =============================================================== set

    
    public Set

Redis的简单笔记

Java相关栏目本月热门文章