Redis6学习笔记(下)

如何在Java中使用Redis

配置maven文件

<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.0modelVersion>

    <groupId>org.examplegroupId>
    <artifactId>RedisartifactId>
    <version>1.0-SNAPSHOTversion>
    <name>springboot_mybatis_01name>
    <description>Demo project for Spring Bootdescription>


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




    <dependencies>

        <dependency>
        <groupId>org.apache.commonsgroupId>
            <artifactId>commons-pool2artifactId>
            <version>2.6.0version>
        dependency>
        <dependency>
            <groupId>redis.clientsgroupId>
            <artifactId>jedisartifactId>
            <version>3.2.0version>
        dependency>

        <dependency>
            <groupId>redis.clientsgroupId>
            <artifactId>jedisartifactId>
            <version>3.2.0version>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.13.2version>
            <scope>compilescope>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.13.2version>
            <scope>compilescope>
        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","[email protected]");
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包

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-redisartifactId>
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);
   }
}