在SpringBoot中注入RedisTemplate实例异常的解决方案

目录
  • 注入RedisTemplate实例异常
  • 贴出详细的错误日志
  • 最后想再验证一个小的问题

注入RedisTemplate实例异常

最近,在项目开发过程中使用了RedisTemplate,进行单元测试时提示

Field redisTemplate in com.example.demo1.dao.RedisDao required a bean of type ‘org.springframework.data.redis.core.RedisTemplate’ that could not be found

翻译过来就是“找不到类型为RedisTemplate的bean”。

当然,仅看这句话我们无法确定为什么会出现这个问题。

贴出详细的错误日志

2018-08-10 14:53:49.761 - Caught exception while allowing TestExecutionListener [org.springframework.test.context.web.ServletTestExecutionListener@5af3afd9] to prepare test instance [com.example.demo1.Demo1ApplicationTests@2361365c]
java.lang.IllegalStateException: Failed to load ApplicationContext
    at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext(DefaultCacheAwareContextLoaderDelegate.java:124)
    at org.springframework.test.context.support.DefaultTestContext.getApplicationContext(DefaultTestContext.java:83)
    at org.springframework.test.context.web.ServletTestExecutionListener.setUpRequestContextIfNecessary(ServletTestExecutionListener.java:189)
    at org.springframework.test.context.web.ServletTestExecutionListener.prepareTestInstance(ServletTestExecutionListener.java:131)
    at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:230)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.createTest(SpringJUnit4ClassRunner.java:228)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner$1.runReflectiveCall(SpringJUnit4ClassRunner.java:287)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.methodBlock(SpringJUnit4ClassRunner.java:289)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:247)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:94)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
    at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:191)
    at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:86)
    at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)
Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'redisDao': Unsatisfied dependency expressed through field 'redisTemplate'; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'org.springframework.data.redis.core.RedisTemplate<java.lang.String, java.lang.Object>' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:588)
    at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:88)
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:366)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1264)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:553)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:483)
    at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:306)
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:230)
    at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:302)
    at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:197)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:761)
    at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:867)
    at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:543)
    at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:693)
    at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:360)
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:303)
    at org.springframework.boot.test.context.SpringBootContextLoader.loadContext(SpringBootContextLoader.java:120)
    at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContextInternal(DefaultCacheAwareContextLoaderDelegate.java:98)
    at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext(DefaultCacheAwareContextLoaderDelegate.java:116)
    ... 25 common frames omitted
Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'org.springframework.data.redis.core.RedisTemplate<java.lang.String, java.lang.Object>' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoMatchingBeanFound(DefaultListableBeanFactory.java:1493)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1104)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1066)
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:585)
    ... 43 common frames omitted

看到这一大段错误日志是不是有点晕,其实我们只需要看关键的错误日志就可以定位到问题。

错误日志中的第二个Caused by打印了关键的错误日志:

No qualifying bean of type ‘org.springframework.data.redis.core.RedisTemplate< java.lang.String, java.lang.Object>

笔主回看写的代码,在注入RedisTemplate< K, V>时指定了具体的类型。

@Component
public class RedisDao {
    /**
     * 注入时指定了K、V类型
     */
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Resource(name="redisTemplate")
    ValueOperations<String, Object> valOpsObj;
    @Resource(name="stringRedisTemplate")
    ValueOperations<String, String> valOpsStr;
}

根据错误日志查看DefaultListableBeanFactory这个类的第1493行的代码,源码如下:

   /**
     * 为无法解决的依赖抛出NoSuchBeanDefinitionException或BeanNotOfRequiredTypeException。
     * Raise a NoSuchBeanDefinitionException or BeanNotOfRequiredTypeException
     * for an unresolvable dependency.
     */
    private void raiseNoMatchingBeanFound(
            Class<?> type, ResolvableType resolvableType, DependencyDescriptor descriptor) throws BeansException {
        checkBeanNotOfRequiredType(type, descriptor);
        //抛出NoSuchBeanDefinitionException
        throw new NoSuchBeanDefinitionException(resolvableType,
                "expected at least 1 bean which qualifies as autowire candidate. " +
                "Dependency annotations: " + ObjectUtils.nullSafeToString(descriptor.getAnnotations()));
    }
   /**
     * 为无法解决的依赖抛出BeanNotOfRequiredTypeException,如果适用,例如,bean的目标类型匹配但是公开的代理不匹配。
     *
     *
     * Raise a BeanNotOfRequiredTypeException for an unresolvable dependency, if applicable,
     * i.e. if the target type of the bean would match but an exposed proxy doesn't.
     */
    private void checkBeanNotOfRequiredType(Class<?> type, DependencyDescriptor descriptor) {
        for (String beanName : this.beanDefinitionNames) {
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            Class<?> targetType = mbd.getTargetType();
            if (targetType != null && type.isAssignableFrom(targetType) &&
                    isAutowireCandidate(beanName, mbd, descriptor, getAutowireCandidateResolver())) {
                // Probably a proxy interfering with target type match -> throw meaningful exception.
                Object beanInstance = getSingleton(beanName, false);
                Class<?> beanType = (beanInstance != null ? beanInstance.getClass() : predictBeanType(beanName, mbd));
                if (!type.isAssignableFrom((beanType))) {
                    //抛出BeanNotOfRequiredTypeException
                    throw new BeanNotOfRequiredTypeException(beanName, type, beanType);
                }
            }
        }
        BeanFactory parent = getParentBeanFactory();
        if (parent instanceof DefaultListableBeanFactory) {
            ((DefaultListableBeanFactory) parent).checkBeanNotOfRequiredType(type, descriptor);
        }
    }

这两个方法说明了没有找到RedisTemplate< String, Object>可以匹配的Bean,那么这个问题该如何解决呢?不妨在使用RedisTemplate< K, V>时不指定具体的类型,修改代码如下:

/**
 * 注入时不指定K、V的类型 
 */
@Autowired
private RedisTemplate redisTemplate;

重新启动服务,启动日志没有报错,RedisTemplate注入Bean成功了。

为什么RedisTemplate< String, Object>注入Bean会失败呢,很是纳闷。思考很久,想到RedisTemplate在SpringBoot框架中是自动配置的,容器中默认的就是RedisTemplate的实例。

想到这里,就需要翻下官网的文档,看看官网文档有没有什么说明。果然,官方文档第30.1.1章节还是针对RedisTemplate做了说明。

官方文档地址:https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/

If you add your own @Bean of any of the auto-configured types, it replaces the default (except in the case of RedisTemplate, when the exclusion is based on the bean name, redisTemplate, not its type).

如果针对自动配置类型添加自己的Bean,它将取代默认的。我的代码好像写的没问题啊,等等…括号中这句话才是重点啊。翻译一波,在RedisTemplate的情况下除外,当排除基于Bean的名称,而不是它的类型。英文不太好,怎么翻译好像都不大通顺。

现在好像明白了,刚才的RedisTemplate< String, Object>注入时用到了@Autowired,@Autowired默认按照类型装配的。也就是说,想要获取RedisTemplate< String, Object>的Bean,要根据名字装配。那么自然想到使用@Resource,它默认按照名字装配。

再次修改代码如下:

   /**
     * 注入时指定了K、V类型
     */
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

再次重新启动服务,启动日志没有报错,RedisTemplate< String, Object>注入Bean成功了。通过这个错误,学习到SpringBoot框架中自动配置类的一个特性。同时,也反映出学习一门技术要从官网开始,避免踩坑。

在实际开发过程中,使用RedisTemplate< K, V>不是必须指定K、V的类型,使用默认的Bean就能满足需求。

最后想再验证一个小的问题

再次修改代码如下:

/**
 * Redis访问工具类
 * @author zhaoheng
 * @date   2018年8月10日
 */
@Component
public class RedisDao {
    /**
     * 注入时指定K、V类型都为String
     */
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    /**
     * 比较两个对象是否是同一个对象
     */
    public boolean compare () {
        LOG.info("redisTemplate的hashcode:{}", redisTemplate.hashCode());
        LOG.info("stringRedisTemplate的hashcode:{}", stringRedisTemplate.hashCode());
        LOG.info("equal()的结果:{}", redisTemplate.equals(stringRedisTemplate));
        return redisTemplate == stringRedisTemplate;
    }
}
/**
 * 单元测试类
 * @author zhaoheng
 * @date   2018年8月10日
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class Demo1ApplicationTests {
    private static final Logger LOG = LoggerFactory.getLogger(Demo1ApplicationTests.class);
    @Autowired
    private RedisDao redisDao;
    @Test
    public void contextLoads() {
        boolean flag = redisDao.compare();
        LOG.info("redisTemplate和stringRedisTemplate的比较结果:{}", flag);
    }
}

上边这段代码在注入RedisTemplate时指定K、V都为String类型,在compare()方法中比较redisTemplate和stringRedisTemplate是否是同一个对象。运行下单元测试类,测试结果如下:

2018-08-10 18:30:57.075 - Started Demo1ApplicationTests in 15.58 seconds (JVM running for 16.974)
2018-08-10 18:30:57.360 - redisTemplate的hashcode:1996087296
2018-08-10 18:30:57.360 - stringRedisTemplate的hashcode:1996087296
2018-08-10 18:30:57.363 - equal()的结果:true
2018-08-10 18:30:57.364 - redisTemplate和stringRedisTemplate的比较结果:true

测试结果表明redisTemplate和stringRedisTemplate是同一个对象。等等…这次注入RedisTemplate时指定K、V都为String为什么没有错呢?而且,两个对象竟然是同一个对象。还是来看下StringRedisTemplate的源码吧。

public class StringRedisTemplate extends RedisTemplate<String, String> {
    /**
     * Constructs a new <code>StringRedisTemplate</code> instance. {@link #setConnectionFactory(RedisConnectionFactory)}
     * and {@link #afterPropertiesSet()} still need to be called.
     */
    public StringRedisTemplate() {
        RedisSerializer<String> stringSerializer = new StringRedisSerializer();
        setKeySerializer(stringSerializer);
        setValueSerializer(stringSerializer);
        setHashKeySerializer(stringSerializer);
        setHashValueSerializer(stringSerializer);
    }
    /**
     * Constructs a new <code>StringRedisTemplate</code> instance ready to be used.
     *
     * @param connectionFactory connection factory for creating new connections
     */
    public StringRedisTemplate(RedisConnectionFactory connectionFactory) {
        this();
        setConnectionFactory(connectionFactory);
        afterPropertiesSet();
    }
    protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {
        return new DefaultStringRedisConnection(connection);
    }
}

看了源码是不是理解了,因为StringRedisTemplate类的父类就是RedisTemplate< String, String>,而Bean默认是单例的,两个是自然是同一个对象了。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • Redis整合SpringBoot的RedisTemplate实现类(实例详解)

    Redis整合SpringBoot>>RedisService 接口 package com.tuan.common.base.redis; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.TimeUnit; public interface RedisService { //Redis 字符串(String) /** * 模糊值再删除 * @param

  • SpringBoot通过RedisTemplate执行Lua脚本的方法步骤

    lua 脚本 Redis 中使用 lua 脚本,我们需要注意的是,从 Redis 2.6.0后才支持 lua 脚本的执行. 使用 lua 脚本的好处: 原子操作:lua脚本是作为一个整体执行的,所以中间不会被其他命令插入. 减少网络开销:可以将多个请求通过脚本的形式一次发送,减少网络时延. 复用性:lua脚本可以常驻在redis内存中,所以在使用的时候,可以直接拿来复用,也减少了代码量. 1.RedisScript 首先你得引入spring-boot-starter-data-redis依赖,其

  • 如何解决redisTemplate注入为空问题

    springboot2.*集成redis时,redis工具类中的redisTemplate注入后总是为空. 问题代码还原: 1.工具类定义成静态工具类,@Resource注入redisTemplate public class RedisCacheUtil { @Resource private static RedisTemplate<String, Object> redisTemplate; /** * 普通缓存获取 * @param key 键 * @return 值 */ publi

  • springboot拦截器无法注入redisTemplate的解决方法

    在工作中我们经常需要做登录拦截验证或者其他拦截认证功能,基于springboot项目下我们很容易想到结合redis做的分布式拦截,把用户登录或者需要验证的信息放到redis里面.但是在写拦截器的时候发现redisTemplate一直无法注入进来,最后查资料才发现springboot拦截器是在Bean实例化之前执行的,所以Bean实例无法注入. 先看下问题,新建一个拦截器,然后注入redisTemplate /** * @author: lockie * @Date: 2019/8/13 16:1

  • 在SpringBoot中注入RedisTemplate实例异常的解决方案

    目录 注入RedisTemplate实例异常 贴出详细的错误日志 最后想再验证一个小的问题 注入RedisTemplate实例异常 最近,在项目开发过程中使用了RedisTemplate,进行单元测试时提示 Field redisTemplate in com.example.demo1.dao.RedisDao required a bean of type ‘org.springframework.data.redis.core.RedisTemplate’ that could not b

  • 如何在SpringBoot中使用logback优化异常堆栈的输出详解

    目录 一.背景 二.需求 三.使用的技术 四.技术实现 1.引入依赖 2.代码实现 3.使用 ShortenedThrowableConverter 来优化异常堆栈 4.查看运行结果 五.完整代码 六.参考文档 总结 一.背景 在我们在编写程序的过程中,无法保证自己的代码不抛出异常.当我们抛出异常的时候,通常会将整个异常堆栈的信息使用日志记录下来.通常一整个异常堆栈的信息是比较多的,而且存在一些没用的信息.那么我们如何优化一些异常堆栈的信息打印,过滤掉不必要的信息呢? 二.需求 1.现有的异常堆

  • Redis6搭建集群并在SpringBoot中使用RedisTemplate的实现

    目录 原理 搭建集群 SpringBoot中使用RedisTemplate 原理 Redis Cluster 一般由多个节点组成,节点数量至少为 6 个才能保证组成完整高可用的集群,其中三个为主节点,三个为从节点.三个主节点会分配槽,处理客户端的命令请求,而从节点可用在主节点故障后,顶替主节点. 如上图所示,该集群中包含6个Redis节点3个主服务器3个从服务器,分别为M1,M2,M3,S1,S2,S3.除了主从 Redis 节点之间进行数据复制外,所有 Redis 节点之间采用 Gossip

  • springboot中自定义异常以及定制异常界面实现过程解析

    不多说废话,直接进入主菜!! 步骤: 1.搭建SpringBoot的开发环境,略(有不会的可以私信我). 2.编写一个自定义异常,自定义异常需要继承RuntimeException.写一个构造函数,并调用父类保存异常信息. public class MyException extends RuntimeException { public MyException(String massage) { super(massage); } } 3.编写一个控制器,用于抛出异常.当请求参数param=a

  • 在springboot中注入FilterRegistrationBean不生效的原因

    springboot注入FilterRegistrationBean不生效 回顾 最近自定义了两个过滤器,接口请求返回加密和sql注入处理过滤器,因为在封装一些工具包,我在单独调好之后,就打算做成一个注解,像springboot启动类上加@EnableScheduling一样,可以随意控制,当我不想让这俩过滤器生效的时候,那就不加这个注解就可以了. 当然我想到了FilterRegistrationBean的使用方法,注入这两个过滤器. 但是当我写完之后,打成包之后,发现只有sql注入过滤器生效.

  • SpringBoot中定制异常页面的实现方法

    定制异常页面,可以避免用户产生恐慌心理,使得产品有更好的用户体验.今天来学习在 SpringBoot 中如何定制开发异常页面 一.历史回顾 在 SpringMVC 年代,我们的异常页面一般配置在 web.xml 文件中,如下: <!-- 配置404页面 --> <error-page> <error-code>404</error-code> <location>/error/404.html</location> </erro

  • SpringBoot中使用HTTP客户端工具Retrofit

    前言 我们平时开发项目时,就算是单体应用,也免不了要调用一下其他服务提供的接口.此时就会用到HTTP客户端工具,之前一直使用的是Hutool中的HttpUtil,虽然容易上手,但用起来颇为麻烦!最近发现一款更好用的HTTP客户端工具Retrofit,你只需声明接口就可发起HTTP请求,无需进行连接.结果解析之类的重复操作,用起来够优雅,推荐给大家! SpringBoot实战电商项目mall(50k+star)地址:https://github.com/macrozheng/mall 简介 Ret

  • SpringBoot中自定义注解实现控制器访问次数限制实例

    今天给大家介绍一下SpringBoot中如何自定义注解实现控制器访问次数限制. 在Web中最经常发生的就是利用恶性URL访问刷爆服务器之类的攻击,今天我就给大家介绍一下如何利用自定义注解实现这类攻击的防御操作. 其实这类问题一般的解决思路就是:在控制器中加入自定义注解实现访问次数限制的功能. 具体的实现过程看下面的例子: 步骤一:先定义一个注解类,下面看代码事例: package example.controller.limit; import org.springframework.core.

  • mybatis+springboot中使用mysql的实例

    目录 依赖引入 配置引入 案例实现 案例源码 在软件开发中,数据库的引入是必不可少的,其中又属mysql使用最为广泛,而在springboot中,集成使用mysql的方式有很多(例如jpa),这里来展现一下通过mybatis框架在springboot中使用mysql. 依赖引入 首先在使用初始化工程的时候加入mybatis.mysql相关的依赖,如下所示: <dependencies> <dependency> <groupId>org.springframework.

随机推荐