Spring boot注入多个redisTemplate,并更改默认序列化策略

该博客详细介绍了如何在Spring Boot应用中配置多个RedisTemplate,分别针对不同类型的键值对(String, Long, Integer),并展示了如何更改默认序列化策略为Jackson2JsonRedisSerializer。通过创建配置类RedisConfig,定义了不同的RedisTemplate Bean,并在RedisController中进行测试,展示了Set、Hash和String的操作。" 113089970,10543589,Qt实现Onvif网络配置功能详解,"['Qt开发', 'Onvif协议', '视频监控', '网络设置', '设备管理']

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1、添加maven依赖
        <dependency>
		   <groupId>org.springframework.boot</groupId>
		   <artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
2、配置文件中增加redis连接相关信息
spring.redis.hostName=192.168.0.134
spring.redis.port=6379
spring.redis.database=0
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-2
3、创建一个配置类
package com.example.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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 com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

import redis.clients.jedis.JedisPoolConfig;

@Configuration
@EnableAutoConfiguration
public class RedisConfig {

    private static Logger logger = LoggerFactory.getLogger(RedisConfig.class);

    @Bean
    @ConfigurationProperties(prefix="spring.redis")
    public JedisPoolConfig getRedisConfig(){
        JedisPoolConfig config = new JedisPoolConfig();
        return config;
    }

    @Bean
    @ConfigurationProperties(prefix="spring.redis")
    public JedisConnectionFactory getConnectionFactory(){
        JedisConnectionFactory factory = new JedisConnectionFactory();
        JedisPoolConfig config = getRedisConfig();
        factory.setPoolConfig(config);
        logger.info("JedisConnectionFactory bean init success.");
        return factory;
    }

    @Bean
    public RedisTemplate<?, ?> getRedisTemplate(){
        RedisTemplate<?,?> template = new StringRedisTemplate(getConnectionFactory()); //只能对字符串的键值操作
        System.out.println("生成<?,?>template:" + template);
        return template;
    }
    
    @Bean(name = "LongRedisTemplate")
    public RedisTemplate<String, Long> getRedisTemplate1(){
        RedisTemplate<String,Long> template = new RedisTemplate<String,Long>(); //只能对字符串的键值操作
        template.setConnectionFactory(getConnectionFactory());
    
     // 使用Jackson2JsonRedisSerialize 替换默认序列化(默认采用的是JDK序列化)
        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.setKeySerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        
        System.out.println("生成<String, Long>template:" + template);
        return template;
    }
    
    @Bean(name = "StringRedisTemplate")
    public RedisTemplate<String, String> getRedisTemplate2(){
        RedisTemplate<String,String> template = new RedisTemplate<String,String>(); //只能对字符串的键值操作
        template.setConnectionFactory(getConnectionFactory());
        
        // 使用Jackson2JsonRedisSerialize 替换默认序列化(默认采用的是JDK序列化)
        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.setKeySerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        
        System.out.println("生成<String, String>template:" + template);
        return template;
    }
    
    @Bean(name = "IntegerRedisTemplate")
    public RedisTemplate<String, Integer> getRedisTemplate3(){
        RedisTemplate<String,Integer> template = new RedisTemplate<String,Integer>(); //只能对字符串的键值操作
        template.setConnectionFactory(getConnectionFactory());
    
     // 使用Jackson2JsonRedisSerialize 替换默认序列化(默认采用的是JDK序列化)
        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.setKeySerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        
        System.out.println("生成<String,Integer>template:" + template);
        return template;
    }
}
4、使用及测试
A、测试注入不同类型的模板根据 @Resource 注解
import java.util.Set;

import javax.annotation.Resource;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RedisController {
	
	@Resource(name = "StringRedisTemplate")
	private RedisTemplate<String, String> stringRedisTemplate;
	
	@Resource(name = "LongRedisTemplate")
	private RedisTemplate<String, Long> longRedisTemplate;
	
	@Resource(name = "IntegerRedisTemplate")
	private RedisTemplate<String, Integer> integerRedisTemplate;
	
	@RequestMapping(value = "/redis")
	public String testRedis() {
		System.out.println("stringRedisTemplate:" + stringRedisTemplate);
		System.out.println("longRedisTemplate:" + longRedisTemplate);
		System.out.println("integerRedisTemplate:" + integerRedisTemplate);
		testStringRedis();
		testLongRedis();
		testIntegerRedis();
		return "成功!";
	}
	
	private void testStringRedis() {
		SetOperations<String, String> set = stringRedisTemplate.opsForSet(); //保存Set
		set.add("set1","22");  
		set.add("set1","33");  
		set.add("set1","33");  
		Set<String> resultSet =stringRedisTemplate.opsForSet().members("set1"); //获取Set
		System.out.println("resultSet:"+resultSet); 
	}
	
	private void testLongRedis() {
		SetOperations<String, Long> set = longRedisTemplate.opsForSet();
		set.add("set2",22L);  
		set.add("set2",22L);  
		set.add("set2",23L);  
		Set<Long> resultSet =longRedisTemplate.opsForSet().members("set2");  
		System.out.println("resultSet:"+resultSet); 
	}
	
	private void testIntegerRedis() {
		SetOperations<String, Integer> set = integerRedisTemplate.opsForSet();
		set.add("set3",222);  
		set.add("set3",333);  
		set.add("set3",555);  
		Set<Integer> resultSet =integerRedisTemplate.opsForSet().members("set3");  
		System.out.println("resultSet:"+resultSet); 
	}
	
}
B、测试例子(测试)Set、Hash、String
        @Resource(name = "IntegerRedisTemplate")
	private RedisTemplate<String, Integer> integerRedisTemplate;
	
	@RequestMapping(value = "/redis")
	public String testRedis() {
		testIntegerSetRedis();
		testIntegerMapRedis();
		testIntegerValueRedis();
		return "成功!";
	}
	
	private void testIntegerSetRedis() {
		System.out.println();
		System.out.println("测试Set结构");
		SetOperations<String, Integer> set = integerRedisTemplate.opsForSet(); //添加Set
		set.add("set1",22);  
		set.add("set1",33);
		set.add("set1",55);  
		Set<Integer> resultSet1 =integerRedisTemplate.opsForSet().members("set1"); //获取Set
		Set<Integer> resultSet5 =integerRedisTemplate.opsForSet().members("set100"); //获取为空的情况
		System.out.println("resultSet5:"+resultSet5); 
		System.out.println("resultSet1:"+resultSet1); 
		set.remove("set1", 22); //删除元素
		Set<Integer> resultSet2 =integerRedisTemplate.opsForSet().members("set1"); //获取Set
		System.out.println("删除后:resultSet2:"+resultSet2);
	}
	
	private void testIntegerMapRedis() {
		System.out.println();
		System.out.println("测试Hash结构");
		HashOperations<String,Object,Object> redisMap = integerRedisTemplate.opsForHash(); //添加Map
		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("goodsId", 12345);
		map.put("shopId", 52341);
		map.put("coupon", 3232);
		redisMap.putAll("hashMapTest", map); 
		Map<Object, Object> resultSet1 =integerRedisTemplate.opsForHash().entries("hashMapTest"); //获取Map
		System.out.println("resultSet1:"+resultSet1); 
		redisMap.delete("hashMapTest", "goodsId"); //删除key
		Map<Object, Object> resultSet2 =integerRedisTemplate.opsForHash().entries("hashMapTest"); //获取Map
		System.out.println("删除后:resultSet2:"+resultSet2); 
	}
	
	private void testIntegerValueRedis() {
		System.out.println();
		System.out.println("测试String-ValueOperations结构");
		ValueOperations<String, Integer> redisValue1 = integerRedisTemplate.opsForValue();
		redisValue1.set("abcde", 123444); //设置
		Integer result1 = redisValue1.get("abcde"); //获取
		System.out.println("result:" + result1);
		
		BoundValueOperations<String, Integer> redisValue2 = integerRedisTemplate.boundValueOps("abcde");
		redisValue2.set(6666); //设置
		Integer result2 = redisValue2.get(); //获取
		System.out.println("result:" + result2);
		integerRedisTemplate.delete("abcde");
		BoundValueOperations<String, Integer> redisValu3 = integerRedisTemplate.boundValueOps("abcde");
		System.out.println("删除后:result3:" + redisValu3.get());
	}
控制台打印结果:
测试Set结构
resultSet5:[]
resultSet1:[22, 33, 55]
删除后:resultSet2:[33, 55]

测试Hash结构
resultSet1:{goodsId=12345, coupon=3232, shopId=52341}
删除后:resultSet2:{shopId=52341, coupon=3232}

测试String-ValueOperations结构
result:123444
result:6666
删除后:result3:null

<think>好的,用户遇到了Spring Boot项目中由于未定义RedisTemplate Bean导致的启动报错问题。我需要先分析可能的原因,然后逐步给出解决方案。 首先,用户可能在代码中使用了@Autowired来注入RedisTemplate,但Spring Boot没有自动配置它。这可能是因为缺少相关的依赖或配置。首先需要检查pom.xml或build.gradle中是否添加了Spring Boot Redis Starter依赖。如果没有这个依赖,自动配置不会生效,导致Bean未找到的错误。 然后,检查配置是否正确。确保在application.properties或application.yml中配置了Redis服务器的连接信息,比如主机地址、端口、密码等。如果这些配置缺失或错误,即使依赖存在,Spring Boot也无法正确创建RedisTemplate实例。 接下来,用户可能需要手动配置RedisTemplate Bean。自动配置可能因为某些原因没有生效,比如使用了自定义的配置类,这时候需要显式地定义一个@Bean方法来提供RedisTemplate实例。在配置类中,使用@Configuration注解,通过@Bean方法返回RedisTemplate,设置连接工厂和序列化器等。 另外,序列化器的配置也很重要。默认情况下,RedisTemplate使用JdkSerializationRedisSerializer,这可能导致存储的键值有乱码。建议更改为StringRedisSerializer或其他合适的序列化方式,以确保数据可读性。 还要检查项目结构是否正确,确保启动类所在的包能够扫描到配置类。如果配置类不在组件扫描的路径下,Spring不会加载它,导致Bean未定义。 最后,如果问题仍然存在,查看完整的堆栈跟踪,确认错误是否确实由RedisTemplate缺失引起,或者是否有其他相关的问题,比如连接超时、认证失败等,这些可能需要不同的解决方法。 总结下来,解决方案的步骤应该是:添加依赖、配置连接信息、手动定义RedisTemplate Bean、设置正确的序列化器,确保配置被正确扫描。同时,提醒用户检查异常信息,确保问题定位准确。</think>在Spring Boot项目中遇到`RedisTemplate` Bean未定义的启动错误,通常由依赖缺失或配置不当引起。以下是分步骤解决方案: --- ### 1. 添加Redis依赖 在`pom.xml`中添加Spring Boot Redis Starter依赖: ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> ``` *Spring Boot的自动配置机制依赖此包创建RedisTemplate实例[^1]。* --- ### 2. 配置Redis连接信息 在`application.properties`或`application.yml`中配置Redis服务器信息: ```properties spring.redis.host=localhost spring.redis.port=6379 spring.redis.password=your_password ``` *若未配置,Spring Boot会尝试连接默认的`localhost:6379`,若连接失败可能导致后续Bean初始化问题[^1]。* --- ### 3. 手动定义RedisTemplate Bean(可选) 若自动配置未生效,可手动创建配置类: ```java @Configuration public class RedisConfig { @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(factory); template.setKeySerializer(new StringRedisSerializer()); template.setValueSerializer(new GenericJackson2JsonRedisSerializer()); return template; } } ``` *此配置显式定义了RedisTemplate指定了序列化器,避免使用默认的JDK序列化导致乱码[^1]。* --- ### 4. 检查依赖冲突 若存在多个Redis客户端依赖(如Jedis和Lettuce),在`pom.xml`中排除冲突依赖: ```xml <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> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency> ``` --- ### 5. 验证配置加载 确保主启动类能扫描到配置类: ```java @SpringBootApplication @EnableCaching // 如果使用缓存注解需添加 public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } ``` --- ### 6. 检查异常堆栈 若仍报错,查看完整异常信息: - 若显示`NoSuchBeanDefinitionException`,确认配置类是否被扫描 - 若显示`ConnectionFailureException`,检查Redis服务是否启动或网络可达性 --- 相关问题
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值