继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持,我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

【学习打卡】第8天 Springboot整合Redis学习

王开琦
关注TA
已关注
手记 36
粉丝 6
获赞 11

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

课程内容:

1、阻塞与非阻塞

1.1、 阻塞模型

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

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

图片描述

1.2、非阻塞模型:

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

2、 Redis 的线程模型

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

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

主要作用是和客户端保持连接,在 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);
	}

}

学习收获:

今天学习了两个小时,收获如下:

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

今天的学习完毕!再接再厉!
图片描述
图片描述

打开App,阅读手记
1人推荐
发表评论
随时随地看视频慕课网APP