我或多或少遇到了同样的问题，但采取了不同的方法：我@ConversationScoped EntityManager在我的存储库中注入了一个，但随后我需要在没有 ConversationContext 可用的情况下进行一些批处理，并且在使用我的存储库时出现异常。我没有尝试在不打算使用它的地方激活 ConversationContext，而是结束了实现 2 个新上下文（+ 1 个拦截器）：
- 第一个是 ThreadContext (
@ThreadScoped)，它将所有内容存储在 aMap中ThreadLocal（这对于异步处理来说很好）+ 1 个方法拦截器 ( @ThreadContextual)，用于在我的异步/批处理方法上用于在调用时激活此上下文。
- 第二个稍微复杂一点：它是某种动态上下文，按以下顺序委托给第一个活动上下文：ThreadContext、(NonTransient)ConversationContext、(NonTransient)ViewContext（
@ViewScoped来自 JSF 2.2）、RequestContext。我用相应的@UnitOfWorkScoped注释调用了这个上下文 UnitOfWorkContext。我注释了需要在该上下文中生存的（少数）bean（对我来说，这只是@Produces我的方法EntityManager）。
实现所有这些似乎很困难，但事实并非如此，代码非常小。如果需要，我将在 2-3 天内粘贴我的代码，因为我暂时无法访问它。
更新：这是第二个上下文的代码：
以下接口用作 Context.isActive() 的补充。有时，即使上下文处于活动状态，也不意味着我想使用它，请参见下面的示例。
public interface DynamicContextActivation {
boolean isActive(Context context);
}
以下注释应放在您的新范围内
@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;
}
动态上下文的实现
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;
}
}
自动注册动态上下文的扩展（添加到/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);
}
}
}
}
这将委托范围限定为 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;
}
}
}
EntityManager给出@UnitOfWorkScoped EntityManagers的生产者：
@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;
}
}
肯定有改进的余地，所以不要犹豫，提供您的反馈。
更新 2：用 EL 表达式替换 DynamicContextActivation 会很好
@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 {}