Redis6入门到精通

3、数字值操作（原子操作：得益于redis单线程，不会被其他线程打断的）

incr k			储存的数字值增 1
incrby k ?		储存的数字值增 ?
decr k 			储存的数字值减 1
decrby k ?		储存的数字值减 ?

1、简介

单键多值

2、数据结构：

3、命令

例：从左插入v1 v2 v3,实际从左到右为v3 v2 v1

1、插吐值

lpush/rpush k v1 v2 v3		从左/右插入v1,v2,v3

lpop/rpop k					从左/右吐出一个值,吐完值键消失

rpoplpush k1 k2				从k1右边吐一个值插到k2左边

2、查询（并非吐值）

lrange k s e				按照索引下标范围获得元素s start, e end
lindex k i					按照索引下标获得元素
llen l						获取列表长度

3、插值

linsert k before "v1" "new v1"		在v1后面插入newv1

演示

4、特殊删除

lrem k 2 "v" 				删除k左边的两个"v"

演示

5、替换

lset k i v					将k下标为i的值换为v

演示

1、简介

自动排重

String类型的无序集合
底层是一个value为null的hash表，增删查复杂度都为O(1)
一个算法，随着数据的增加，执行时间的长短，如果是O(1)，数据增加，查找数据的时间不变

2、数据结构

是dict字典，字典使用哈希表实现的
Java中的HashSet的内部实现使用的是HashMap，只不过所有的value都指向同一个对象。
Redis的set结构也一样，内部也使用Hash结构，所有的value指向同一个对象

3、命令

sadd k v1 v2 v3				添加
smembers k					返回集合中所有元素
srandmember k n				随机从集合查询n个值
sismember k v				判断集合中是否有v
scard k						查询集合中元素个数

srem k v1 v2				删除集合中的某个元素
spop k						随机从集合k吐出某个值（吐出的值消失）

smover k1 k2 v1				把集合k1中的值v1移到k2

sinter k1 k2				返回两个集合的交集元素
sunion k1 k2				返回两个集合的并集元素
sdiff k1 k2					返回两个集合的差集元素（k1中的存在的，k2中不存在的）

1、简介

Hash是一个String类型的field和value的映射表，类似于Map

2、数据结构

Hash类型对应数据结构为：ziplist(压缩列表)，hashtable（哈希表），
当field-value长度较短且个数较少时，使用ziplist，否则使用hashtable

3、命令

hset k f v				给k中的f赋值v
hsetnx k f v			给k中的f赋值v,仅当f不存在时
例 hset user:1001 id 1	设置user1001的id为1
hmest k f1 v1 f2 v2 	给k中的多个f赋值v

hexist k f 				查看k中是否存在f
hkeys k					查看k中的所有field
hvals k					查看k中的所有value

hget k f				从k集合f查询v

hincrby k f n			为k中的f的v加上增量n

1、简介

2、数据结构

跳跃表实现过程

3、命令

zadd k s v s v					将一个或多个member元素及其score值加入有序集k中

zrange k s e 					返回k中下标在s-e中的元素
zrange k s e withscores 		返回k中下标在s-e中的元素并带score（按评分从小到大）
zrevrange k s e withscores 		返回k中下标在s-e中的元素并带score（按评分从大到小）

zrangebyscore k min max   		返回评分在min max的元素（包含min,max）从小到大
zrevrangebyscore k max min		返回评分在max min的元素（包含min,max）从大到小

zincrby k  v			为元素的scrore加上增量
zrem k v						删除k中指定元素
zcount k min max				统计个数，返回个数
zrank k v						返回v的排名，小的是第一名，排名从0开始

1、bind

2、protected-mode

默认为yes，远程无法访问
修改为no，远程可以访问

3、Port

默认6379

4、tcp-backlog

5、timeout

1.requirepass

修改配置文件中的 requirepass 参数，
把前面 # 注释去掉，后面 foobared 改成自己想用的密码，
重启redis即可。

进入客户端输入

auth ***						连接

1.daemonize

2.pidfile

3.loglevel

4.logfile

5、database 16

数据库设置默认16个 0-15

1.maxclients

2.maxmemory

3.maxmemory-policy

4.maxmemory-samples

1.打开一个客户端订阅channel1

subscribe channel1

2.打开另一个客户端，给channe11发布消息hello

publish channel1 hello

3.打开第一个客户端收到hello

1.简介

2、命令

汇总

1、setbit   			设置bitmaps中某个偏移量的值（0或1）
   *offset:偏移量从0开始						设置成功返回0

2、getbit  					获取bitmaps中某个偏移量的值

3、bitcount  [start end] 				统计字符串从start字节到end字节比特值为1的数量

4、bitop and(or/not/xor)  [k1 k2...]		获取多个k中的and（交集），or（并集），not（非），xor（异或）
   的操作结果并将结果保存在destkey中					返回值为and(or/not/xor)后的数量

1、设置bitmaps中某个偏移量的值

setbit   			设置bitmaps中某个偏移量的值（0或1）
*offset:偏移量从0开始						设置成功返回0

实例

2、getbit

getbit  					获取bitmaps中某个偏移量的值

3、bitcount（获取的数量是byte并非bit）

bitcount  [start end] 				统计字符串从start字节到end字节比特值为1的数量

4、bitop

bitop and(or/not/xor)  [k1 k2...]		获取多个k中的and（交集），or（并集），not（非），xor（异或）
的操作结果并将结果保存在destkey中					返回值为and(or/not/xor)后的数量

演示

Bitmaps与set的对比

1、简介

2、命令

1、pfadd

如果执行命令后HLL估计的近似基数发生变化，则返回1，否则返回0

pfadd  			添加指定元素

2、pfcount

pfcount 					计算HLL的近似基数，返回数量

3、pfmerge

pfmerge  	将一个或多个HLL合并后的结果存在

1、简介

2、命令

1、geoadd

geoadd    				添加地理位置（经度，纬度，名称）
geoadd city 19.21 32.23 guangzhou

2、geopos

geopos  										获取指定地区坐标值
geopos city guangzhou

3、geodist

geodist    [m|km|ft|mi]				获取两个位置的直线距离 单位m默认值

4、georadius

georadius    radius [m|km|ft|mi]	以给定的经纬度为中心，找出某一半径radius内的元素

1、pom文件

	redis.clients
    jedis
    3.2.0

2、开放防火墙

systemctl status firewalld			查看防火墙状态
systemctl stop firewalld			关闭防火墙

3、配置文件

1、bind127.0.0.1		-》			#bind127.0.0.1	注释掉61行 
2、protected-mode yes	-》			protected-mode no 关闭保护模式

4、重启redis

1、ps -ef|grep redis			查看进程
2、kill -9 pid					杀掉进程

5、测试连接

public class JedisDemo01 {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.88.129", 6379);
        
        String value = jedis.ping();
        System.out.println(value);        
        //输出PONG
    }
}

6、测试String

public void demo1() {
        Jedis jedis = new Jedis("192.168.88.129", 6379);

        jedis.set("name", "jiali");
        String name = jedis.get("name");
        
        System.out.println(name);

        Set keys = jedis.keys("*");
        for (String key : keys) {
            System.out.println("key:" + key);
        }
    }

1、生成6位随机数

public static String getCode() {
    Random random = new Random();
    String code = "";
    for (int i = 0; i < 6; i++) {
        //取10之间的数字
        int rand = random.nextInt(10);
        code += rand;
    }
    return code;
}

2、每个手机每天只能发送三次，验证码放到redis中，设置过期时间

public static void sendCode(String phone) {
    Jedis jedis = new Jedis("192.168.88.129", 6379);
    jedis.auth("****");

    //拼接key
    //手机发送次数key
    String countKey = phone + ":count";
    //验证码key
    String codeKey = phone + ":code";

    //每个手机每天只能发送三次
    String count = jedis.get(countKey);
    if (count == null) {
        //没有发送次数，第一次发送
        //设置发送次数是1
        jedis.setex(countKey, 24 * 60 * 60, "1");
    } else if (Integer.parseInt(count) <= 2) {
        //发送次数+1
        jedis.incr(countKey);
    } else if (Integer.parseInt(count) > 2) {
        //发送三次，不能再发送
        System.out.println("今天发送次数已经超过三次");
        jedis.close();
        //中断获取验证码后续操作
        return;
    }

    //发送验证码放到redis
    String code = getCode();
    jedis.setex(codeKey, 120, code);
    jedis.close();

}

3、验证码校验

public static void verifyCode(String phone, String inputCode) {

    Jedis jedis = new Jedis("192.168.88.129", 6379);
    jedis.auth("****");

    String codeKey = phone + ":code";
    String redisCode = jedis.get(codeKey);

    if (redisCode.equals(inputCode)) {
        System.out.println("成功");
    } else {
        System.out.println("失败");
    }
}

4、验证

1、sendCode("10086");

2、进入redis-cli，查看keys *,查看验证码填入下面？

3、verifyCode("10086","?");

4、成功

1、pom

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


    org.apache.commons
    commons-pool2

2、配置文件

spring:
  redis:
    host: 192.168.88.129
    port: 6379
    password: ****
    database: 0
    #连接超时时间
    timeout: 1800000
    lettuce:
      pool:
        #最大连接数
        max-active: 20
        #最大阻塞等待时间（负数表示没限制）
        max-wait: -1
        #最大最小空间连接
        max-idle: 5
        min-idle: 0

3、RedisConfig

package com.laptoy.redis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate template = new RedisTemplate<>();

        RedisSerializer redisSerializer = new StringRedisSerializer();

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();

        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        template.setConnectionFactory(factory);

        //key序列化
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashKeySerializer(jackson2JsonRedisSerializer);

        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {

        RedisSerializer redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();

        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        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;
    }
}

4、测试Controller

@RestController
public class RedisTestController {

    @Autowired
    RedisTemplate redisTemplate;

    @GetMapping("/test")
    public String redisTest() {

        redisTemplate.opsForValue().set("name", "jiali");

        String name = (String) redisTemplate.opsForValue().get("name");

        return name;
    }
}

1、组队中某个命令出现报告错误，执行时整个的所有队列都会被回滚

2、执行阶段某个命令报错，则只有报错的不会执行，其他正常执行

例子：同一个账户有10000块，三个人登录同一个账户同一时刻购买东西

客户端1

客户端2

被watch的客户端的key成功执行事务后，自动取消watch状态

1.客户端添加秒杀商品 iphone 10件

set sk:iphone:kc 10

2.获取随机用户id

public static String getUid() {
    Random random = new Random();
    String uid = "";
    int rand = random.nextInt(20);
    uid += rand;

    return uid;
}

3.秒杀过程

public static void doSecKill(String uid, String pid) {

    if (uid == null || pid == null) {
        System.out.println("用户名或商品名不能为空");
    }

    Jedis jedis = new Jedis("192.168.88.129", 6379);
    jedis.auth("****");

    //1、库存key
    String kcKey = "sk:" + pid + ":kc";
    //2、用户key
    String userKey = "sk:" + pid + ":user";
    //3、判断秒杀是否开始
    String kc = jedis.get(kcKey);
    if (kc == null) {
        System.out.println("秒杀未开始");
        jedis.close();
        //中止
        return;
    }

    //4、判断用户是否重复秒杀
    if (jedis.sismember(userKey, uid)) {
        System.out.println("您已经秒杀成功，无法重复参与");
        jedis.close();
        //中止
        return;
    }

    //5、判断库存数量
    if (Integer.parseInt(kc) <= 0) {
        System.out.println("秒杀已结束");
        jedis.close();
        //中止
        return;
    }

    //6、秒杀过程
    //6.1、库存-1
    jedis.decr(kcKey);
    
    //6.2、把秒杀用户添加到清单里
    jedis.sadd(userKey, uid);
    System.out.println("秒杀成功");
    jedis.close();
}

4.测试

public static void main(String[] args) {
    for (int i = 0; i <20 ; i++) {
        doSecKill(getUid(), "iphone");
    }
}

自行模拟tomcat测试，此处省略

1.使用工具ab模拟测试
centos6默认安装，centos7需要手动安装

2.安装ab

yum install httpd-tools

3.命令

ab --help

ab      http://....			
	-n 请求数量
	-c 请求并发量
	-p post请求时提交参数
	-T 指定参数类型post/put

1.使用数据库连接池解决–单例模式懒加载，双重校验锁

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisPoolUtil{
    private static volatile JedisPool jedisPool = null;

    private JedisPoolUtil() {
    }

    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);
                    //测试连接状态 ping pong
                    poolConfig.setTestOnBorrow(true);

                    jedisPool = new JedisPool(poolConfig, "192.168.88.129", 6379, 60000, "****");
                }
            }
        }
        return jedisPool;
    }

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

2.测试连接

JedisPool jedisPoolInstance = JedisPoolUtil.getJedisPoolInstance();
Jedis jedis = jedisPoolInstance.getResource();

1.乐观锁解决

代码演示
1.注释秒杀过程

//6、秒杀过程
//6.1、库存-1
//jedis.decr(kcKey);
//6.2、把秒杀用户添加到清单里
//jedis.sadd(userKey, uid);

2.加了乐观锁

jedis.watch(kcKey);

Transaction multi = jedis.multi();

multi.decr(kcKey);
multi.sadd(userKey, uid);

List