确保从非弹簧上下文加载弹簧 bean

Question

我在（jersey 2.6 类和）servlet 旁边有 spring 应用程序。

我需要从 jersey/非 spring 上下文中获取 Spring bean，

类似的question 建议在上下文的静态包装器中获取上下文

public static ApplicationContext getContext() {
    return context;
}

如何确定上下文是否已加载或不为空？

如果我不能，我应该如何等待/检查，直到它加载弹簧上下文？

如果从 jersey 上下文调用或从 调用 bean 一个简单的 HttpServlet 代码

编辑

Jersey 使用 jersey-spring3 依赖 jar 可以正常工作，所以 我的问题只是关于 Spring 控制之外的 Servlet

编辑 2

应用程序加载的 spring 不同于 @entpnerd 建议的 article

它注册一个实现WebApplicationInitializer的Servlet

public class MyWebAppInitializer implements WebApplicationInitializer {

但在 web.xml 中也配置了DispatcherServlet

DispatcherServlet 怎么只能在 Spring 加载后加载？

因为我们在它的 init 方法中添加了自动装配功能：

WebApplicationContextUtils.getRequiredWebApplicationContext(config.getServletContext())
                    .getAutowireCapableBeanFactory().autowireBean(this);

在服务请求之前添加超时是最喜欢的解决方案，还是对类加载进行调整可以解决这个问题？

编辑 3

我找到了answers 和answers 的注入，但没有发现为什么 Spring 在 Servlet 之前加载。

Answer 1

这个想法很简单，尽管实际实现可能会根据 Spring boot 和 Jersery 初始化的确切方式而有所不同。

一个想法：

Spring boot，作为一个纯粹的运行时框架，就是正确加载应用程序上下文（从问题的角度来看）。

因此，归根结底，当它被加载时，内存中的某处有一个应用程序上下文，并且可以从该应用程序上下文访问 bean。

现在，既然你说 Jersey 不是 spring/spring-boot 驱动的，那么这个应用程序上下文必须可以从 Jersey 的某种静态全局变量中访问，这很丑但应该可以工作。

所以这个想法有两个步骤：

1. 将应用程序上下文引用放置到可从 Jersey 访问的某个静态持有者。
2. 在 Jersey 组件的一些基础设施级代码中读取此值。

一种可能的实现方式

技术上第一步可以通过实现某种Spring Boot侦听器来完成，该侦听器将应用程序上下文存储在某种单例中：

enum ApplicationContextHolder {
   INSTANCE;
    private ApplicationContext ctx;
    void setApplicationContext(ApplicationContext ctx) {
        this.ctx = ctx;
    }

    ApplicationContext getCtx() {
        return this.ctx;
    }

}


// and a listener (spring boot provides many ways to register one, but the 
// implementation should be something like this):
// The main point is that its managed by spring boot, and hence and access to 
// the application context
class StartupListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {           
             ApplicationContextHolder
             .INSTANCE
             .setApplicationContext(event.getApplicationContext());
    }
}

现在第二步是：

class MyJerseyOrWhateverComponentThatWantsToAccessApplicationContext {

    public void foo() {
       ApplicationContext ctx = ApplicationContextHolder.INSTANCE.getCtx();
       ... 
       ctx.getBean(...);
    }
}

Answer 2

因此，一个可行的解决方案可能分两个阶段进行：

1. Spring bean 获取 ApplicationContext 实例并将其发送到 Spring 上下文之外的静态单例。
2. 您的独立 servlet 从静态单例中获取 ApplicationContext 实例并验证是否已加载正确的 bean。

以下面的代码为例：

SpringMetaBean.java

// @Component so that it's part of the Spring context
// Implement ApplicationContextAware so that the ApplicationContext will be loaded
// correctly
@Component
public class SpringMetaBean implements ApplicationContextAware {
  private ApplicationContext appCtx;
  public setApplicationContext(ApplicationContext appCtx) {
    this.appCtx = appCtx;
  }

  // @PostConstruct so that when loaded into the Spring context, this method will
  // automatically execute and notify ApplicationContextHolder with a reference to
  // the ApplicationContext
  @PostConstruct
  public void setup() {
    ApplicationContextHolder.set(this.appCtx);
  }
}

ApplicationContextHolder.java

public class ApplicationContextHolder {
  // ensure the reference is thread-safe because Spring and standalone Servlet will
  // probably be running on different threads.
  private final AtomicReference<ApplicationContext> appCtxContainer = new AtomicReference<>();

  public void set(ApplicationContext appCtx) {
    this.appCtxContainer.set(appCtx);
  }

  public ApplicationContext get() {
    return this.appCtxContainer.get();
  }
}

MyStandaloneServlet.java

public class MyStandaloneServlet {
  // my request handler method
  public void getResponse(HttpServletRequest rq) {
    ApplicationContext springAppCtx = ApplicationContextHolder.get();
    // if not null, we know that Spring has been loaded and we can dig into the
    // application context.
  }
}