Announcement Announcement Module
Collapse
No announcement yet.
JUnit not weaving the correct Spring singleton bean Page Title Module
Move Remove Collapse
X
Conversation Detail Module
Collapse
  • Filter
  • Time
  • Show
Clear All
new posts

  • JUnit not weaving the correct Spring singleton bean

    Hi,

    I've run into a strange problem that I am having difficulty tracking down.

    I have an class (ServiceErrorInterceptor) defined as an @Aspect which is instantiated via XML configuration as a singleton bean. The XML configuration allows me to inject its dependent beans.

    In my normal workflow, everything works fine. The class is properly instantiated, and whenever the advice is called, the injected beans are as I would expect.

    However, when I run my JUnit test, all my injected beans are null. This leads me to the conclusion that the advice is called from a different bean - not the same singleton bean that was instantiated by Spring. To further validate my hypothesis, I put a breakpoint on a setter which is called during the instantiation, and see that the bean id is not the same as the bean id if I put a breakpoint in my advice.

    Is there some special configuration I must enable in my JUnit class to rectify this? My test class is already annotate with:

    Code:
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = { 
    		"classpath:spring/applicationContext-base.xml", 
    		"classpath:spring/applicationContext-jndi.xml", 
    		"classpath:spring/applicationContext-error.xml", 
    		"classpath*:spring/applicationContext-dao.xml", 
    		"classpath:spring/applicationContext-blaze.xml", 
    		"classpath:spring/applicationContext-calculateServices.xml", 
    		"classpath:spring/applicationContext-dom.xml"})
    public class LendingSimulationServiceImplTest {
    ...
    ...
    }
    I've looked through the logs (I enabled spring trace logs), but don't see anything that stands out. And posting the entire log here would likely be overkill. If there is value in a specific part of the log please let me know and I will post it.


    I'm able to post my code for the aspect, my junit and my config if that is helpful.

    application-context.xml snippet:
    Code:
             <!-- SPRING ASPECT BEAN.  POINTCUT DEFINED IN BEAN WITH ANNOTATION -->
    	<bean id="serviceErrorInterceptor" class="com.cws.cs.lendingsimulationservice.error.ServiceErrorInterceptor" scope="singleton">
    		<property name="errorMessageProvider" ref="resourceBundleProviderImpl"/>
    		<property name="defaultLocale">
    			<util:constant static-field="java.util.Locale.ENGLISH" />
    		</property>
    	</bean>
    Any suggestions would be appreciated.

    Thanks,

    Eric

  • #2
    I did a little further investigation and found the following. My bean is implemented as:

    Code:
        @Aspect
        public class ServiceErrorInterceptor {
        
        	/**
        	 * Logger
        	 */
        	private static final Logger logger = LoggerFactory.getLogger(ServiceErrorInterceptor.class);
        
        	/**
        	 * SOAP Header data
        	 */
        	@Autowired
        	private SOAPHeaderData soapHeaderData;
        	
        	public ServiceErrorInterceptor(){
        		int x = 0;
        		x=x+1;
        		
        	}
        
        	/**
        	 * Exception Interceptor. 
        	 * @param ex
        	 */
        	@AfterThrowing(pointcut = "execution(* com.cws.cs.lendingsimulationservice.process.CalculatorProcess.calculate (..))", throwing = "ex")
        	public void errorInterceptor(Exception ex) {
        		if (logger.isDebugEnabled()) {
        			logger.debug("Error Message Interceptor started");
        		}
        
            }
    The relevant portions of my pom:
    Code:
    		<!-- Aspect Oriented Programming (AOP) Framework (depends on spring-core, 
    			spring-beans) Define this if you use Spring AOP APIs (org.springframework.aop.*) -->
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aop</artifactId>
    			<version>${org.springframework.version}</version>
    		</dependency>
    
    		<!-- Support for AspectJ Annotations -->
    		<dependency>
    			<groupId>org.aspectj</groupId>
    			<artifactId>aspectjweaver</artifactId>
    			<version>${org.aspectj}</version>
    		</dependency>
    Putting a breakpoint in the dummy constructor, I get the following results:

    - with @Aspect and XML configuration, the constructor is called twice (different bean ids)
    - if I remove the @Aspect annotation then it is only called once.
    - If leave the @Aspect but remove the XML configuration, then the constructor isn't even called.
    - If I use an @Component annotation in combination with @Aspect (but without any XML configuration), then the bean is constructed twice.
    - Oddly enough, however, with both the @Component and @Aspect annotations _AND_ the XML configuration, the constructor is still only called twice.

    So then why would having both the XML configuration and the @Aspect annotation cause the constructor to be called twice with two different bean ids?

    I have further validated that if I move the entire AOP definition into the XML configuration (removing the @Aspect and @Pointcut annotations) then the bean is only constructed once.


    Help anyone?

    Thanks!

    Eric

    Comment

    Working...
    X