SpringBoot实战（四）:SpringBoot整合Redis

谁借莪１个温暖的怀抱￠ 2022-03-27 07:50 322阅读 0赞

强烈推荐一个大神的人工智能的教程：[http://www.captainbed.net/zhanghan][http_www.captainbed.net_zhanghan]

### 【前言】 ###

最近自己在整理过去搭建过的框架，将用到的各个组件进行了梳理并融入自己新建的项目中（[https://github.com/dangnianchuntian/springboot][https_github.com_dangnianchuntian_springboot]），一是对过去项目的整理；二是在整理的过程中查漏补缺；三是以后可以拿过去就用；

### 【整合Redis实战】 ###

**         一、Pom中引入相应的Jar包**

<dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <dependency>
           <groupId>redis.clients</groupId>
           <artifactId>jedis</artifactId>
           <version>2.9.0</version>
    </dependency>

**         二、重要代码展示**

1、读取配置文件中配置连接Redis属性值

package com.zhanghan.zhboot.properties;
    
    import lombok.Data;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    
    @Component
    @Data
    @ConfigurationProperties
    public class RedisProperties {
    
        @Value("${spring.redis.database}")
        private int database;
    
        @Value("${spring.redis.host}")
        private String host;
    
        @Value("${spring.redis.port}")
        private int port;
    
        @Value("${spring.redis.password}")
        private String password;
    
        @Value("${spring.redis.pool.max-idle}")
        private int maxIdle;
    
        @Value("${spring.redis.pool.min-idle}")
        private int minIdle;
    
        @Value("${spring.redis.pool.max-active}")
        private int maxActive;
    
        @Value("${spring.redis.pool.max-wait}")
        private int maxWait;
    
        @Value("${spring.redis.timeout}")
        private int timeout;
    
    }

2、创建相应的Redis操作template

package com.zhanghan.zhboot.config;
    
    import com.zhanghan.zhboot.properties.RedisProperties;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
    import org.springframework.data.redis.connection.RedisPassword;
    import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
    import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.GenericToStringSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    import redis.clients.jedis.JedisPoolConfig;
    
    
    @Configuration
    @EnableCaching
    public class RedisConfig extends CachingConfigurerSupport {
    
        @Autowired
        private RedisProperties redisProperties;
    
        @Bean
        public JedisConnectionFactory jedisConnectionFactory() {
            RedisStandaloneConfiguration rf = new RedisStandaloneConfiguration();
            rf.setDatabase(redisProperties.getDatabase());
            rf.setHostName(redisProperties.getHost());
            rf.setPort(redisProperties.getPort());
            rf.setPassword(RedisPassword.of(redisProperties.getPassword()));
            JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpb =
                    (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration.builder();
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxIdle(redisProperties.getMaxIdle());
            jedisPoolConfig.setMinIdle(redisProperties.getMinIdle());
            jedisPoolConfig.setMaxTotal(redisProperties.getMaxActive());
            jedisPoolConfig.setMaxWaitMillis(redisProperties.getMaxWait());
            jedisPoolConfig.setEvictorShutdownTimeoutMillis(redisProperties.getTimeout());
            jpb.poolConfig(jedisPoolConfig);
            JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(rf, jpb.build());
            return jedisConnectionFactory;
        }
    
    
        @Bean
        public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
            return new PropertySourcesPlaceholderConfigurer();
        }
    
        @Bean
        RedisTemplate<Object, Object> redisTemplate() {
            RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(jedisConnectionFactory());
            return redisTemplate;
        }
    
        @Bean
        RedisTemplate<String, String> strRedisTemplate() {
            final RedisTemplate<String, String> template = new RedisTemplate<>();
            template.setConnectionFactory(jedisConnectionFactory());
            template.setKeySerializer(new StringRedisSerializer());
            template.setHashValueSerializer(new GenericToStringSerializer<>(String.class));
            template.setValueSerializer(new GenericToStringSerializer<>(String.class));
            return template;
        }
    
        @Bean
        RedisTemplate<String, Long> longRedisTemplate() {
            final RedisTemplate<String, Long> template = new RedisTemplate<>();
            template.setConnectionFactory(jedisConnectionFactory());
            template.setKeySerializer(new StringRedisSerializer());
            template.setHashValueSerializer(new GenericToStringSerializer<>(Long.class));
            template.setValueSerializer(new GenericToStringSerializer<>(Long.class));
            return template;
        }
    
        @Bean
        RedisTemplate<String, Boolean> booleanRedisTemplate() {
            final RedisTemplate<String, Boolean> template = new RedisTemplate<>();
            template.setConnectionFactory(jedisConnectionFactory());
            template.setKeySerializer(new StringRedisSerializer());
            template.setHashValueSerializer(new GenericToStringSerializer<>(Boolean.class));
            template.setValueSerializer(new GenericToStringSerializer<>(Boolean.class));
            return template;
        }
    }

3、使用相应的RedisTemplate演示

package com.zhanghan.zhboot.controller;
    
    import com.mysql.jdbc.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.util.ObjectUtils;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.HashMap;
    import java.util.Map;
    
    @RestController
    public class RedisController {
    
        @Autowired
        private RedisTemplate<String, String> strRedisTemplate;
        @Autowired
        private RedisTemplate<String, Long> longRedisTemplate;
        @Autowired
        private RedisTemplate<String, Boolean> booleanRedisTemplate;
    
        @RequestMapping(value = "/get/redis", method = RequestMethod.GET)
        public Map xmlAnalysis() {
            String strRedisKey = "zh:boot:String";
            String longRedisKey = "zh:boot:long";
            String booleanRedisKey = "zh:boot:bollean";
    
            String strRedisValue = strRedisTemplate.opsForValue().get(strRedisKey);
            if (StringUtils.isNullOrEmpty(strRedisValue)) {
                strRedisTemplate.opsForValue().set(strRedisKey, "张晗");
            }
    
            Long longRedisValue = longRedisTemplate.opsForValue().get(longRedisKey);
            if (ObjectUtils.isEmpty(longRedisValue)) {
                longRedisTemplate.opsForValue().set(longRedisKey, 1L);
            }
    
            Boolean booleanRedisValue = booleanRedisTemplate.opsForValue().get(booleanRedisKey);
            if (ObjectUtils.isEmpty(booleanRedisValue)) {
                booleanRedisTemplate.opsForValue().set(booleanRedisKey, true);
            }
    
            strRedisValue = strRedisTemplate.opsForValue().get(strRedisKey);
            longRedisValue = longRedisTemplate.opsForValue().get(longRedisKey);
            booleanRedisValue = booleanRedisTemplate.opsForValue().get(booleanRedisKey);
    
            Map result = new HashMap();
            result.put(strRedisKey, strRedisValue);
            result.put(longRedisKey, longRedisValue);
            result.put(booleanRedisKey, booleanRedisValue);
    
            return result;
        }
    
    }

**         三、效果展示**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70][]

**四、项目地址****及代码版本**

1、地址：[https://github.com/dangnianchuntian/springboot][https_github.com_dangnianchuntian_springboot]

2、代码版本：1.0.0-Release

### 【总结】 ###

1、总结，提炼，查漏补缺；

2、要有前瞻性。

[http_www.captainbed.net_zhanghan]: http://www.captainbed.net/zhanghan
[https_github.com_dangnianchuntian_springboot]: https://github.com/dangnianchuntian/springboot
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70]: /images/20220327/66af9fd50e7f41089bc2021c88501e69.png