Is it possible to activate a session scope and a conversation scope from an existing query scope?

I had more or less the same problem, but I took a different approach: I had @ConversationScoped

EntityManager

it injected into my repos, but then I needed to batch process where the ConversationContext dialog was not available and an exception was thrown when using my repository. Instead of trying to activate the ConversationContext where it was not intended to be used, I ended up implementing 2 new contexts (+ 1 interceptor):

• the first one was ThreadContext ( @ThreadScoped
  
  ), which saved everything in Map
  
  in ThreadLocal
  
  (which is good for handling async) + 1 interceptor ( @ThreadContextual
  
  ) method to be used in my async / batch methods to activate this context for the duration of the call.
• the second one was a little more complex: it was some kind of dynamic context that delegated the first active context in this order: ThreadContext, (NonTransient) ConversationContext, (NonTransient) ViewContext ( @ViewScoped
  
  from JSF 2.2), RequestContext. I named this context UnitOfWorkContext with the appropriate annotation @UnitOfWorkScoped
  
  . I annotated (multiple) beans that were meant to live in this context (for me it was just a method @Produces
  
  for mine EntityManager
  
  ).

It would seem difficult to implement all this, but it is not, the code was rather small. I will paste my code in 2-3 days if needed, as I don't have access to it at the moment.

UPDATE: Here is the code for the second context:

The following interface is used in addition to Context.isActive (). Sometimes, even if the context is active it doesn't mean that I want to use it, see below example.

public interface DynamicContextActivation {

    boolean isActive(Context context);
}

      

        
        
        
      

    

The following annotation should be placed in your new area

@Retention(RUNTIME)
@Target(ANNOTATION_TYPE)
public @interface DynamicScope {

    class DefaultActivation implements DynamicContextActivation {

        public boolean isActive(Context context) {
            return true;
        }
    }

    Class<? extends Annotation>[] value();

    Class<? extends DynamicContextActivation> activation() default DefaultActivation.class;
}

      

        
        
        
      

    

Implementing dynamic context

public class DynamicContext implements AlterableContext {

    private final BeanManager beanManager;
    private final DynamicContextActivation activation;
    private final Class<? extends Annotation> scope;
    private final Class<? extends Annotation>[] scopes;

    public DynamicContext(BeanManager beanManager, DynamicContextActivation activation, Class<? extends Annotation> scope, Class<? extends Annotation>[] scopes) {
        this.beanManager = beanManager;
        this.activation = activation;
        this.scope = scope;
        this.scopes = scopes;
    }

    public void destroy(Contextual<?> contextual) {
        Context context = getContext();
        if (context instanceof AlterableContext) {
            ((AlterableContext) context).destroy(contextual);
        }
    }

    public <T> T get(Contextual<T> contextual) {
        return getContext().get(contextual);
    }

    public <T> T get(Contextual<T> contextual, CreationalContext<T> creationalContext) {
        return getContext().get(contextual, creationalContext);
    }

    // Find the first active context
    private Context getContext() {
        for (Class<? extends Annotation> scope : this.scopes) {
            try {
                Context context = this.beanManager.getContext(scope);
                if (context.isActive() && this.activation.isActive(context)) {
                    return context;
                }
            } catch (ContextNotActiveException exception) {
                continue;
            }
        }
        return null;
    }

    public Class<? extends Annotation> getScope() {
        return this.scope;
    }

    public boolean isActive() {
        return getContext() != null;
    }
}

      

        
        
        
      

    

An extension that automatically registers dynamic context (add it to /META-INF/services/javax.enterprise.inject.spi.Extension

)

public class DynamicContextExtension implements Extension {

    private final Set<Class<? extends Annotation>> scopes = new HashSet<>();

    public void processBean(@Observes ProcessBean<?> bean) {
        Class<? extends Annotation> scope = bean.getBean().getScope();
        if (scope.isAnnotationPresent(DynamicScope.class)) {
            this.scopes.add(scope);
        }
    }

    public void afterBeanDiscovery(@Observes AfterBeanDiscovery afterBeanDiscovery, BeanManager beanManager) {
        for (Class<? extends Annotation> scope : scopes) {
            DynamicScope dynamicScope = scope.getAnnotation(DynamicScope.class);
            try {
                // TODO use a managed DynamicContextActivation instead of instantiating it here
                DynamicContextActivation activation = dynamicScope.activation().newInstance();
                Context context = new DynamicContext(beanManager, activation, scope, dynamicScope.value());
                afterBeanDiscovery.addContext(context);
            } catch (InstantiationException | IllegalAccessException exception) {
                afterBeanDiscovery.addDefinitionError(exception);
            }
        }
    }
}

      

        
        
        
      

    

This allows delegates for ThreadScoped, (LongRunning) ConversationScoped, (NonTransient) ViewScoped, RequestScoped:

@Retention(RUNTIME)
@NormalScope(passivating = true) // must be true if any of the delegate context is passivation-capable
@DynamicScope(value = {ThreadScoped.class, ConversationScoped.class, ViewScoped.class, RequestScoped.class}, activation = UnitOfWorkActivation.class)
public @interface UnitOfWorkScoped {

    class UnitOfWorkActivation implements DynamicContextActivation {

        public boolean isActive(Context context) {
            if (context.getScope().equals(ConversationScoped.class)) {
                // I only want long-running conversations here because in JSF there
                // is always a transient conversation per request and it could take
                // precedence over all other scopes that come after it
                return !CDI.current().select(Conversation.class).get().isTransient();
            }
            if (context.getScope().equals(ViewScoped.class)) {
                // Storing things in view scope when the view is transient gives warnings
                return !FacesContext.getCurrentInstance().getViewRoot().isTransient();
            }
            return true;
        }
    }
}

      

        
        
        
      

    

An EntityManager

producer that gives @UnitOfWorkScoped

EntityManager

s:

@Stateful // it could work without @Stateful (but Serializable) but I haven't tested enough
@UnitOfWorkScoped
public class EntityManagerProducer {

    @PersistenceContext(type = EXTENDED)
    private EntityManager entityManager;

    @Produces
    @UnitOfWorkScoped
    @TransactionAttribute(NOT_SUPPORTED)
    public EntityManager entityManager() {
        return entityManager;
    }
}

      

        
        
        
      

    

There is certainly room for improvement, so feel free to give your feedback.

UPDATE 2: It would be nice to replace DynamicContextActivation with EL expressions

@Retention(RUNTIME)
@NormalScope(passivating = true)
@DynamicScope({
    @Scope(scope = ThreadScoped.class),
    @Scope(scope = ConversationScoped.class, ifExpression = "#{not javax.enterprise.context.conversation.transient}"),
    @Scope(scope = ViewScoped.class, ifExpression = "#{not facesContext.viewRoot.transient}"),
    @Scope(scope = RequestScoped.class)
})
public @interface UnitOfWorkScoped {}