Redis 入门篇

Redis简介

---

关系型数据库:

1. Mysql
2. Oracle
3. DB2
4. SQLServer

非关系型数据库

1. Redis
2. Mongo db
3. MemCached

Redis应用场景

---

1. 缓存
2. 任务队列
3. 消息队列
4. 分布式锁

Redis下载和安装

---

相关文章
windows下安装和配置Redis
Linux下安装Redis（超详细教程）_linux安装redis-CSDN博客

Redis 数据类型

---

Redis存储的是key-value结构的数据
key是字符串类型, value有五种常用数据类型

1. 字符串 String
2. 哈希 hash 适合存储对象
3. 列表 list 按照插入顺序排序 可以有重复元素
4. 集合 set 无序集合 没有重复元素
5. 有序集合 sorted set 没有重复元素

Redis 常用命令

---

字符串 string 操作命令

• SET key value 设置指定key的值
• 
• GET key 获取指定key的值
• 
• SETEX key seconds value 设置指定key的值, 并将key过期时间设置为seconds秒
• 
• SETNX key value 只有在key不存在时设置key
• 

哈希 hash 操作命令

hash 是一个 string 类型的 field 和 value 的映射表
hash 特别适合用于存储对象

• HSET key field value 将哈希表key中字段field的值设为value
• 
• HGET key field 获取存储在哈希表中指定字段的值
• 
• HDEL key field 删除存储在哈希表中的指定字段
• 
• HKEYS key 获取哈希表中所有字段
• 
• HVALS key 获取哈希表中所有值
• 
• HGETALL key 获取在哈希表中指定key所有字段和值
• 

列表 list 操作命令

Redis 列表是简单的字符串列表 按照插入顺序排序

• LPUSH key value1 [value2] 将一个或多个值插入到列表头部

• 

• LRANGE key start stop 获取列表指定范围内的元素

• 

• RPOP key 移除并获取列表最后一个元素

• 

• LLEN key 获取列表长度

• 

• BRPOP key1 [key2] timeout 移除并获取列表最后一个元素, 如果列表没有

  元素会阻塞列表知道等待超时或者发现可弹出元素为止

集合 set 操作命令

Redis set 是 string 类型的无序集合 集合成员是唯一的

• SADD key member1 [member2] 向集合中添加一个或多个成员
• 
• SMEMBERS key 返回集合中的所有成员
• 
• SCARD key 获取集合的成员数
• 
• SINTER key1 [key2] 返回给定所有集合的交集
• 
• SUNION key1 [key2] 返回给定所有集合的并集
• 
• SDIFF key1 [key2] 返回给定所有集合的差集
• 
• SREM key member1 [member2] 移除集合中一个或多个成员
• 

有序集合 sorted set 操作命令

Redis sorted set 有序集合是string类型元素的集合
且不允许重复的成员 每个元素都会关联一个double类型的分数.
redis 正是通过分数来为集合中的成员进行从小到大的排序,
有序集合的成员是唯一的, 但分数却可以重复

• ZADD key score1 member1 [score2 member2] 添加一个或多个 或更新已存在成员的分数
• 
• ZRANGE key start stop [WITHSCORES] 通过索引区间返回成员 withscores 分数也返回
• 
• ZINCRBY key incrrement member 对指定成员的分数上加上增量 increment
• 
• ZREM key member [member…] 移除一个或多个成员
• 

通用命令

• KEYS pattern 查找所有符合给定模式(pattern)的key
• 
• EXISTS key 检查给定 key 是否存在
• 
• 
• TYPE key 返回 key 所存储的值的类型
• 
• TTL key 返回给定 key 的剩余生存时间, 以秒为单位
• 
• DEL key 该命令用于在 key 存在时删除key
• 

Jedis 快速入门

---

配置依赖

	<!-- jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>5.0.0</version>
    </dependency>

    <!-- junit单元测试 -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.7.0</version>
        <scope>test</scope>
    </dependency>

建立连接 / 操作

private Jedis jedis;

	@BeforeEach
	void setUp(){
		// 1. 建立连接
		jedis = new Jedis("192.168.1.123", 6379);
		// 2. 设置密码
//		jedis.auth("123456");
		// 3. 选择数据库
		jedis.select(4);
	}
	
	@Test
	void testString(){
		// 存入数据
		String result = jedis.set("name", "zhangsan");
		System.out.println(result);
		// 获取数据
		String name = jedis.get("name");
		System.out.println(name);
	}

	@AfterEach
	void testDown(){
		// 关闭连接
		if(jedis != null){
			jedis.close();
		}
	}

@Test
	void testHash(){
		jedis.hset("user:1", "name", "zhangsan");
		jedis.hset("user:1", "age", "18");
		
		Map<String, String> map = jedis.hgetAll("user:1");
		System.out.println(map);
	}

Jedis 连接池

---

配置 jedis 连接池

private static final JedisPool jedisPool;

	static {
		// 配置连接池
		JedisPoolConfig poolConfig = new JedisPoolConfig();
		poolConfig.setMaxTotal(8);
		poolConfig.setMaxIdle(8);
		poolConfig.setMinIdle(0);
		poolConfig.setMaxWaitMillis(1000);
		// 创建连接池对象
		jedisPool = new JedisPool(poolConfig, "192.168.1.123", 6379, 1000);
	}

	public static Jedis getJedis(){
		return jedisPool.getResource();
	}

调用 jedis 连接池

@BeforeEach
	void setUp(){
		// 1. 建立连接
//		jedis = new Jedis("192.168.1.123", 6379);
		jedis = JedisConnectionFactory.getJedis(); // 改成调用~
		// 2. 设置密码
//		jedis.auth("123456");
		// 3. 选择数据库
		jedis.select(4);
	}

SpringDataRedis 快速入门

---

基本操作

引入依赖

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

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!--common pool-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

配置信息

spring:
  redis:
    host: 192.168.1.123
    port: 6379
#    password: 123456
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: 100ms

测试操作 String

	@Autowired
	private RedisTemplate redisTemplate;

	@Test
	void testString() {
		// 写入
		redisTemplate.opsForValue().set("name", "莜莜");
		// 读取
		Object name = redisTemplate.opsForValue().get("name");
		System.out.println(name);
	}

自定义序列化器

如果不自己定义序列化器 写入redis里的就是下面这种看不懂的玩意

引入 json 依赖

<!--json依赖-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

自定义序列化器

@Configuration
public class RedisConfig {

	/** 自定义序列化器 **/
	@Bean
	public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory){
		// 创建 RedisTemplate 对象
		RedisTemplate<String, Object> template = new RedisTemplate<>();
		// 设置连接工厂
		template.setConnectionFactory(connectionFactory);
		// 创建 JSON 序列化工具
		GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
		// 设置 key 的序列化
		template.setKeySerializer(RedisSerializer.string());
		template.setHashKeySerializer(RedisSerializer.string());
		// 设置 value 的序列化
		template.setValueSerializer(jsonRedisSerializer);
		template.setHashValueSerializer(jsonRedisSerializer);
		// 返回
		return template;
	}
}

再次测试结果如下

测试操作 User对象

@Test
void testSaveUser(){
	redisTemplate.opsForValue().set("user1", new User("莜莜", 18));
	User user = (User) redisTemplate.opsForValue().get("user1");
	System.out.println(user);
}

我们会发现, 写入对象进redis时它会"夹带私货",

存了个对象的类型, 这不是我们需要的, 同时还会加大宝贵的内存开销

优化

直接使用stringRedisTemplate, 省去自定义redisTemplate
增加 手动序列化和反序列化

使用 stringRedisTemplate String操作

	@Autowired
	private StringRedisTemplate stringRedisTemplate;

	@Test
	void testString() {
		// 写入
		stringRedisTemplate.opsForValue().set("name", "Youovo");
		// 读取
		Object name = stringRedisTemplate.opsForValue().get("name");
		System.out.println(name);
	}

使用 stringRedisTemplate saveUser对象操作

private static final ObjectMapper mapper = new ObjectMapper();
@Test
void testSaveUser() throws JsonProcessingException {
	// 创建对象
	User user = new User("派大星", 18);
	// 手动序列化
	String json = mapper.writeValueAsString(user);
	// 写入redis
	stringRedisTemplate.opsForValue().set("user:100", json);
	// 获取数据
	String jsonUser = stringRedisTemplate.opsForValue().get("user:100");
	// 手动反序列化
	User value = mapper.readValue(jsonUser, User.class);
	System.out.println(value);
}

序列化和反序列化的结果均达到~

补充 Hash 操作~

@Test
void testHash(){
	stringRedisTemplate.opsForHash().put("user:20", "name", "海绵宝宝");
	stringRedisTemplate.opsForHash().put("user:20", "age", "18");
	stringRedisTemplate.opsForHash().entries("user:20").forEach((k, v) -> {
		System.out.println(k + " = " + v);
	});
}

小结

相关文章

Spring Data Redis操作Redis-CSDN博客