springboot整合redis

　　springboot2.0整合reids，发现网上的一些整合，尤其是连接池，连接工厂那块，总是方法过时什么的，下面采用如下代码：

加入jar包

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

写propertie

spring.rabbitmq.addresses=192.168.135.129:5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.virtual-host=/

spring.redis.host=192.168.135.129
spring.redis.port=6379
spring.redis.database=0
spring.redis.jedis.pool.max-active=10
spring.redis.jedis.pool.max-idle=5
spring.redis.jedis.pool.max-wait=-1
spring.redis.jedis.pool.min-idle=3

config类

package com.sharp.forward.redis;

import java.time.Duration;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.PropertySources;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
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.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ser.std.StringSerializer;

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * 新建配置类继承CachingConfigurerSupport类
 *
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport{
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private Integer port;
    @Value("${spring.redis.database}")
    private Integer database;
    @Value("${spring.redis.jedis.pool.max-active}")
    private Integer maxActive;
    @Value("${spring.redis.jedis.pool.max-idle}")
    private Integer maxIdle;
    @Value("${spring.redis.jedis.pool.max-wait}")
    private Integer maxWait;
    @Value("${spring.redis.jedis.pool.min-idle}")
    private Integer minIdle;
    @Bean
    JedisConnectionFactory jedisConnectionFactory() {
//        spring2.0的配置可以采用redis 独立配置RedisStandaloneConfiguration或者集群配置org.springframework.data.redis.connection.RedisClusterConfiguration.class
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration ();
//    方式一：直接写死的方式
//        redisStandaloneConfiguration.setHostName("192.168.135.129");
//        redisStandaloneConfiguration.setPort(6379);
//        redisStandaloneConfiguration.setDatabase(0);
//        redisStandaloneConfiguration.setPassword(RedisPassword.of("123456"));
//    方式二：配置文件方式
        redisStandaloneConfiguration.setHostName(host);
        redisStandaloneConfiguration.setPort(port);
        redisStandaloneConfiguration.setDatabase(database);

        JedisClientConfiguration.JedisClientConfigurationBuilder jedisClientConfiguration = JedisClientConfiguration.builder();
        jedisClientConfiguration.connectTimeout(Duration.ofMillis(15000));//  connection timeout
        JedisConnectionFactory factory = new JedisConnectionFactory(redisStandaloneConfiguration,
                jedisClientConfiguration.build());
        
        return factory;
    }
//    编写redids  key默认生成器
    @Override
    public KeyGenerator keyGenerator() {
        // TODO Auto-generated method stub
        return super.keyGenerator();
    }
//    配置缓存管理
    @Bean
    public CacheManager cacheManage() {
//        两种写法都行
//        RedisCacheManager cacheManager = RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(jedisConnectionFactory()).build();
        RedisCacheManager cacheManager = RedisCacheManager.create(jedisConnectionFactory());
        return cacheManager;
    }
    
    @Bean 
    public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory connectionFactory){
//        设置序列化
//        为给定目标类设置序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
//        指定受影响的类型，属性描述符最小可见性
        om.setVisibility(PropertyAccessor.ALL,Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
//        配置redisTemplate
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<String,Object>();
        redisTemplate.setConnectionFactory(connectionFactory);
        RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }


}

实体

package com.sharp.forward.redis;

import java.io.Serializable;

public class Order implements Serializable{
    private String id;
    private Integer number;
    private String name;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public Integer getNumber() {
        return number;
    }
    public void setNumber(Integer number) {
        this.number = number;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
}

测试

package com.sharp.forward;

import java.util.HashMap;
import java.util.Map;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.Binding.DestinationType;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

import com.rabbitmq.client.AMQP;
import com.sharp.forward.redis.Order;

@RunWith(SpringRunner.class)
@SpringBootTest
public class ForwardApplicationTests {
    @Autowired
    private RabbitAdmin rabbitAdmin;
    @Test
    public void contextLoads() {
    }
    
    @Test
    public void manager() {
        rabbitAdmin.declareQueue(new Queue("admin_test", true, false,false));
        rabbitAdmin.declareExchange(new DirectExchange("admin_exchange", true, false));
        rabbitAdmin.declareBinding(new Binding("admin_test", DestinationType.QUEUE, "admin_exchange", "mq.direct", null));
        rabbitAdmin.purgeQueue("queue_test", false);
        rabbitAdmin.deleteQueue("admin_test");
        rabbitAdmin.deleteExchange("admin_exchange");
    }
    @Autowired
    private RabbitTemplate template;
    @Test
    public void sedMsg() {
        String body = "hello.object rabbitmq!";
        MessageProperties properties = new MessageProperties();
        properties.setContentEncoding("utf-8");
        properties.setContentType("text");
        properties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
        properties.setHeader("key1", "value");
        Message msg = new Message(body.getBytes(), properties);
        template.convertAndSend("ex001","mq.direct", msg, new MessagePostProcessor() {
            
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().getHeaders().put("key1", "new value");
                return message;
            }
        });
    }
    
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    public void redisWork() {
        redisTemplate.opsForValue().set("test", "test002");
    }
    @Test
    public void redisSave() {
        Order order = new Order();
        order.setId("001");
        order.setName("订单001");
        order.setNumber(20);
        redisTemplate.opsForValue().set("order:", order);
        Order order1=(Order) redisTemplate.opsForValue().get("order:");
        System.out.println(order1.getName());
        
    }
}

测试OK！