Frühling erhält aktuellen ApplicationContext

Ich verwende Spring MVC für meine Webanwendung. Meine Bohnen sind in der spring-servlet.xmlDatei " " geschrieben

Jetzt habe ich eine Klasse MyClassund möchte mit Spring Bean auf diese Klasse zugreifen

In der habe spring-servlet.xmlich folgendes geschrieben

<bean id="myClass" class="com.lynas.MyClass" />

Jetzt muss ich mit darauf zugreifen ApplicationContext

ApplicationContext context = ??

Damit ich es tun kann

MyClass myClass = (MyClass) context.getBean("myClass");

Wie macht man das??

Einfach injizieren ..

@Autowired
private ApplicationContext appContext;

oder implementieren Sie diese Schnittstelle: ApplicationContextAware

Ich denke, dieser Link zeigt den besten Weg, um Anwendungskontext überall abzurufen, selbst in der Nicht-Bean-Klasse. Ich finde es sehr nützlich. Hoffe es ist das gleiche für dich. Das Folgende ist der abstrakte Code davon

Erstellen Sie eine neue Klasse ApplicationContextProvider.java

package com.java2novice.spring;

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

public class ApplicationContextProvider implements ApplicationContextAware{

    private static ApplicationContext context;

    public static ApplicationContext getApplicationContext() {
        return context;
    }

    @Override
    public void setApplicationContext(ApplicationContext ac)
            throws BeansException {
        context = ac;
    }
}

Fügen Sie einen Eintrag in application-context.xml hinzu

<bean id="applicationContextProvider"
                        class="com.java2novice.spring.ApplicationContextProvider"/>

Im Fall von Anmerkungen (anstelle von application-context.xml)

@Component
public class ApplicationContextProvider implements ApplicationContextAware{
...
}

Holen Sie sich den Kontext so

TestBean tb = ApplicationContextProvider.getApplicationContext().getBean("testBean", TestBean.class);

Prost!!

Falls Sie über einen HttpServlet auf den Kontext zugreifen müssen, der selbst nicht von Spring instanziiert wird (und daher weder @Autowire noch ApplicationContextAware funktionieren) ...

WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(getServletContext());

oder

SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this);

Überlegen Sie sich einige der anderen Antworten, bevor Sie dies tun:

new ClassPathXmlApplicationContext("..."); // are you sure?

... da dies Ihnen nicht den aktuellen Kontext gibt, sondern eine weitere Instanz davon für Sie erstellt. Dies bedeutet, dass 1) ein erheblicher Speicherbereich und 2) Beans nicht zwischen diesen beiden Anwendungskontexten geteilt werden.

Wenn Sie eine Klasse implementieren, die nicht von Spring instanziiert wurde, wie z. B. einen JsonDeserializer, können Sie Folgendes verwenden:

WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
MyClass myBean = context.getBean(MyClass.class);

Fügen Sie dies Ihrem Code hinzu

@Autowired
private ApplicationContext _applicationContext;

//Add below line in your calling method
MyClass class = (MyClass) _applicationContext.getBean("myClass");

// Or you can simply use this, put the below code in your controller data member declaration part.
@Autowired
private MyClass myClass;

Dadurch wird myClass einfach in Ihre Anwendung eingefügt

basierend auf Viveks Antwort, aber ich denke, das Folgende wäre besser:

@Component("applicationContextProvider")
public class ApplicationContextProvider implements ApplicationContextAware {

    private static class AplicationContextHolder{

        private static final InnerContextResource CONTEXT_PROV = new InnerContextResource();

        private AplicationContextHolder() {
            super();
        }
    }

    private static final class InnerContextResource {

        private ApplicationContext context;

        private InnerContextResource(){
            super();
        }

        private void setContext(ApplicationContext context){
            this.context = context;
        }
    }

    public static ApplicationContext getApplicationContext() {
        return AplicationContextHolder.CONTEXT_PROV.context;
    }

    @Override
    public void setApplicationContext(ApplicationContext ac) {
        AplicationContextHolder.CONTEXT_PROV.setContext(ac);
    }
}

Das Schreiben von einer Instanzmethode in ein statisches Feld ist eine schlechte Praxis und gefährlich, wenn mehrere Instanzen manipuliert werden.

Es gibt viele Möglichkeiten, den Anwendungskontext in der Spring-Anwendung abzurufen. Diese sind unten angegeben:

1. Über 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;
   }
   }

Hier erhalten setApplicationContext(ApplicationContext applicationContext)Sie den applicationContext

2. Über Autowired :

   @Autowired
   private ApplicationContext applicationContext;

Hier @Autowiredliefert das Schlüsselwort den applicationContext.

Für weitere Informationen besuchen Sie diesen Thread

Vielen Dank :)

Eine andere Möglichkeit besteht darin, applicationContext über das Servlet einzufügen.

Dies ist ein Beispiel für das Einfügen von Abhängigkeiten bei Verwendung von Spring-Webdiensten.

<servlet>
        <servlet-name>my-soap-ws</servlet-name>
        <servlet-class>org.springframework.ws.transport.http.MessageDispatcherServlet</servlet-class>
        <init-param>
            <param-name>transformWsdlLocations</param-name>
            <param-value>false</param-value>
        </init-param>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:my-applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>5</load-on-startup>

</servlet>

Alternativ können Sie den Anwendungskontext wie unten gezeigt in Ihre web.xml einfügen

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
        /WEB-INF/classes/my-another-applicationContext.xml
        classpath:my-second-context.xml
    </param-value>
</context-param>

Grundsätzlich versuchen Sie, dem Servlet mitzuteilen, dass es nach Beans suchen soll, die in diesen Kontextdateien definiert sind.

Schritt 1 : Injizieren Sie den folgenden Code in die Klasse

@Autowired
private ApplicationContext _applicationContext;

Schritt 2 : Schreiben Sie Getter & Setter

Schritt 3 : Definieren Sie autowire = "byType" in der XML-Datei, in der die Bean definiert ist

Selbst nach dem Hinzufügen von @Autowire, wenn Ihre Klasse kein RestController oder keine Konfigurationsklasse ist, wurde das applicationContext-Objekt als null angezeigt. Versucht, eine neue Klasse mit unten zu erstellen und es funktioniert gut:

@Component
public class SpringContext implements ApplicationContextAware{

   private static ApplicationContext applicationContext;

   @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws 
     BeansException {
    this.applicationContext=applicationContext;
   }
 }

Sie können dann eine Getter-Methode in derselben Klasse implementieren, die Ihren Anforderungen entspricht, z. B. die Referenz für die implementierte Klasse abrufen durch:

    applicationContext.getBean(String serviceName,Interface.Class)

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-servlet.xml");

Dann können Sie die Bohne abrufen:

MyClass myClass = (MyClass) context.getBean("myClass");

Referenz: springbyexample.org