Defining the request scope as prototype for integration tests

Question

When writing integration tests with Spring 3.1, I usually define the request scope to be a SimpleThreadScope, with the following XML context configuration:

<bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
  <property name="scopes">
    <map>
      <entry key="request">
        <bean class="org.springframework.context.support.SimpleThreadScope" />
      </entry>
    </map>
  </property>
</bean>

To define the request scope to be backed by a prototype scope implementation, I thought to change the class to be an implementation of the prototype scope. However I was not able to locate any.

Looking at the Scope Interface Javadoc, in the section All Known Implementing Classes, I see listed: AbstractRequestAttributesScope, PortletContextScope, RequestScope, ServletContextScope, SessionScope, SimpleThreadScope... nothing that looks like a prototype scope.

How can I define the request scope as prototype for integration tests?

UPDATE: I've managed to make my integration tests pass by creating my own prototype scope, which I've defined as follow, so my question now is, whether the following implementation is correct, or it has to be fixed.

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;

public class PrototypeScope implements Scope {

    private static final Log logger = LogFactory.getLog(PrototypeScope.class);

    public Object get(String name, ObjectFactory objectFactory) {
        return objectFactory.getObject();
    }

    public Object remove(String name) {
        return null;
    }

    public void registerDestructionCallback(String name, Runnable callback) {
        logger.warn("PrototypeScope does not support destruction callbacks. "
                + "Consider using a RequestScope in a Web environment.");
    }

    public Object resolveContextualObject(String key) {
        return null;
    }

    public String getConversationId() {
        return Thread.currentThread().getName();
    }

}

UPDATE 2: I am using TestNG and my Integration tests look like this:

@Test
@ContextConfiguration(locations = { "classpath:META-INF/spring/test-context.xml" })
@TransactionConfiguration(transactionManager = "transactionManager", defaultRollback = true)
public class MyIntegrationTest extends AbstractTransactionalTestNGSpringContextTests {

    @Resource
    private MyBeanThatShouldBePrototype bean;

    @Transactional
    public void testCase() {
        ...

Answer 1

In fact it's working in a different way - Spring checks if bean is a prototype, and then clones its definition and just populate new bean, so there is no backing class for holding such beans. If you want to look at the implementation please visit: org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean and you will find:

if (mbd.isPrototype()) {
    // It's a prototype -> create a new instance.
    Object prototypeInstance = null;
    try {
            beforePrototypeCreation(beanName);
            prototypeInstance = createBean(beanName, mbd, args);
    }
    finally {
        afterPrototypeCreation(beanName);
    }
    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}

If you want to use prototype scope in tests you can just manually create this bean by invoking new MyObjectThatShouldBePrototype() and then configure it as a Spring bean by using AutowireCapableBeanFactory (injected/autowired into your test):

@Autowired
AutowireCapableBeanFactory beanFactory;

public MyObjectThatShouldBePrototype getBean() {
    MyObjectThatShouldBePrototype bean = new MyObjectThatShouldBePrototype();
    beanFactory.autowireBean(bean);
    return bean;
}

Of course there are several ways to create beans - you can find then here http://www.kubrynski.com/2013/09/injecting-spring-dependencies-into-non.html