获取Spring应用程序上下文

java spring configuration

296435 观看

14回复

11400 作者的声誉

有没有办法在Spring应用程序中静态/全局请求ApplicationContext的副本?

假设主类启动并初始化应用程序上下文,是否需要将它通过调用堆栈传递给任何需要它的类,或者有没有办法让类询问先前创建的上下文?(我认为必须是单身?)

作者: Joe Skora 的来源 发布者: 2008 年 9 月 24 日

回应 (14)


37

39236 作者的声誉

这是一个很好的方式(不是我的,原始参考在这里:http//sujitpal.blogspot.com/2007/03/accessing-spring-beans-from-legacy-code.html

我用过这种方法,它运行正常。基本上它是一个简单的bean,它包含对应用程序上下文的(静态)引用。通过在spring配置中引用它,它已初始化。

看看原始参考,非常清楚。

作者: Steve B. 发布者: 24.09.2008 07:33

4

342517 作者的声誉

看看ContextSingletonBeanFactoryLocator。它提供静态访问器来获取Spring的上下文,假设它们已经以某种方式注册。

它不漂亮,比你想要的更复杂,但它有效。

作者: skaffman 发布者: 24.09.2008 07:36

165

28145 作者的声誉

决定

如果需要访问容器的对象是容器中的bean,则只需实现BeanFactoryAwareApplicationContextAware接口。

如果容器外的对象需要访问容器,我已经为弹簧容器使用了标准的GoF单例模式。这样,您的应用程序中只有一个单例,其余的都是容器中的单例bean。

作者: Don Kirkby 发布者: 24.09.2008 09:08

11

3978 作者的声誉

在您实施任何其他建议之前,请问自己这些问题......

  • 为什么我要尝试获取ApplicationContext?
  • 我是否有效地使用ApplicationContext作为服务定位器?
  • 我可以完全避免访问ApplicationContext吗?

这些问题的答案在某些类型的应用程序(例如Web应用程序)中比在其他应用程序中更容易,但无论如何都值得提出。

访问ApplicationContext确实违反了整个依赖注入原则,但有时你没有太多选择。

作者: belugabob 发布者: 27.09.2008 08:28

18

2369 作者的声誉

我相信你可以使用SingletonBeanFactoryLocator。beanRefFactory.xml文件将保存实际的applicationContext,它将是这样的:

<bean id="mainContext" class="org.springframework.context.support.ClassPathXmlApplicationContext">
     <constructor-arg>
        <list>
            <value>../applicationContext.xml</value>
        </list>
     </constructor-arg>
 </bean>

从wheverver获取来自applicationcontext的bean的代码将是这样的:

BeanFactoryLocator bfl = SingletonBeanFactoryLocator.getInstance();
BeanFactoryReference bf = bfl.useBeanFactory("mainContext");
SomeService someService = (SomeService) bf.getFactory().getBean("someService");

Spring团队不鼓励使用这个类和yadayada,但它在我使用它的地方很适合我。

作者: stian 发布者: 27.09.2008 09:43

6

13548 作者的声誉

如果您使用Web应用程序,还可以通过使用servletfilter和ThreadLocal来访问应用程序上下文而不使用单例。在过滤器中,您可以使用WebApplicationContextUtils访问应用程序上下文,并在TheadLocal中存储应用程序上下文或所需的bean。

警告:如果您忘记取消设置ThreadLocal,则在尝试取消部署应用程序时会遇到令人讨厌的问题!因此,您应该设置它并立即启动尝试以取消最终部分中的ThreadLocal。

当然,这仍然使用单例:ThreadLocal。但实际的bean不再需要了。甚至可以是请求范围的,如果在具有EAR中的库的应用程序中有多个WAR,则此解决方案也可以工作。不过,您可能会认为ThreadLocal的使用与使用普通单例一样糟糕。;-)

也许Spring已经提供了类似的解决方案?我找不到一个,但我不确定。

作者: Hans-Peter Störr 发布者: 30.03.2009 02:54

113

6897 作者的声誉

您可以实现ApplicationContextAware或只使用@Autowired

public class SpringBean {
  @Autowired
  private ApplicationContext appContext;
}

SpringBeanApplicationContext注入,在其中实例化此bean。例如,如果您的Web应用程序具有非常标准的上下文层次结构:

main application context <- (child) MVC context

并且SpringBean在主要上下文中声明,它将注入主要上下文; 否则,如果它在MVC上下文中声明,它将注入MVC​​上下文。

作者: omnomnom 发布者: 14.05.2012 11:31

3

2387 作者的声誉

请注意,通过将当前状态ApplicationContextApplicationContext自身存储在静态变量中(例如使用单例模式),如果使用Spring-test,则会使测试不稳定且不可预测。这是因为Spring-test在同一个JVM中缓存并重用应用程序上下文。例如:

  1. 测试运行并注释@ContextConfiguration({"classpath:foo.xml"})
  2. 测试B运行并注释 @ContextConfiguration({"classpath:foo.xml", "classpath:bar.xml})
  3. 测试C运行并注释 @ContextConfiguration({"classpath:foo.xml"})

当测试A运行时,ApplicationContext会创建一个,并且任何实现ApplicationContextAware或自动装配的bean都ApplicationContext可以写入静态变量。

当测试B运行时,同样的事情发生,静态变量现在指向测试B ApplicationContext

当测试C运行时,不会创建任何bean,因为测试A 的TestContext(和此处ApplicationContext)被重用。现在你有一个静态变量指向另一个,而ApplicationContext不是当前持有测试bean的那个。

作者: gogstad 发布者: 20.02.2014 11:52

0

9048 作者的声誉

请注意; 下面的代码将创建新的应用程序上下文,而不是使用已经加载的上下文。

private static final ApplicationContext context = 
               new ClassPathXmlApplicationContext("beans.xml");

还要注意,它beans.xml应该是src/main/resources战争中手段的一部分,它是WEB_INF/classes真实应用程序将通过applicationContext.xml提及加载的部分Web.xml

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>META-INF/spring/applicationContext.xml</param-value>
</context-param>

这是很难applicationContext.xml的路径ClassPathXmlApplicationContext构造。ClassPathXmlApplicationContext("META-INF/spring/applicationContext.xml")将无法找到该文件。

因此,最好使用注释来使用现有的applicationContext。

@Component
public class OperatorRequestHandlerFactory {

    public static ApplicationContext context;

    @Autowired
    public void setApplicationContext(ApplicationContext applicationContext) {
        context = applicationContext;
    }
}
作者: Kanagavelu Sugumar 发布者: 05.12.2016 07:44

5

181 作者的声誉

SpringApplicationContext.java

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * Wrapper to always return a reference to the Spring Application 
Context from
 * within non-Spring enabled beans. Unlike Spring MVC's 
WebApplicationContextUtils
 * we do not need a reference to the Servlet context for this. All we need is
 * for this bean to be initialized during application startup.
 */
public class SpringApplicationContext implements 
ApplicationContextAware {

  private static ApplicationContext CONTEXT;

  /**
   * This method is called from within the ApplicationContext once it is 
   * done starting up, it will stick a reference to itself into this bean.
  * @param context a reference to the ApplicationContext.
  */
  public void setApplicationContext(ApplicationContext context) throws BeansException {
    CONTEXT = context;
  }

  /**
   * This is about the same as context.getBean("beanName"), except it has its
   * own static handle to the Spring context, so calling this method statically
   * will give access to the beans by name in the Spring application context.
   * As in the context.getBean("beanName") call, the caller must cast to the
   * appropriate target class. If the bean does not exist, then a Runtime error
   * will be thrown.
   * @param beanName the name of the bean to get.
   * @return an Object reference to the named bean.
   */
  public static Object getBean(String beanName) {
    return CONTEXT.getBean(beanName);
  }
}

资料来源:http//sujitpal.blogspot.de/2007/03/accessing-spring-beans-from-legacy-code.html

作者: Vanessa Schissato 发布者: 21.04.2017 08:16

0

2558 作者的声誉

我知道这个问题已得到解答,但我想分享我用来检索Spring Context的Kotlin代码。

我不是专家,因此我对评论家,评论和建议持开放态度:

https://gist.github.com/edpichler/9e22309a86b97dbd4cb1ffe011aa69dd

package com.company.web.spring

import com.company.jpa.spring.MyBusinessAppConfig
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationContext
import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Import
import org.springframework.stereotype.Component
import org.springframework.web.context.ContextLoader
import org.springframework.web.context.WebApplicationContext
import org.springframework.web.context.support.WebApplicationContextUtils
import javax.servlet.http.HttpServlet

@Configuration
@Import(value = [MyBusinessAppConfig::class])
@ComponentScan(basePackageClasses  = [SpringUtils::class])
open class WebAppConfig {
}

/**
 *
 * Singleton object to create (only if necessary), return and reuse a Spring Application Context.
 *
 * When you instantiates a class by yourself, spring context does not autowire its properties, but you can wire by yourself.
 * This class helps to find a context or create a new one, so you can wire properties inside objects that are not
 * created by Spring (e.g.: Servlets, usually created by the web server).
 *
 * Sometimes a SpringContext is created inside jUnit tests, or in the application server, or just manually. Independent
 * where it was created, I recommend you to configure your spring configuration to scan this SpringUtils package, so the 'springAppContext'
 * property will be used and autowired at the SpringUtils object the start of your spring context, and you will have just one instance of spring context public available.
 *
 *Ps: Even if your spring configuration doesn't include the SpringUtils @Component, it will works tto, but it will create a second Spring Context o your application.
 */
@Component
object SpringUtils {

        var springAppContext: ApplicationContext? = null
    @Autowired
    set(value) {
        field = value
    }



    /**
     * Tries to find and reuse the Application Spring Context. If none found, creates one and save for reuse.
     * @return returns a Spring Context.
     */
    fun ctx(): ApplicationContext {
        if (springAppContext!= null) {
            println("achou")
            return springAppContext as ApplicationContext;
        }

        //springcontext not autowired. Trying to find on the thread...
        val webContext = ContextLoader.getCurrentWebApplicationContext()
        if (webContext != null) {
            springAppContext = webContext;
            println("achou no servidor")
            return springAppContext as WebApplicationContext;
        }

        println("nao achou, vai criar")
        //None spring context found. Start creating a new one...
        val applicationContext = AnnotationConfigApplicationContext ( WebAppConfig::class.java )

        //saving the context for reusing next time
        springAppContext = applicationContext
        return applicationContext
    }

    /**
     * @return a Spring context of the WebApplication.
     * @param createNewWhenNotFound when true, creates a new Spring Context to return, when no one found in the ServletContext.
     * @param httpServlet the @WebServlet.
     */
    fun ctx(httpServlet: HttpServlet, createNewWhenNotFound: Boolean): ApplicationContext {
        try {
            val webContext = WebApplicationContextUtils.findWebApplicationContext(httpServlet.servletContext)
            if (webContext != null) {
                return webContext
            }
            if (createNewWhenNotFound) {
                //creates a new one
                return ctx()
            } else {
                throw NullPointerException("Cannot found a Spring Application Context.");
            }
        }catch (er: IllegalStateException){
            if (createNewWhenNotFound) {
                //creates a new one
                return ctx()
            }
            throw er;
        }
    }
}

现在,spring上下文是公开可用的,能够独立于上下文(junit测试,bean,手动实例化类)调用相同的方法,就像在这个Java Servlet上一样:

@WebServlet(name = "MyWebHook", value = "/WebHook")
public class MyWebServlet extends HttpServlet {


    private MyBean byBean
            = SpringUtils.INSTANCE.ctx(this, true).getBean(MyBean.class);


    public MyWebServlet() {

    }
}
作者: John John Pichler 发布者: 28.06.2018 12:20

1

3147 作者的声誉

在Spring应用程序中有很多方法可以获取应用程序上下文。这些是下面给出的:

  1. 通过ApplicationContextAware

    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    
    public class AppContextProvider implements ApplicationContextAware {
    
    private ApplicationContext applicationContext;
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
    }
    

在这里,setApplicationContext(ApplicationContext applicationContext)您将获得applicationContext

ApplicationContextAware

希望被通知其运行的ApplicationContext的任何对象实现的接口。例如,当对象需要访问一组协作bean时,实现此接口是有意义的。

  1. 通过Autowired

    @Autowired
    private ApplicationContext applicationContext;
    

Here @Autowired关键字将提供applicationContext。自动装配有一些问题。它会在单元测试期间产生问题。

谢谢 :)

作者: Md. Sajedul Karim 发布者: 17.10.2018 08:52

1

10972 作者的声誉

不确定这将有多大用处,但您也可以在初始化应用程序时获取上下文。这是最快的,你可以获得上下文,甚至在之前@Autowire

@SpringBootApplication
public class Application extends SpringBootServletInitializer {
    private static ApplicationContext context;

    // I believe this only runs during an embedded Tomcat with `mvn spring-boot:run`. 
    // I don't believe it runs when deploying to Tomcat on AWS.
    public static void main(String[] args) {
        context = SpringApplication.run(Application.class, args);
        DataSource dataSource = context.getBean(javax.sql.DataSource.class);
        Logger.getLogger("Application").info("DATASOURCE = " + dataSource);
作者: Chloe 发布者: 20.12.2018 08:48

0

72 作者的声誉

在Spring bean中自动装配如下:@Autowired private ApplicationContext appContext;

你将是applicationcontext对象。

作者: SandeepJain 发布者: 06.03.2019 05:14
32x32