redis1-jvm缓存|redis分布式部署|缓存/session/分布式锁

痛定思痛。 2022-05-14 04:43 251阅读 0赞

### 文章目录 ###

*  前置知识
 *   *  jvm内置缓存
     *  memcache
     *   *  工作原理
         *  结构
 *  一、基础
 *   *  简介 开源
     *  Redis 优势
     *  Redis与其他key-value存储有什么不同？
     *  应用场景:
     *   *  额外的探索
     *  为什么这么快?
 *  二、安装与分布式安装
 *   *  Redis 配置文件
     *   *  让其他电脑访问到redis三种设置
 *  三、分布式锁
 *  四、整合进springboot/做缓存
 *   *   *  1.Jedis操作数据库
         *  2.springboot + redis
         *  3.redisTemplate使用PipeLine
         *  4.redis做缓存
         *  5.redis做spring-session
         *  5.redis做缓存 -批量删除key
         *  6. redis设计秒杀

# 前置知识 #

## jvm内置缓存 ##

Oscache,Ehcache,Jcache,Jbosscache  
jvm内置缓存和nosql缓存一样,存在内存中  
mybatis和hibernate二级缓存是oscache,ehcache jvm内置缓存

OsCache与EhCache区别  
ehcache 主要是对数据库访问的缓存，相同的查询语句只需查询一次数据库，从而提高了查询的速度，使用spring的AOP可以很容易实现这一功能。(Springboot支持)  
oscache 主要是对页面的缓存，可以整页或者指定网页某一部分缓存，同时指定他的过期时间，这样在此时间段里面访问的数据都是一样的。

缺点

*  容易内存溢出
 *  没有持久化机制
 *  不能分布式(不能共享)

## memcache ##

**Redis与memcached相比有哪些优势？**  
1.memcached所有的值均是简单的字符串，redis作为其替代者，支持更为丰富的数据类型  
2.redis的速度比memcached快很多  
3.redis可以持久化其数据

开源、高性能、分布式的内存对象缓存系统,用于动态web应用以减轻数据库的负载。

*  Memcache作为一个缓存区域,将数据和对象存在内存中来减少读取数据库的次数,提高网站访问速度
 *  Memcache是一个存储键值对的HashMap
 *  进行分布式,毕竟单台memcache的内存容量是有限的

redis 更优,memcache仅适合缓存  
memcache没有持久化功能,服务器关闭则数据消失  
非阻塞式,可以接受很多线程

### 工作原理 ###

在内存中开辟一个空间,然后建立一个HashTable,Memcache管理这个hash表

### 结构 ###

1.  服务器端 11211
2.  客户端

# 一、基础 #

## 简介 开源 ##

*  key-value存储系统。
 *  开源的使用ANSI C语言编写(*需要安装gcc-c++*)、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
 *  常用类型,值（value）:字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。
 *  redis的单线程的

> 什么是 BSD 协议？  
> [BSD介绍][BSD]

## Redis 优势 ##

● 性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。  
● 丰富的数据类型  
● 原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过**MULTI和EXEC**指令包起来。  
● 丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。  
● 高可用

## Redis与其他key-value存储有什么不同？ ##

● Redis有着更为**复杂的数据结构**并且提供对他们的**原子性操作**。Redis的数据类型都是基于基本数据结构的同时对程序员透明，无需进行额外的抽象。  
● **Redis运行在内存中但是周期性把数据持久化到磁盘(RDB),或者把修改操作追加到文件记(AOF)**。在内存数据库方面的另一个优点是，相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，这样Redis可以做很多内部复杂性很强的事情。同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问。  
[redis如何关闭持久化][redis]

## 应用场景: ##

\[涉及高并发或者是存在大量读数据的情况下\]  
缓存 - 任务队列  
应用排行榜,网站访问统计,数据过期处理,分布式集群架构中的session分离  
redis保存用户的购物车信息、生成订单号、访问量计数器、分布式锁,验证码,session共享

### 额外的探索 ###

*  redis的key和string类型value限制均为**512MB**。
 *  默认16个库

## 为什么这么快? ##

完全基于内存  
数据结构简单，对数据操作也简单  
采用单线程，避免了不必要的上下文切换和竞争条件  
使用多路I/O复用模型，非阻塞IO  
**这里“多路”指的是多个网络连接，“复用”指的是复用同一个线程。**

# 二、安装与分布式安装 #

[安装教程-菜鸟教程网站][-]  
`yum -y install gcc` `yum install gcc-c++`  
[安装失败合集][Link 1]

./redis-cli -h 127.0.0.1 -p 6379
    >set key value
    >get key
    >ping
    pong

## Redis 配置文件 ##

Redis 的配置文件位于 Redis 安装目录下，文件名为 redis.conf。  
主要配置修改密码:requirepass 123456  
配置连接我的有道笔记:[点这里][Link 2]

### 让其他电脑访问到redis三种设置 ###

1.关闭绑定本机  
![在这里插入图片描述][70]  
2.redis.conf中设置保护模式为no  
![在这里插入图片描述][70 1]  
3.设置密码  
![在这里插入图片描述][70 2]

主从部署文章请参考我的其他博客[点击链接][Link 3]

--------------------

# 三、分布式锁 #

import org.springframework.data.redis.core.RedisTemplate;
    
    import java.util.concurrent.TimeUnit;
    
    /** * 简易Redis分布式锁 * <p> * 根据redis单线程(原子性)特性,防止多点定时任务执行重复 * 此工具类需要引用spring-redis至少2.1版本 * <dependency> * <groupId>org.springframework.data</groupId> * <artifactId>spring-data-redis</artifactId> * <version>2.1.2.RELEASE</version> * </dependency> * * 测试使用示例: * @Test * public void test() { * String lockValue = UUID.randomUUID().toString(); * String lockKey = "key"; * try { * // 问题所在 ,等待多长时间???? * if (RedisLockUtils.lock(redisTemplate, lockKey, lockValue, 10, TimeUnit.SECONDS)) { * // 业务逻辑 * System.out.println("业务逻辑"); * } else { * System.out.println("对象被上锁,请稍后再试"); * } * } finally { * if (lockValue.equals(RedisLockUtils.getLock(redisTemplate, lockKey))) { * System.out.println("高并发场景下,只有锁对象和加锁对象是同一个线程,才能释放锁"); * RedisLockUtils.delLock(redisTemplate, lockKey); * } * } * } * * @author zhaojy * @date 2019/11/14 */
    public class RedisLockUtils { 
    
        /** * 上锁 * <p> * 使用redis的setNx命令:不存在时设置值,存在不做任何动作 * 同时设置了锁超时时间防止死锁 * * @param redisTemplate redis模板 * @param key key值 * @param value value:锁对象 * @param time 有效时间(数值) * @param timeUnit 有效时间(单位)TimeUnit.MINUTES * @return 成功返回true, 失败false */
        public static Boolean lock(RedisTemplate<String, Object> redisTemplate, String key, String value, int time, TimeUnit timeUnit) { 
            return redisTemplate.opsForValue().setIfAbsent(key, value, time, timeUnit);
        }
    
    
        /** * 释放锁 * <p> * [强制]使用try-finally强制拆锁,防止死锁 * * @param redisTemplate redis模板 * @param key key值 */
        public static void delLock(RedisTemplate<String, Object> redisTemplate, String key) { 
            redisTemplate.delete(key);
        }
    
        /** * 获取锁 * * 并发场景下,释放锁需要判断 * * @param redisTemplate 模板 * @param key key * @return 返回 [锁对象] */
        public static Object getLock(RedisTemplate<String, Object> redisTemplate, String key) { 
            return redisTemplate.opsForValue().get(key);
        }
    
    
        /** * 获取锁剩余生存时间 * * @param redisTemplate * @param key * @return */
        public static long getLockTime(RedisTemplate<String, Object> redisTemplate, String key) { 
            return redisTemplate.getExpire(key);
        }
    
    }

# 四、整合进springboot/做缓存 #

### 1.Jedis操作数据库 ###

<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

java代码

Jedis jedis = new Jedis("192.168.18.2",6379);
    //设置密码时必须验证密码
    jedis.auth("123456");
    //----------string
    jedis.set("name","zhaojianyu");
    jedis.get();
    //----------hash
    Map map = new HashMap<String,String>();
    map.put("nih","1111");
    jedis.hmset("keyHash",map);
    //----------list
    jedis.lpush("listKey","111");
    jedis.lpush("listKey","222");
    //----------set
    jedis.sadd("set","1111");
    jedis.sadd("set","3333");

### 2.springboot + redis ###

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

配置文件

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

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.stereotype.Component;
    
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    /** * Redis操作类 */
    @Component
    public class RedisOperator { 
    
    	@Autowired
    	private StringRedisTemplate redisTemplate;
    
    	/** * 实现命令：TTL key，以秒为单位，返回给定 key的剩余生存时间(TTL, time to live)。 * * @param key * @return */
    	public long ttl(String key) { 
    		return redisTemplate.getExpire(key);
    	}
    	
    	/** * 实现命令：expire 设置过期时间，单位秒 * * @param key * @return */
    	public void expire(String key, long timeout) { 
    		redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
    	}
    	
    	/** * 实现命令：INCR key，增加key一次 * * @param key * @return */
    	public long incr(String key, long delta) { 
    		return redisTemplate.opsForValue().increment(key, delta);
    	}
    
    	/** * 实现命令：KEYS pattern，查找所有符合给定模式 pattern的 key */
    	public Set<String> keys(String pattern) { 
    		return redisTemplate.keys(pattern);
    	}
    
    	/** * 实现命令：DEL key，删除一个key * * @param key */
    	public void del(String key) { 
    		redisTemplate.delete(key);
    	}
    
    	/** * =============String（字符串）================= */
    	/** * 实现命令：SET key value，设置一个key-value（将字符串值 value关联到 key） * * @param key * @param value */
    	public void set(String key, String value) { 
    		redisTemplate.opsForValue().set(key, value);
    	}
    
    	/** * 实现命令：SET key value EX seconds，设置key-value和超时时间（秒） * * @param key * @param value * @param timeout * （以秒为单位） */
    	public void set(String key, String value, long timeout) { 
    		redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    	}
    
    	/** * 实现命令：GET key，返回 key所关联的字符串值。 * * @param key * @return value */
    	public String get(String key) { 
    		return (String)redisTemplate.opsForValue().get(key);
    	}
    
    	/** * ============= Hash（哈希表）================= */
    	/** * 命令：HSET key field value， * * @param key key值 * @param field 此key下的域field * @param value 域field的值 */
    	public void hset(String key, String field, Object value) { 
    		redisTemplate.opsForHash().put(key, field, value);
    	}
    
    	/** * 实现命令：HGET key field，返回哈希表 key中给定域 field的值 * * @param key * @param field 获取key下域 * @return */
    	public String hget(String key, String field) { 
    		return (String) redisTemplate.opsForHash().get(key, field);
    	}
    
    	/** * 实现命令：HDEL key field [field ...]，删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。 * * @param key * @param fields */
    	public void hdel(String key, Object... fields) { 
    		redisTemplate.opsForHash().delete(key, fields);
    	}
    
    	/** * 实现命令：HGETALL key，返回哈希表 key中，所有的域和值。 * * @param key * @return */
    	public Map<Object, Object> hgetall(String key) { 
    		return redisTemplate.opsForHash().entries(key);
    	}
    
    	// List（列表）
    
    	/** * 实现命令：LPUSH key value，将一个值 value插入到列表 key的表头 * * @param key * @param value * @return 执行 LPUSH命令后，列表的长度。 */
    	public long lpush(String key, String value) { 
    		return redisTemplate.opsForList().leftPush(key, value);
    	}
    
    	/** * 实现命令：LPOP key，移除并返回列表 key的头元素。 * * @param key * @return 列表key的头元素。 */
    	public String lpop(String key) { 
    		return (String)redisTemplate.opsForList().leftPop(key);
    	}
    
    	/** * 实现命令：RPUSH key value，将一个值 value插入到列表 key的表尾(最右边)。 * * @param key * @param value * @return 执行 LPUSH命令后，列表的长度。 */
    	public long rpush(String key, String value) { 
    		return redisTemplate.opsForList().rightPush(key, value);
    	}
    
    }

### 3.redisTemplate使用PipeLine ###

https://blog.csdn.net/xiaoliu598906167/article/details/82218525

https://blog.csdn.net/ywj776199845/article/details/83933782

https://blog.csdn.net/supersub000/article/details/80100016

--------------------

### 4.redis做缓存 ###

@SpringBootApplication
    //下面这个注解表示开启了缓存
    @EnableCaching
    public class managerToolApplication { 
    
    	public static void main(String[] args) { 
    		ProcessUtil.setProcessID();
    		ApplicationContext app = SpringApplication.run(managerToolApplication.class, args);
    		SpringUtil.setApplicationContext(app);
    		SpringUtil.scannerBeans();
    	}
    }

业务逻辑层impl

@Cacheable(value = "findAll")
    public List<User> findAll(){ 
    	System.out.println("使用缓存此方法只进入一次");
    	List<User> list = userDao.findAll();
    	return list;
    }

### 5.redis做spring-session ###

<dependency>
        <groupId>org.springframework.session</groupId>
        <artifactId>spring-session-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>

server.port=9988
    spring.redis.host= 172.16.203.105
    spring.redis.port= 6379
    spring.redis.database=16

package com.zjy.demo;
    
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.boot.web.servlet.FilterRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.RedisNode;
    import org.springframework.data.redis.connection.RedisSentinelConfiguration;
    import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.session.data.redis.config.ConfigureRedisAction;
    import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
    import org.springframework.session.web.http.CookieSerializer;
    import org.springframework.session.web.http.DefaultCookieSerializer;
    import org.springframework.session.web.http.SessionRepositoryFilter;
    import redis.clients.jedis.JedisPoolConfig;
    
    /** * spring-session配置 * * @date 2019-08-30 * @author */
    @EnableRedisHttpSession(redisNamespace = "sqcsessions", maxInactiveIntervalInSeconds = 36000)
    public class SessionConfiguration { 
    
    	private static final String SPRING_SESSION_URL_PATTERN = "/";
    
    	@Bean
    	public static ConfigureRedisAction configureRedisAction() { 
    		return ConfigureRedisAction.NO_OP;
    	}
    
    	@Bean
    	public CookieSerializer defaultCookieSerializer() { 
    
    		DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();
    		cookieSerializer.setCookieName("cookie");
    		cookieSerializer.setCookiePath("/");
    		cookieSerializer.setUseHttpOnlyCookie(true);
    		cookieSerializer.setDomainName("AAAASESSION");
    
    		return cookieSerializer;
    	}
    
    // @Bean("springSessionDefaultRedisSerializer")
    // public RedisSerializer<Object> redisSerializer() { 
    //
    // return new GenericJackson2JsonRedisSerializer();
    // }
    
    	@Bean
    	public FilterRegistrationBean springSessionFilterRegistration(SessionRepositoryFilter<?> sessionRepositoryFilter) { 
    
    		FilterRegistrationBean registration = new FilterRegistrationBean();
    		registration.setFilter(sessionRepositoryFilter);
    		registration.addUrlPatterns(SPRING_SESSION_URL_PATTERN);
    
    		return registration;
    	}
    
    	@Bean("redisConnectionFactory")
    	public RedisConnectionFactory redisConnectionFactory() { 
    
    		JedisPoolConfig poolConfig = new JedisPoolConfig();
    		poolConfig.setMaxIdle(5);
    		poolConfig.setMinIdle(2);
    		// 是否使用主从
    		boolean useSentinel = false;
    		if (useSentinel) { 
    // RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration();
    // /* 配置 master 的名称 */
    // redisSentinelConfiguration.master("smartlink-redis");
    // redisSentinelConfiguration.setDatabase();
    // /* 配置 redis 的哨兵 sentinel */
    // //"39.105.0.95:26379,39.107.241.198:26379,39.105.216.65:26379"
    // Set<RedisNode> redisNodeSet = new HashSet<>();
    // redisProperties.getSentinel().getNodes().forEach(x->{ 
    // redisNodeSet.add(new RedisNode(x.split(":")[0],Integer.parseInt(x.split(":")[1])));
    // });
    // redisSentinelConfiguration.setSentinels(redisNodeSet);
    // JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(redisSentinelConfiguration,poolConfig);
    // return jedisConnectionFactory;
    		}
    		RedisStandaloneConfiguration redisStandaloneConfiguration =
    				new RedisStandaloneConfiguration();
    		redisStandaloneConfiguration.setHostName("172.16.203.105");
    		redisStandaloneConfiguration.setPort(6379);
    		redisStandaloneConfiguration.setPassword("");
    		redisStandaloneConfiguration.setDatabase(16);
    		JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(redisStandaloneConfiguration);
    		jedisConnectionFactory.setPoolConfig(poolConfig);
    		return jedisConnectionFactory;
    	}
    }

[☆☆☆☆☆☆☆☆☆☆lianjie☆☆☆☆][lianjie]

### 5.redis做缓存 -批量删除key ###

正则批量删除key

// 批量查询 "前缀" 开头的 key
    Set<String> keys = redisTemplate.keys("前缀" + ":*");
    if (!CollectionUtils.isEmpty(keys)) { 
        redisTemplate.delete(keys);
    }

批量插入数据到缓存

// 放入缓存
    List result = redisTemplate.execute(new RedisCallback<List>() { 
    	@Nullable
    	@Override
    	public List doInRedis(RedisConnection connection) throws DataAccessException { 
    	    connection.openPipeline();
    	    List<EnterpriseSetting> enterpriseSettingList = enterpriseSettingMapper.listAll();
    	    if (!CollectionUtils.isEmpty(enterpriseSettingList)) { 
    	        for (EnterpriseSetting setting : enterpriseSettingList) { 
    	            try { 
    	                connection.set(generateKey(setting.getEnterpriseId()).getBytes(), objectToBytes(setting));
    	            } catch (Exception e) { 
    	                e.printStackTrace();
    	            }
    	        }
    	    }
    	    return connection.closePipeline();
    	}
    });
    
    private static <T> byte[] objectToBytes(T obj) { 
        byte[] bytes = null;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ObjectOutputStream sOut;
        try { 
            sOut = new ObjectOutputStream(out);
            sOut.writeObject(obj);
            sOut.flush();
            bytes = out.toByteArray();
        } catch (IOException e) { 
            e.printStackTrace();
        }
        return bytes;
    }

### 6. redis设计秒杀 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzYyNjc3_size_16_color_FFFFFF_t_70]

[BSD]: https://www.oschina.net/question/12_2825
[redis]: https://blog.csdn.net/tomisaboy/article/details/53763537
[-]: http://www.runoob.com/redis/redis-install.html
[Link 1]: https://blog.csdn.net/Yujiumin/article/details/82725059
[Link 2]: http://note.youdao.com/noteshare?id=b1d9539f0d0906829a0ee30b12939864
[70]: /images/20220514/259eb85230834c7da892d337231319eb.png
[70 1]: /images/20220514/4d575ac9b126498ca317f05c883f94fe.png
[70 2]: /images/20220514/7d426b0e2bbb4619b773a3b9a1f0e592.png
[Link 3]: https://blog.csdn.net/qq_36762677/article/details/82880239
[lianjie]: https://blog.csdn.net/plei_yue/article/details/79362372
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzYyNjc3_size_16_color_FFFFFF_t_70]: /images/20220514/d5caee2b7b1341feb1d625cd4f00934c.png