前言

之前只是在项目简单使用了Redis(只是充当缓存层实现)，对Redis的体系技术没深入了解，最近时间比较充裕，所以再次复习巩固Redis，然后打算写几篇博客记录以及分享所复习的Redis知识。

Redis从入门到实战：入门篇
Redis从入门到实战：实战篇
Redis从入门到实战：进阶篇
Redis从入门到实战：完结篇

Redis从入门到实战：实战篇

Redis Java客户端介绍
Jedis操作Redis
SpringData-Redis操作Redis
SpringBoot操作Redis

Redis Java客户端介绍

Redis Java客户端主要有三种：Jedis、Lettuce、Redisson。

Jedis

Jedis是Redis的Java实现的客户端，其API提供了比较全面的Redis命令的支持。
Jedis中的方法调用是比较底层的暴露的Redis的API，也即Jedis中的Java方法基本和Redis的API保持着一致，了解Redis的API，也就能熟练的使用Jedis。
Jedis使用阻塞的I/O，且其方法调用都是同步的，程序流需要等到sockets处理完I/O才能执行，不支持异步。Jedis客户端实例不是线程安全的，所以需要通过连接池来使用Jedis。
Jedis仅支持基本的数据类型如：String、Hash、List、Set、Sorted Set。

Lettuce

Lettuce是高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。目前springboot默认使用的客户端。
Lettuce基于Netty框架的事件驱动的通信层，其方法调用是异步的。Lettuce的API是线程安全的，所以可以操作单个Lettuce连接来完成各种操作。

Redisson

Redisson实现了分布式和可扩展的Java数据结构，提供很多分布式相关操作服务，例如，分布式锁，分布式集合，可通过Redis支持延迟队列。和Jedis相比，功能较为简单，不支持字符串操作，不支持排序、事务、管道、分区等Redis特性。Redisson的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上。
Redisson中的方法则是进行比较高的抽象，每个方法调用可能进行了一个或多个Redis方法调用。
Redisson基于Netty框架的事件驱动的通信层，其方法调用是异步的。Redisson的API是线程安全的，所以可以操作单个Redisson连接来完成各种操作。
Redisson不仅提供了一系列的分布式Java常用对象，基本可以与Java的基本数据结构通用，还提供了许多分布式服务，其中包括（BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service）。

Jedis操作Redis

上面介绍了三种Redis Java客户端，接下来就使用Jedis操作Redis，首先引入Jedis依赖：

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

在使用Jedis的时候，有两种方式可选：

单机版Jedis，对应redis.clients.jedis.Jedis类。
Jedis连接池，对应redis.clients.jedis.JedisPoolConfig类。

单机版Jedis

单机版的Jedis就是一旦与Redis建立连接成功后，然后进行一系列对Redis的操作之后，就要关闭Redis连接对象，否则会占用系统资源。

@Test
public void jedis(){
    Jedis jedis = null;
    try {
        jedis = new Jedis("localhost",6379);//设置地址和端口
//            jedis.auth(PASSWORD);//如果redis服务器配置了需要密码，此处必须设置
        jedis.select(5);//选择指定数据库
        //存储集合到redis，并取出
        jedis.lpush("names","xxxq","xxq","xq");
        System.out.println(jedis.lrange("names", 0, -1));
    }finally {
        jedis.close();
    }
}

Jedis连接池

以前我们使用MySQL、Oracle等关系型数据库的时候，都会使用数据库连接池，比如：C3P0、Druid等等。在Jedis中，也提供了一个Redis连接池来管理Redis连接对象，就是redis.clients.jedis.JedisPool，还有一个对Jedis连接池配置的类：redis.clients.jedis.JedisPoolConfig，下面我们对它进行配置。

配置连接池需要一些参数，把这些参数单独放在一个配置文件中：redis.properties

redis.host = xxx
redis.port = 6379
redis.password = xxx
redis.timeout = 5000
redis.maxTotal = 100
redis.maxIdle = 20
redis.minIdle = 5

下面封装一个Jedis连接池工具类，简化后续的开发工作。

public class JedisPoolUtils {
    private static JedisPool  pool = null;

    /**
     *  读取属性配置文件，配置Jedis连接池
     */
    static {
        Properties properties = new Properties();
        try {
            properties.load(JedisPoolUtils.class.getClassLoader().getResourceAsStream("redis.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        int maxIdle = new Integer(properties.getProperty("redis.maxIdle"));
        int minIdle = new Integer(properties.getProperty("redis.minIdle"));
        int maxTotal = new Integer(properties.getProperty("redis.maxTotal"));
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setMaxTotal(maxTotal);
        //设置主机
        String host = properties.getProperty("redis.host");
        //设置端口号
        int port = new Integer(properties.getProperty("redis.port"));
        //创建Jedis连接池
        pool = new JedisPool(poolConfig,host,port);
    }
	
	/**
		获取单机版Jedis
	*/
    public static Jedis getJedis(){
        return pool.getResource();
    }
}

使用Jedis连接池创建单机版Jedis，测试是否配置成功。使用Jedis连接池，我们不需要手动关闭Jedis连接对象。

public class JedisPoolTest{
    public static void main(String[] args) {
        Jedis jedis = JedisPoolUtils.getJedis();
        System.out.println("Redis服务正在运行："+jedis.ping());
        //set命令
        jedis.set("name", "zwq");
        System.out.println(jedis.get("name"));
    }
}

执行结果：
	Redis服务正在运行：PONG
	zwq

SpringData-Redis操作Redis

Jedis支持五种数据类型（string/hash/list/set/zset/）的操作，但在Java中我们却通常以类对象为主，所以在实际项目中，我们需要将Redis存储的五种数据类型与Java对象之间进行切换，我们可以自己编写一些工具类，实现两者之间的转换，但是涉及到许多对象的时候，这其中无论工作量还是工作难度都是很大的，所以总体来说，就操作对象而言，使用原生的Jedis还是挺难的，好在Spring对这些进行了封装和支持，也就是SpringData-Redis。

引入SpringData-Redis依赖

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>2.2.4.RELEASE</version>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.1.0</version>
</dependency>

接下来我们使用Spring配置Jedis连接池。

#redis.properties配置文件
redis.host = xxx
redis.port = 6379
redis.password = xxx
redis.timeout = 5000
redis.maxTotal = 100
redis.maxIdle = 20
redis.minIdle = 5

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p" 
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <!--Redis服务地址-->
        <property name="hostName" value="${redis.host}"/>
        <!--端口号-->
        <property name="port" value="${redis.port}"/>
        <!--如果有密码则需要配置密码-->
        <!--<property name="password" value="${redis.password}"/>-->
        <!--连接池配置-->
        <property name="poolConfig" ref="poolConfig"/>
    </bean>

    <bean id="redisTemplate"
          class="org.springframework.data.redis.core.RedisTemplate"
          p:connection-factory-ref="connectionFactory"/>

    <!--加载属性文件-->
    <context:property-placeholder location="classpath:redis.properties"/>

    <!--Spring整合配置，连接池配置-->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!--最大连接数-->
        <property name="maxTotal" value="${redis.maxTotal}"/>
        <!--最大空闲数-->
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <!--最大等待时间-->
        <property name="maxWaitMillis" value="20000"/>
        <!--最小空闲数-->
        <property name="minIdle" value="${redis.minIdle}"/>
    </bean>
</beans>

上面配置了RedisTemplate，因为普通的Redis连接对象没有办法直接将Java对象直接存入Redis内存中，我们需要替代的方案：将对象序列化（可以简单的理解为实现Serializable接口）。我们可以把对象序列化之后存入Redis缓存中，然后在取出的时候又通过转换器，将序列化之后的对象反序列化回对象，这样就完成了我们的要求。RedisTemplate可以帮助我们完成这份工作，它会找到对应的序列化器去转换Redis的键值。

创建用户实体类，实现Serializable接口。

@Data
public class User implements Serializable {
    private String name;
    private Integer age;
}

测试Spring配置是否成功。

@Test
public void springDataRedis(){
    ApplicationContext context = new ClassPathXmlApplicationContext("redis.xml");
    RedisTemplate template = context.getBean(RedisTemplate.class);
    User user = new User();
    user.setName("zhangsan");
    user.setAge(22);
    template.opsForValue().set("zhangsan",user);
    User u = (User) template.opsForValue().get("zhangsan");
    System.out.println(u);
}
运行结果：
	User(name=zhangsan, age=22)

从运行结果来看，SpringData-Redis已经自动帮我们序列化对象与反序列化对象了，使用起来非常简便。但是当我们查看Redis服务器的时候，发现存入的数据乱码了，如下图所示：
上面说了RedisTemplate通过序列化器来转换Redis的键值，而RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此序列化器完成的。出现上面问题说明就是JDK序列化器在序列化与反序列化时编码问题，我们可以更改RedisTemplate序列化器，除了JDK序列化器JdkSerializationRedisSerializer，还有一个字符串序列化器StringRedisSerializer，因为Redis的key都是字符串类型，所以我们将key的序列化器改为StringRedisSerializer，而Value使用默认的JdkSerializationRedisSerializer。

接下来按照上面总结的原因来更改上面配置文件：redis.xml

<bean id="redisTemplate"
	          class="org.springframework.data.redis.core.RedisTemplate"
	          p:connection-factory-ref="connectionFactory"
	        p:keySerializer-ref="stringSerializer"
	        p:valueSerializer-ref="jdkSerializer"/>
	
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" id="stringSerializer"/>
<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" id="jdkSerializer"/>

从上图来看，修改序列化器之后，key已经不再乱码了，但是值又乱码了。按照上面的分析可以将value的序列化器改为StringRedisSerializer就不会乱码了。

SpringBoot操作Redis

上面我们已经介绍了原生Jedis操作Redis与SpringData-Redis操作Redis，虽然没有讲大量的API，但是我们已经学会怎么使用了，剩下的就是大家自己来操作API实现效果了。接下来再介绍在SpringBoot中如何操作Redis。不管是SpringData-Redis，还是在SpringBoot中，都是通过RedisTemplate操作Redis，只不过SpringBoot做了更多的封装，让我们操作Redis更加简便。接下来先介绍RedisTemplate。

RedisTemplate

RedisTemplate只是提供操作Redis的模板API，底层还是使用Redis Java客户端来实现。

这里说一个细节，SpringBoot2.0之前默认是使用Jedis客户端底层实现，SpringBoot2.0之后就改为使用Lettuce客户端底层实现，如果需要在SpringBoot2.0之后使用Jedis，则需要排除Lettuce依赖，如下所示：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.1.0</version>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
	<exclusions>
	    <exclusion>
	        <groupId>io.lettuce</groupId>
	        <artifactId>lettuce-core</artifactId>
	    </exclusion>
	</exclusions>
</dependency>

接下来配置Redis连接池，SpringBoot省去了繁杂的XML配置，直接在application.properties配置即可。

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

编写测试代码，测试配置是否成功。

@RunWith(SpringRunner.class)
@SpringBootTest
public class AppTest {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    public void test(){
        stringRedisTemplate.opsForValue().set("name","zwq");
        System.out.println(stringRedisTemplate.opsForValue().get("name"));
    }
}
运行结果：
	zwq

上面使用的是StringRedisTemplate，它继承了RedisTemplate，从名字看它就是支持Value为String类型的读写操作，也就是Value使用了StringRedisSerializer序列化器，截图验证：

我们验证读写对象会不会出现之前使用SpriingData-Redis的乱码问题，编写一个用户实体类

@Data
public class User implements Serializable {
    private String name;
    private Integer age;
}

上面都已经配置好了，所以直接编写测试代码即可。

@Test
public void saveUser(){
    User user = new User();
    user.setName("zhangsan");
    user.setAge(22);
    redisTemplate.opsForValue().set("zhangsan",user);
    User zhangsan = (User) redisTemplate.opsForValue().get("zhangsan");
    System.out.println(zhangsan);
}
运行结果：
	User(name=zhangsan, age=22)

在程序代码中读写也是没问题，但是写入到Redis服务器上就乱码了。

这个原因也是序列化与反序列化过程中产生的问题，接下来开始指定序列化器。在SpringBoot中没有了xml配置，所以需要编写一个配置类来配置序列化器，如下代码：

@Configuration
public class RedisCnfig {

    @Autowired
    RedisConnectionFactory factory;

    @Bean
    public RedisTemplate<Object, Object> redisTemplate() {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(factory);
        //StringRedisSerializer序列化器
        StringRedisSerializer stringRedisSerializer =new StringRedisSerializer();
        //JdkSerializationRedisSerializer序列化器
        JdkSerializationRedisSerializer jdkRedisSerializer = new JdkSerializationRedisSerializer();
        redisTemplate.setValueSerializer(jdkRedisSerializer);
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

再执行上面测试代码，发现key已经不乱码了，而Value还是出现乱码。

通过把Value的序列化器修改为JSON序列化器，也就是对象与JSON之间的转换，这样就可以解决乱码的问题。

@Configuration
public class RedisCnfig {

    @Autowired
    RedisConnectionFactory factory;

    @Bean
    public RedisTemplate<Object, Object> redisTemplate() {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(factory);
        //StringRedisSerializer序列化器
        StringRedisSerializer stringRedisSerializer =new StringRedisSerializer();
        //JdkSerializationRedisSerializer序列化器
        JdkSerializationRedisSerializer jdkRedisSerializer = new JdkSerializationRedisSerializer();
        //Json序列化器
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
//        redisTemplate.setValueSerializer(jdkRedisSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

除了改配置之外，还需要引入下面依赖。

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.5.4</version>
</dependency>

再执行上面的测试代码，发现Key、Value都不会乱码了。

总结

这样就把Java操作Redis的技术讲完了，还是和上面说了，这里讲的API比较少，我们还是得自己敲，把API练熟悉了，才能把Redis运用自如，虽然我也还没把Redis运用自如。
大家觉得OK的话，不妨来个👍或者关注也行。

Redis从入门到实战：实战篇

前言

Redis从入门到实战：实战篇

Redis Java客户端介绍

Jedis

Lettuce

Redisson

Jedis操作Redis

单机版Jedis

Jedis连接池

SpringData-Redis操作Redis

SpringBoot操作Redis

RedisTemplate

总结

PDManer [元数建模]-v4.9.0 发布：一款简单好用的数据库建模平台

使用neovim打造go ide(支持代码跳转, 代码补全, 实时语法检查)

sql求连续值问题

cs01 CSS Syntax

挑战程序设计竞赛 2.3章习题 poj 3046 Ant Counting

[MASM拾遗]Offset伪指令

h30 HTML Layout Elements

了解显卡

一款基于C#开发的通讯调试工具（支持Modbus RTU、MQTT调试）

Linux/Golang/glibC系统调用

最全面Java內部類總結（面試&查漏補缺必備）

Github搜索騷技巧，快速查找優質開源項目

面試官問：你看過ArrayList源碼嗎？一文帶你深入ArrayList底層源碼

SpringBoot2.X監控和管理神器：SpringBoot Admin

SpringMVC攔截器實現原理以及登錄攔截器實現(圖文講解)

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結