1.springboot 目前的推荐版是2.1.2.RELEASE,我们就以当前最新的推荐版为例;

2.关于redis在linux下安装,可以参考《linux下安装redis》  《linux下redis集群搭建》

3.spring-data-redis 目前spring的官网的版本是2.1.5,详细查看https://spring.io/projects/spring-data-redis#overview

关于官网描述的特性,主要的几点如下:
1.支持jedis和lettuce,不支持JRedis和SRP

   特别介绍下在2.x版本中,默认是使用lettuce;1.x版本的时候,默认使用的就是Jedis;关于两个的区别:

  1. # Jedis和Lettuce都是Redis Client
  2. # Jedis 是直连模式,在多个线程间共享一个 Jedis 实例时是线程不安全的。
  3. # 如果想要在多线程环境下使用 Jedis,需要使用连接池。
  4. # 每个线程都去拿Jedis 实例,当连接数量增多时,物理连接成本就较高了。
  5. # Lettuce 是基于 netty 的,netty 是一个多线程、事件驱动的 I/O 框架,连接实例可以在多个线程间共享,通过异步的方式可以让我们更好的利用系统资源,而不用浪费线程等待网络或磁盘I/O。

2.异常的处理转换
3.RedisTemplate提供的是redis操作的高级抽象
4.Pubsub 支持
5.redis的哨兵模式以及集群模式的支持
6.JDK, String, JSON and Spring Object/XML的序列化映射
……………………后面的就不翻译了,英语也不太好,翻译的也不太好………………

4.springboot2.x整合redis;主要是使用Jedis的方式,毕竟1.x版本的时候,默认使用的就是Jedis;

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.2.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
 <properties>
        <java.version>1.8</java.version>
        <!-- 默认为2.9.1版本,运行的时候,会报错,指定低一个版本的 -->
        <jedis.version>2.9.0</jedis.version>
    </properties>
<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <!-- 默认指定了 lettuce,我们需要排除,并且引入jedis的客户端-->
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

yml文件的配置

spring:
  redis:
    database: 0
    host: localhost
    port: 6379
    timeout: 
      nano: 2
      seconds: 2
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0

查看redis的配置类org.springframework.boot.autoconfigure.data.redis.RedisProperties,与springboot1.x不同的是
timeout属性由之前的int类型,换成了java8的类型;(下部分,会用源码的形式,查看timeout的类型的改变)
Jedis与Lettuce的连接属性进行了区别;

如果想使用Lettuce,进行整合,只需要把引入spring-boot-starter-data-redis,默认就是Lettuce,只需要把连接池属性改成Lettuce;

如果是集群搭建,配置文件如下

spring:
  redis:
    cluster:
      nodes:
      - 192.168.112.129:7000
      - 192.168.112.129:7001
      - 192.168.112.129:7002
      - 192.168.112.129:7003
      - 192.168.112.129:7004
      - 192.168.112.129:7005
      max-redirects: 3
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0

5.测试,以及测试结果就不演示了,很简单的案例

在测试过程中,使用redis的客户端(界面化工具),直接获取数据,会遇到序列化的问题;在org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration自动装配类中,实例化了redisTemplate和stringRedisTemplate;

@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
	public RedisTemplate<Object, Object> redisTemplate(
			RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	@Bean
	@ConditionalOnMissingBean
	public StringRedisTemplate stringRedisTemplate(
			RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

}

我们简单查看源码,就可以看到序列化的问题;

先看RedisTemplate<Object, Object> template = new RedisTemplate<>();的实例化,RedisTemplate构造方法下的,重写父级的public void afterPropertiesSet()方法,直接查看父级的org.springframework.data.redis.core.RedisAccessor类,可以看到afterPropertiesSet()方法,实现于spring的org.springframework.beans.factory.InitializingBean接口,关于InitializingBean接口作用,以及什么时机执行,大家自行去了解

	/*
	 * (non-Javadoc)
	 * @see org.springframework.data.redis.core.RedisAccessor#afterPropertiesSet()
	 */
	@Override
	public void afterPropertiesSet() {

		super.afterPropertiesSet();

		boolean defaultUsed = false;

		if (defaultSerializer == null) {

			defaultSerializer = new JdkSerializationRedisSerializer(
					classLoader != null ? classLoader : this.getClass().getClassLoader());
		}

		if (enableDefaultSerializer) {

			if (keySerializer == null) {
				keySerializer = defaultSerializer;
				defaultUsed = true;
			}
			if (valueSerializer == null) {
				valueSerializer = defaultSerializer;
				defaultUsed = true;
			}
			if (hashKeySerializer == null) {
				hashKeySerializer = defaultSerializer;
				defaultUsed = true;
			}
			if (hashValueSerializer == null) {
				hashValueSerializer = defaultSerializer;
				defaultUsed = true;
			}
		}

		if (enableDefaultSerializer && defaultUsed) {
			Assert.notNull(defaultSerializer, "default serializer null and not all serializers initialized");
		}

		if (scriptExecutor == null) {
			this.scriptExecutor = new DefaultScriptExecutor<>(this);
		}

		initialized = true;
	}

 看代码,就可以看到,在没有指定keySerializer,valueSerializer的情况下,默认使用的是defaultSerializer;

我们在看StringRedisTemplate template = new StringRedisTemplate();构造方法,相信大家也都能看懂,调用了set的方法,把序列化的类,直接使用string的形式

public StringRedisTemplate() {
		setKeySerializer(RedisSerializer.string());
		setValueSerializer(RedisSerializer.string());
		setHashKeySerializer(RedisSerializer.string());
		setHashValueSerializer(RedisSerializer.string());
	}

 所有说,我们对序列化以及反序列化的时候,一般情况下,json串-->POJO对象转换的时候,自己手动转换,可以直接使用StringRedisTemplate;而需要自动转换的时候,可以自定义一个RedisTemplate的实例,使用Jackson2JsonRedisSerializer的形式,序列化valueSerializer,代码如下:

我把key序列了字符换,val用的jackson2JsonRedisSerializer序列化,大家可以根据实际情况来操作;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
                Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setKeySerializer(RedisSerializer.string());
//        template.setValueSerializer(RedisSerializer.string());
//        template.setHashKeySerializer(RedisSerializer.string());
//        template.setHashValueSerializer(RedisSerializer.string());
        return template;
    }
}

测试代码如下,比较简单,大家自行测试即可 

@RunWith(SpringRunner.class)
@SpringBootTest
public class BadgerRedisSingleApplicationTests {
    @Autowired
    RedisTemplate<String, Object> redisTemplate;

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    @Test
    public void testRedisTemplate() {
        final String key = "obj";
        List<String> strs = Arrays.asList("d", "b", "a", "c", "a");
        ValueOperations<String, Object> opsForValue = redisTemplate.opsForValue();
        opsForValue.set(key, strs);
        Object str = opsForValue.get(key);
        System.out.println(str);
    }

    @Test
    public void testString() {
        final String key = "test";
        ValueOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();
        opsForValue.set(key, "test");
        String str = opsForValue.get(key);
        System.out.println(str);
    }
}

至此,redis的整合就完成了,下面对源码进行讲解下,不感兴趣的同学,可以略过了………………

6.自动装配的源码解析

我们先看org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration自动装配类

@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

里面的内容,上面已经介绍过了,我们直接看Import导入的JedisConnectionConfiguration的实例,我们使用的Jedis,排除了Lettuce,所以只有JedisConnectionConfiguration可以实例化成功

@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })

JedisConnectionConfiguration(RedisProperties properties,
			ObjectProvider<RedisSentinelConfiguration> sentinelConfiguration,
			ObjectProvider<RedisClusterConfiguration> clusterConfiguration,
			ObjectProvider<JedisClientConfigurationBuilderCustomizer> builderCustomizers) {
		super(properties, sentinelConfiguration, clusterConfiguration);
		this.properties = properties;
		this.builderCustomizers = builderCustomizers;
	}

	@Bean
	@ConditionalOnMissingBean(RedisConnectionFactory.class)
	public JedisConnectionFactory redisConnectionFactory() throws UnknownHostException {
		return createJedisConnectionFactory();
	}

我们先看构造方法,实例的时候自动注入了以下属性,并把properties和builderCustomizers存起来了

RedisProperties properties,:这个就yml配置文件里的属性的类
ObjectProvider<RedisSentinelConfiguration> sentinelConfiguration:这个是哨兵模式的配置
ObjectProvider<RedisClusterConfiguration> clusterConfiguration:这个是集群模式的配置
ObjectProvider<JedisClientConfigurationBuilderCustomizer> builderCustomizers:这个是普通模式的构建器

再看redisConnectionFactory()方法,也是这个类中最重要的部分,为RedisAutoConfiguration自动装配的时候,提供的RedisConnectionFactory 这个连接工厂;

private JedisConnectionFactory createJedisConnectionFactory() {
		//获取jedis客户端的配置
		JedisClientConfiguration clientConfiguration = getJedisClientConfiguration();
		//创建哨兵模式的连接工厂(yml只配置了普通模式,此处不判断不生效)
		if (getSentinelConfig() != null) {
			return new JedisConnectionFactory(getSentinelConfig(), clientConfiguration);
		}
		//创建集群模式的连接工厂(yml只配置了普通模式,此处不判断不生效)
		if (getClusterConfiguration() != null) {
			return new JedisConnectionFactory(getClusterConfiguration(),
					clientConfiguration);
		}
		//创建普通模式的连接工厂
		return new JedisConnectionFactory(getStandaloneConfig(), clientConfiguration);
	}

我们先看第一行的方法:getJedisClientConfiguration() 获取jedis客户端的配置

private JedisClientConfiguration getJedisClientConfiguration() {
		//创建默认的JedisClientConfigurationBuilder对象,并设置useSsl,readTimeout,connectTimeout属性
		JedisClientConfigurationBuilder builder = applyProperties(JedisClientConfiguration.builder());
		//获取yml文件配置的pool,并配置JedisPoolConfig 设置到poolConfig属性中
		RedisProperties.Pool pool = this.properties.getJedis().getPool();
		if (pool != null) {
			applyPooling(pool, builder);
		}
		//处理url
		if (StringUtils.hasText(this.properties.getUrl())) {
			customizeConfigurationFromUrl(builder);
		}
		//执行定制器
		customize(builder);
		return builder.build();
	}

先看第一个JedisClientConfiguration.builder()方法,构建JedisClientConfigurationBuilder对象

class DefaultJedisClientConfigurationBuilder implements JedisClientConfigurationBuilder,
			JedisPoolingClientConfigurationBuilder, JedisSslClientConfigurationBuilder {

		private boolean useSsl;
		private @Nullable SSLSocketFactory sslSocketFactory;
		private @Nullable SSLParameters sslParameters;
		private @Nullable HostnameVerifier hostnameVerifier;
		private boolean usePooling;
		private GenericObjectPoolConfig poolConfig = new JedisPoolConfig();
		private @Nullable String clientName;
		private Duration readTimeout = Duration.ofMillis(Protocol.DEFAULT_TIMEOUT);
		private Duration connectTimeout = Duration.ofMillis(Protocol.DEFAULT_TIMEOUT);

		private DefaultJedisClientConfigurationBuilder() {}

上述yml配置中spring.timeout.nano =2 以及spring.timeout.seconds =2 ;在applyProperties中,设置了readTimeout 和connectTimeout属性,这个属性默认的就是Duration.ofMillis(Protocol.DEFAULT_TIMEOUT);后面的配置,大家就自己往下看;

我们再看创建JedisConnectionFactory的最后一步,在createJedisConnectionFactory()方法中,创建完JedisClientConfiguration,开始创建new JedisConnectionFactory(getStandaloneConfig(), clientConfiguration);

我们直接看JedisConnectionFactory中的获取连接的方法 Jedis jedis = fetchJedisConnector();

public RedisConnection getConnection() {

		if (isRedisClusterAware()) {
			return getClusterConnection();
		}

		Jedis jedis = fetchJedisConnector();
		String clientName = clientConfiguration.getClientName().orElse(null);
		JedisConnection connection = (getUsePool() ? new JedisConnection(jedis, pool, getDatabase(), clientName)
				: new JedisConnection(jedis, null, getDatabase(), clientName));
		connection.setConvertPipelineAndTxResults(convertPipelineAndTxResults);
		return postProcessConnection(connection);
	}

 

protected Jedis fetchJedisConnector() {
		try {

			if (getUsePool() && pool != null) {
				return pool.getResource();
			}

			Jedis jedis = createJedis();
			// force initialization (see Jedis issue #82)
			jedis.connect();

			potentiallySetClientName(jedis);
			return jedis;
		} catch (Exception ex) {
			throw new RedisConnectionFailureException("Cannot get Jedis connection", ex);
		}
	}

	private Jedis createJedis() {

		if (providedShardInfo) {
			return new Jedis(getShardInfo());
		}

		Jedis jedis = new Jedis(getHostName(), getPort(), getConnectTimeout(), getReadTimeout(), isUseSsl(),
				clientConfiguration.getSslSocketFactory().orElse(null), //
				clientConfiguration.getSslParameters().orElse(null), //
				clientConfiguration.getHostnameVerifier().orElse(null));

		Client client = jedis.getClient();

		getRedisPassword().map(String::new).ifPresent(client::setPassword);
		client.setDb(getDatabase());

		return jedis;
	}

后面的就可以不看了,拿到Jedis实例后,就可以做相关操作了;在创建实例的时候,传入的getConnectTimeout(),getReadTimeout()参数中,就是上述readTimeout属性Duration的toMillis()方法;获取的结果跟springboot1.x版本中的int类型的,是一致的

private int getConnectTimeout() {
		return Math.toIntExact(clientConfiguration.getConnectTimeout().toMillis());
	}

好了,redis在springboot2.0中,自动装配就是这样的,有兴趣的,还可以继续深入的看下去

 

Logo

更多推荐