【学习打卡】第8天 Springboot整合Redis学习@慕课网原创_慕课网

课程名称：Java架构师-技术专家
课程章节：第7周集群架构：主从复制高可用Redis集群
主讲老师：慕课讲师团：Geely、风间影月、阿神……

课程内容：

1、阻塞与非阻塞

1.1、阻塞模型

用户与服务器通信，需要发起请求，服务器就会去做相应的处理。

当一个请求正在处理的时候，后续所有的请求都要等待正在处理的请求处理完毕，直到第一个请求处理完毕响应给客户端之后，之后的请求才能被处理，这种一对一处理的模式就是阻塞的通信模式。效率低下，开销大。

1.2、非阻塞模型：

第一个请求等待响应的时候，后续请求是不会被阻塞的，之后的请求仍然可以被处理，这种模式就是多路复用的模式，处理效率高、支持的并发也非常高。

2、 Redis 的线程模型

Redis server 通过客户端进行连接，可以是 redis-cli，也可以是Java 客户端等。

Redis Server 启动之后会产生一个进程，内部有多路复用器和文件事件分配器，文件事件分配器专门用于分配事件，分配器下面有三个不同的处理器，分别是连接应答处理器、命令请求处理器、命令回复处理器。

主要作用是和客户端保持连接，在 redis server 启动之后，当客户端和 server 建立连接的时候，客户端会发送一个 read 标志（其实就是一个 read 事件），这时候 redis 会产生一个 server-socket，这个 server-socket 和客户端的 Read 标志是一一对应的（socker 通信）。随后就会交给多路复用器进行处理，它是非阻塞的，只负责接受。之后会将其通过管道传输到文件事件处理器。

当文件事件处理器识别到这个事件是 read 事件之后，就会把它交给连接应答处理器，和连接应答处理器做到一个匹配，即 client 端和 server 端建立连接。建立好连接之后，这个事件会交给命令请求处理器（处理请求）。

命令回复处理器用于处理响应，会给客户端返回一些内容。这个事件成为 AE_Writable 事件。

Redis 单线程模型非常快的原因是一是采用了多路复用的机制，多路复用器处理速度非常快，二是 redis 的所有操作都是在纯内存中进行的，所以速度是非常快的。

使用了单线程可以避免上下文切换等损耗，效率非常高。

3、SpringBoot整合Redis

3.1、创建springboot工程

创建springboot 工程，引入如下依赖

  <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--引入 Redis 依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.7.0</version>
        </dependency>
    </dependencies>

3.2、配置 redis-server 信息

在 application.yaml 中增加配置

spring:
  redis:
    host: 47.94.9.237
    port: 6379
    database: 7
	# password: password

3.3、使用 redis 客户端连接 server

编写 RedisController.java

package com.wkq.springbootredis.controller;

import com.wkq.springbootredis.utils.RedisOperator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
public class RedisController {
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private RedisOperator redisOperator;

    @GetMapping("/set")
    public String set(String key,String value) {
//        redisTemplate.opsForValue().set(key, value);
        redisOperator.set(key, value);
        return "ok！";
    }
    @GetMapping("/get")
    public String get(String key) {
        return redisOperator.get(key);
//        return (String) redisTemplate.opsForValue().get(key);
    }

    @GetMapping("/del")
    public Object del(String key) {
        redisOperator.del(key);
        return "ok";
//        return redisTemplate.delete(key);
    }

}
···
编写测试 http 文件进行测试。
```http
###
GET localhost:8080/set?key=name&value=王开琦
###
GET localhost:8080/set?key=age&value=25
###
GET localhost:8080/set?key=sex&value=1

###
GET localhost:8080/get?key=name
###
GET localhost:8080/get?key=age
###
GET localhost:8080/get?key=sex

###
GET localhost:8080/del?key=name

RedisOperator 工具类

不管是 hash、 list、 set 还是 zset，都序列化成 string 类型的 json 去存储。

package com.imooc.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisClusterConnection;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.StringRedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

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

/**
 * @Title: Redis 工具类
 * @author 慕课网
 */
@Component
public class RedisOperator {
	
//	@Autowired
//    private RedisTemplate<String, Object> redisTemplate;
	
	@Autowired
	private StringRedisTemplate redisTemplate;
	
	// Key（键），简单的key-value操作

	/**
	 * 实现命令：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);
	}

	/**
	 * 批量查询，对应mget
	 * @param keys
	 * @return
	 */
	public List<String> mget(List<String> keys) {
		return redisTemplate.opsForValue().multiGet(keys);
	}

	/**
	 * 批量查询，管道pipeline
	 * @param keys
	 * @return
	 */
	public List<Object> batchGet(List<String> keys) {

//		nginx -> keepalive
//		redis -> pipeline

		List<Object> result = redisTemplate.executePipelined(new RedisCallback<String>() {
			@Override
			public String doInRedis(RedisConnection connection) throws DataAccessException {
				StringRedisConnection src = (StringRedisConnection)connection;

				for (String k : keys) {
					src.get(k);
				}
				return null;
			}
		});

		return result;
	}


	// Hash（哈希表）

	/**
	 * 实现命令：HSET key field value，将哈希表 key中的域 field的值设为 value
	 * 
	 * @param key
	 * @param field
	 * @param value
	 */
	public void hset(String key, String field, Object value) {
		redisTemplate.opsForHash().put(key, field, value);
	}

	/**
	 * 实现命令：HGET key field，返回哈希表 key中给定域 field的值
	 * 
	 * @param key
	 * @param field
	 * @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);
	}

}

学习收获：

今天学习了两个小时，收获如下：

阻塞和非阻塞模型的区别及优缺点
Redis 的线程模型，redis非常快的原因一是采用了IO多路复用器，二是所有操作都在内存中进行。
学习了 springboot 整合 redis 的步骤，① 引入依赖；② 配置redis-server的信息；③ 使用 RedisTemplate 等相关 api 即可操作 redis。

今天的学习完毕！再接再厉！