Redis6学习笔记(下)

最新推荐文章于 2024-07-22 20:43:37 发布

Str_Null

最新推荐文章于 2024-07-22 20:43:37 发布

阅读量1k

点赞数 1

分类专栏：微服务学习文章标签：运维

本文链接：https://blog.csdn.net/qq_47431361/article/details/123248148

版权

微服务学习专栏收录该内容

5 篇文章 1 订阅

订阅专栏

如何在Java中使用Redis

配置maven文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>Redis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>springboot_mybatis_01</name>
    <description>Demo project for Spring Boot</description>


    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>




    <dependencies>

        <dependency>
        <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.6.0</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>compile</scope>
        </dependency>


    </dependencies>

</project>

创建测试程序

public static void main(String[] args) {
Jedis jedis = new Jedis("192.168.137.3",6379);
jedis.auth("如果有密码的话在里面输入你的密码 没有密码这一行不写")
String pong = jedis.ping();
System.out.println("连接成功："+pong);
jedis.close();
}
}

Redis中的数据类型测试

Key

jedis.set("k1", "v1");
jedis.set("k2", "v2");
jedis.set("k3", "v3");
Set<String> keys = jedis.keys("*");
System.out.println(keys.size());
for (String key : keys) {
System.out.println(key);
}
System.out.println(jedis.exists("k1"));
System.out.println(jedis.ttl("k1"));                
System.out.println(jedis.get("k1"));

String

List<String> list = jedis.lrange("mylist",0,-1);
for (String element : list) {
System.out.println(element);
}

List

List<String> list = jedis.lrange("mylist",0,-1);
for (String element : list) {
System.out.println(element);
}

Set

jedis.sadd("orders", "order01");
jedis.sadd("orders", "order02");
jedis.sadd("orders", "order03");
jedis.sadd("orders", "order04");
Set<String> smembers = jedis.smembers("orders");
for (String order : smembers) {
System.out.println(order);
}
jedis.srem("orders", "order02");

hash

jedis.hset("hash1","userName","lisi");
System.out.println(jedis.hget("hash1","userName"));
Map<String,String> map = new HashMap<String,String>();
map.put("telphone","13810169999");
map.put("address","atguigu");
map.put("email","abc@163.com");
jedis.hmset("hash2",map);
List<String> result = jedis.hmget("hash2", "telphone","email");
for (String element : result) {
System.out.println(element);
}

Zset

jedis.zadd("zset01", 100d, "z3");
jedis.zadd("zset01", 90d, "l4");
jedis.zadd("zset01", 80d, "w5");
jedis.zadd("zset01", 70d, "z6");
 
Set<String> zrange = jedis.zrange("zset01", 0, -1);
for (String e : zrange) {
System.out.println(e);
}

如何在SpringBoot里面整合Redis

导入jar包

<!-- redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置application


#Redis服务器地址
spring.redis.host=192.168.2.166
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database=0
#连接超时时间（毫秒）
spring.redis.timeout=1800000
#连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=20
#最大阻塞等待时间(负数表示没限制)
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=5
#连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0

导入配置类

@EnableCaching
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
    
}

创建测试

在这里插入图片描述

Redis的事务

事务的定义

Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

MySQL的事务

事务特点：ACID
从业务角度出发，对数据库的一组操作要求保持4个特征：

Atomicity（原子性）：一个事务必须被视为一个不可分割的最小工作单元，整个事务中的所有操作要么全部提交成功，要么全部失败回滚，对于一个事务来说，不可能只执行其中的一部分操作。
Consistency（一致性）：数据库总是从一个一致性状态转换到另一个一致状态。下面的银行列子会说到。
Isolation（隔离性）：通常来说，一个事务所做的修改在最终提交以前，对其他事务是不可见的。注意这里的“通常来说”，后面的事务隔离级级别会说到。
Durability（持久性）：一旦事务提交，则其所做的修改就会永久保存到数据库中。此时即使系统崩溃，修改的数据也不会丢失。（持久性的安全性与刷新日志级别也存在一定关系，不同的级别对应不同的数据安全级别。）

Redis事务的主要作用就是串联多个命令防止别的命令插队。

Multi(组队)、Exec(执行)、discard(取消组队)

介绍

从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。
在这里插入图片描述

事务的三种情况

组队执行成功----------顺利执行
组队失败,执行成功—所有失败
组队成功,执行失败—就执行失败的哪一条失败

组队执行成功

在这里插入图片描述

组队阶段失败,全部失败

在这里插入图片描述

组队成功,执行失败

在这里插入图片描述

事务冲突问题(乐观锁悲观锁)

举例

一个请求想给金额减8000

一个请求想给金额减5000

一个请求想给金额减1000
在这里插入图片描述

锁🔒

悲观锁🔒

悲观锁认为无时无刻都有人要跟自己抢东西所以当悲观锁操作数据的时候他会给数据上锁让其他人是用不了数据当时用完数据之后再把锁打开
在这里插入图片描述
传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

乐观锁🔒

乐观锁认为就只有我一个人来操作数据就不去上锁了
乐观锁修改数据会给数据添加一个版本号
写完数据之后会检查原来的数据的版本号进行对比如果版本号不一样就放弃这次修改
举一个例来说
在这里插入图片描述
上面的黄色和下面的蓝色都同时拿到了这个数据
然后他们都进行修改
黄色提交的快它发现自己的版本和原来数据的版本号一样就提交了然后修改了版本号
蓝色的修改的慢它修改完在看当前数据的版本号和自己的不一样就放弃修改了

乐观锁适用于多读的应用类型，这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务的。

Redis事务三特性

Ø 单独的隔离操作

事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

Ø 没有隔离级别的概念

队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行
Ø 不保证原子性

事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚

Redis事务–秒杀并发模拟

使用工具ab模拟测试
ab安装网上有很多教程这里就不细嗦了

准备处理业务程序

//秒杀过程
public static boolean doSecKill(String uid, String prodid) throws IOException {
    //判断参数是否为空
    if (uid == null && prodid == null) {
        return false;
    }
    //连接数据库
    Jedis jedis = new Jedis("192.168.2.166", 6379);


    //拼接字符串
    String kckey = "sk:" + prodid + ":qt";
    String userkey = "sk:" + prodid + ":user";
    //判断秒杀是否开始
    String kc = jedis.get(kckey);
    if (kc == null) {
        System.out.println("秒杀还没有开始");
        jedis.close();
        return false;
    }
    //判断用户是否秒杀成功过
    if (jedis.sismember(userkey, uid)) {
        System.out.println("您已经秒杀过了");
        jedis.close();
        return false;
    }
    //判断商品是否为空
    if(Integer.parseInt(kc)<=0){
        System.out.println("商品已被抢空");
        jedis.close();
        return false;
    }
    //库存-1
    jedis.decr(kckey);
    System.out.println("秒杀成功");
    //添加抢购成功用户id
    jedis.sadd(userkey, uid);
    return true;

联网安装

yum –y install httpd-tools

在当前文件夹下创建一个postfile文件

vi postfile
prodid=0101&

并发测试

2000连接数 200个位并发请求
ab -n 2000 -c 200 -k -p ~/postfile -T application/x-www-form-urlencoded http://192.168.2.115:8081/Seckill/doseckill

商品溢出

在这里插入图片描述

乐观锁解决超卖问题

//秒杀过程
public static boolean doSecKill(String uid, String prodid) throws IOException {
    //判断参数是否为空
    if (uid == null && prodid == null) {
        return false;
    }
    //连接数据库
    Jedis jedis = new Jedis("192.168.2.166", 6379);

    //拼接字符串
    String kckey = "sk:" + prodid + ":qt";
    String userkey = "sk:" + prodid + ":user";

    //增加乐观锁
    jedis.watch(kckey);

    //判断秒杀是否开始
    String kc = jedis.get(kckey);
    if (kc == null || "".equals(kc.trim())) {
        System.out.println("秒杀还没有开始");
        jedis.close();
        return false;
    }
    //判断用户是否秒杀成功过
    if (jedis.sismember(userkey, uid)) {
        System.out.println("您已经秒杀过了");
        jedis.close();
        return false;
    }
    //判断商品是否为空
    if(Integer.parseInt(kc)<=0){
        System.out.println("商品已被抢空");
        jedis.close();
        return false;
    }

    //增加事务
    Transaction multi = jedis.multi();
    //库存-1
    multi.decr(kckey);
    //添加抢购成功用户id
    multi.sadd(userkey, uid);
    List<Object> exec = multi.exec();
    if(exec==null||exec.size()==0){
        System.out.println("秒杀失败");
        jedis.close();
        return false;
    }
    System.err.println("秒杀成功");
    jedis.close();
    return true;
}

连接池

节省每次连接redis服务带来的消耗，把连接好的实例反复利用。
通过参数管理连接的行为

链接池参数

MaxTotal：控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；如果赋值为-1，则表示不限制；如果pool已经分配了MaxTotal个jedis实例，则此时pool的状态为exhausted。
maxIdle：控制一个pool最多有多少个状态为idle(空闲)的jedis实例；
MaxWaitMillis：表示当borrow一个jedis实例时，最大的等待毫秒数，如果超过等待时间，则直接抛JedisConnectionException；
testOnBorrow：获得一个jedis实例的时候是否检查连接可用性（ping()）；如果为true，则得到的jedis实例均是可用的；


public static JedisPool getJedisPoolInstance() {
   if (null == jedisPool) {
      synchronized (JedisPoolUtil.class) {
         if (null == jedisPool) {
            JedisPoolConfig poolConfig = new JedisPoolConfig();
            poolConfig.setMaxTotal(200);
            poolConfig.setMaxIdle(32);
            poolConfig.setMaxWaitMillis(100*1000);
            poolConfig.setBlockWhenExhausted(true);
            poolConfig.setTestOnBorrow(true);  // ping  PONG
            jedisPool = new JedisPool(poolConfig, "192.168.44.168", 6379, 60000 );
         }
      }
   }
   return jedisPool;
} 

public static void release(JedisPool jedisPool, Jedis jedis) {
   if (null != jedis) {
      jedisPool.returnResource(jedis);
   }
}

Str_Null

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Redis6学习笔记(下)

文章目录如何在Java中使用Redis配置maven文件创建测试程序Redis中的数据类型测试KeyStringListSethashZset如何在SpringBoot里面整合Redis导入jar包配置application导入配置类创建测试Redis的事务事务的定义MySQL的事务Multi(组队)、Exec(执行)、discard(取消组队)介绍事务的三种情况组队执行成功组队阶段失败,全部失败组队成功,执行失败事务冲突问题(乐观锁悲观锁)举例锁🔒悲观锁🔒乐观锁🔒Redis事务三特性Redis事务--秒
复制链接

扫一扫