JUnit 4中不能看到豆

我用@Bean和@annotation在我的课是这样的：JUnit 4中不能看到豆

@Transactional 
@Configuration 
public class UserDAO { 

    @Bean 
    public UserDAO userDAO() 
    { 
     return new UserDAO(); 
    } 
    private HibernateTemplate hibernateTemplate; 

    @Autowired 
    public void setSessionFactory(SessionFactory sessionFactory) { 
     this.hibernateTemplate = new HibernateTemplate(sessionFactory); 
    } 

    public void Save(User s){ 
     this.hibernateTemplate.save(s); 
    } 
}

这是我为spring-servlet.xml。请注意，我不写任何豆状“userDAO的”：

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:context="http://www.springframework.org/schema/context" 
    (...) 

    <context:annotation-config /> 
    <tx:annotation-driven transaction-manager="txManager" /> 
    <bean id="txManager" 
     class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
     <property name="sessionFactory"> 
      <ref local="sessionFactory" /> 
     </property> 
    </bean> 
    <bean id="jspViewResolver" 
     (...) 
    </bean> 

    <bean id="pdfViewResolver" class="org.springframework.web.servlet.view.XmlViewResolver"> 
      (...) 
    </bean> 

    <bean 
     class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" /> 

    <bean class="org.springframework.jmx.export.MBeanExporter"> 
     <property name="autodetect" value="false" /> 
     <property name="assembler"> 
      <bean id="jmxAssembler" 
       class="org.springframework.jmx.export.assembler.MetadataMBeanInfoAssembler"> 
       <property name="attributeSource"> 
        <bean 
         class="org.springframework.jmx.export.annotation.AnnotationJmxAttributeSource" /> 
       </property> 
      </bean> 
     </property> 

    </bean> 
    <context:component-scan base-package="pl.edm.taskcards.spring" /> 
    <context:component-scan base-package="pl.raban.resource.spring" /> 

    <bean id="messageSource" 
     class="org.springframework.context.support.ResourceBundleMessageSource" 
     p:basename="messages" /> 

    <bean id="openSessionInViewInterceptor" 
     class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor"> 
     <property name="sessionFactory" ref="sessionFactory" /> 
    </bean> 


    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" 
     (...) 
    </bean> 




    <bean id="sessionFactory" 
     class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"> 
     <property name="dataSource" ref="dataSource" /> 
     <property name="packagesToScan"> 
      <list> 
       <value>pl.edm.taskcards.spring</value> 
       <value>pl.raban.resource.spring</value> 
      </list> 
     </property> 
     <property name="hibernateProperties"> 
      <props> 
       <prop key="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</prop> 
       <prop key="hibernate.show_sql">true</prop> 
       <prop key="hibernate.connection.useUnicode">true</prop> 
       <prop key="hibernate.connection.characterEncoding">UTF-8</prop> 
       <prop key="hibernate.jdbc.batch_size">0</prop> 
       <prop key="hibernate.query.substitutions">true 1, false 0</prop> 
      </props> 
     </property> 
    </bean> 
    <tx:annotation-driven /> 

</beans>

一切工作正常，我可以在我的web应用程序保存用户。现在，我想做一个简单的测试是这样的：

@RunWith(SpringJUnit4ClassRunner.class) 
@ContextConfiguration (locations = {"classpath:**/spring-servlet.xml"}) 
@DependsOn("UserDAO") 
@Transactional 
@Configuration 
public class UserDAOTest extends AbstractTransactionalDataSourceSpringContextTests { 

    @Autowired 
    private UserDAO userDAO; 
    @Autowired 
    private SessionFactory sessionFactory; 

    public UserDAO getUserDAO() { 
     return userDAO; 
    } 
    public void setUserDAO(UserDAO userDAO) { 
     this.userDAO = userDAO; 
    } 
    public SessionFactory getSessionFactory() { 
     return sessionFactory; 
    } 
    public void setSessionFactory(SessionFactory sessionFactory) { 
     this.sessionFactory = sessionFactory; 
    } 


    @Test 
    public void testSave() { 
     User spr = new User(); 
     spr.setKzId(0); 
     spr.setOpis("User test"); 
     spr.setPlan("Plan test"); 
     spr.setPolrocze(1); 
     spr.setPrognoza1("test1"); 
     spr.setPrognoza2("test2"); 
     spr.setRok(2000); 
     userDAO.Save(spr); 
     User spr2 = userDAO.GetUserById(spr.getId()); 
     Assert.assertEquals("User test", spr2.getOpis()); 
    } 

}

但我运行这个测试后，我得到了错误：

> <pre>org.springframework.beans.factory.BeanCreationException: Error 
> creating bean with name 'pl.edm.taskcards.spring.UserDAOTest': 
> Injection of autowired dependencies failed; nested exception is 
> org.springframework.beans.factory.BeanCreationException: Could not 
> autowire field: private pl.edm.taskcards.spring.UserDAO 
> pl.edm.taskcards.spring.UserDAOTest.userDAO; nested exception is 
> org.springframework.beans.factory.NoSuchBeanDefinitionException: No 
> matching bean of type [pl.edm.taskcards.spring.UserDAO] found for 
> dependency: expected at least 1 bean which qualifies as autowire 
> candidate for this dependency. Dependency annotations: 
> {@org.springframework.beans.factory.annotation.Autowired(required=true)} 
>  at 
> org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:288) 
>  at 
> org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1074) 
>  at 
> org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireBeanProperties(AbstractAutowireCapableBeanFactory.java:374) 
>  at 
> org.springframework.test.context.support.DependencyInjectionTestExecutionListener.injectDependencies(DependencyInjectionTestExecutionListener.java:110) 
>  at 
> org.springframework.test.context.support.DependencyInjectionTestExecutionListener.prepareTestInstance(DependencyInjectionTestExecutionListener.java:75) 
>  at 
> org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:321) 
>  at 
> org.springframework.test.context.junit4.SpringJUnit4ClassRunner.createTest(SpringJUnit4ClassRunner.java:211) at 
> org.springframework.test.context.junit4.SpringJUnit4ClassRunner$1.runReflectiveCall(SpringJUnit4ClassRunner.java:287) 
>  at 
> org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15) 
>  at 
> org.springframework.test.context.junit4.SpringJUnit4ClassRunner.methodBlock(SpringJUnit4ClassRunner.java:289) 
>  at 
> org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:231) 
>  at 
> org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:49) 
>  at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193) at 
> org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)  at 
> org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191) at 
> org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)  at 
> org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184) 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:236) at 
> org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:174) 
>  at 
> org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50) 
>  at 
> org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) 
>  at 
> org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467) 
>  at 
> org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683) 
>  at 
> org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390) 
>  at 
> org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197) 
> Caused by: org.springframework.beans.factory.BeanCreationException: 
> Could not autowire field: private pl.edm.taskcards.spring.UserDAO 
> pl.edm.taskcards.spring.UserDAOTest.userDAO; nested exception is 
> org.springframework.beans.factory.NoSuchBeanDefinitionException: No 
> matching bean of type [pl.edm.taskcards.spring.UserDAO] found for 
> dependency: expected at least 1 bean which qualifies as autowire 
> candidate for this dependency. Dependency annotations: 
> {@org.springframework.beans.factory.annotation.Autowired(required=true)} 
>  at 
> org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:508) 
>  at 
> org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:84) 
>  at 
> org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:285) 
>  ... 26 more Caused by: 
> org.springframework.beans.factory.NoSuchBeanDefinitionException: No 
> matching bean of type [pl.edm.taskcards.spring.UserDAO] found for 
> dependency: expected at least 1 bean which qualifies as autowire 
> candidate for this dependency. Dependency annotations: 
> {@org.springframework.beans.factory.annotation.Autowired(required=true)} 
>  at 
> org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(DefaultListableBeanFactory.java:924) 
>  at 
> org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:793) 
>  at 
> org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:707) 
>  at 
> org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:480) 
>  ... 28 more</pre>

来源

2011-10-18 Cichy

我认为你在这里混淆了一些机制。一个@Configuration类提供bean，但不应该是bean本身。

要么使用@Component直接创建bean，要么将@Configuration注释放在不同的类上。

但它应该仍然工作，即使你是容易混淆的概念。

的问题，但是，这里应该是：

@ContextConfiguration (locations = {"classpath:**/spring-servlet.xml"})

两个问题：
一）wildcards at the beginning of resource Strings are problematic
B）如果你的Spring上下文是在WEB-INF，它不是在类路径上，因此不能通过"classpath:**/spring-servlet.xml"找到。我不知道的正规途径是单位/集成测试，访问这样的背景是什么，但我会尝试这样的事：

@ContextConfiguration (locations = { 
    "file:/src/main/webapp/WEB-INF/spring-servlet.xml"})

（见FileSystemResource caveats）

来源

2011-10-18 10:05:14

在xml中有一个应该选择UserDAO的组件扫描 - 配置是一种组件，因此组件扫描将检测它。 – gkamal

@gkamal你是对的。虽然这很丑陋，但我认为问题出在其他地方（请参阅我的更新）。哦，我刚刚看到你得出了同样的结论。对于那个：+1） –

我跑了同样的问题。春天一开始并不会抱怨通配符，这很奇怪... –

你需要声明一个bean的userDAO的类。

来源

2011-10-18 09:09:26

你的意思是 - 在我的spring-servlet.xml中写入bean？这是唯一的方法吗？ – Cichy

是的。是的，据我所知。 –

春天在哪里-servlet.xml文件 - 我猜它是在WEB-INF下，如果这样你不能使用classpath加载它：就像你在测试类中做的那样？

来源

2011-10-18 12:43:17 gkamal

JUnit 4中不能看到豆

回答

相关问题