Obtenir ServletContext dans l'application

Pourriez-vous expliquer comment je peux obtenir le ServletContext exemple, dans mon Application's sous-classe? Est-il possible? J'ai essayé de faire comme dans l'extrait suivant, mais il ne semble pas fonctionner - le ctx n'est pas définie:

import javax.ws.rs.core.Application;
import javax.ws.rs.core.Context;

//...

@ApplicationPath("/")
public class MainApplication extends Application {

    @Context ServletContext ctx;

    @Override
    public Set<Class<?>> getClasses() {     
        Set<Class<?>> classes = new HashSet<Class<?>>();
//...
        return classes;
    }
}

web.xml:

<web-app ...>
 <context-param>
  <param-name>environment</param-name>
  <param-value>development</param-value>
 </context-param>
 <filter>
  <filter-name>jersey-filter</filter-name>
  <filter-class>org.glassfish.jersey.servlet.ServletContainer</filter-class>
   <init-param>
   <param-name>javax.ws.rs.Application</param-name>
   <param-value>my.MainApplication</param-value>
  </init-param>
</filter>
...
</web-app>

Le problème est que j'ai besoin d'obtenir des paramètres de contexte. Si il y a une autre façon, je serais reconnaissant si quelqu'un a donné une indication.

Je comprends que Context annotation peuvent ne pas être adaptés pour cela. En fait, je n'ai pas besoin ServletContext lui-même. Si seulement je pouvais les mettre en contexte params de web.xml, je serais parfaitement heureux.

Voici un exemple de ce que j'ai vraiment besoin de:

import java.util.HashSet;
import java.util.Set;

import javax.servlet.ServletContext;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.Context;

import org.glassfish.hk2.utilities.binding.AbstractBinder;

public class MainApplication extends Application {

    @Context ServletContext ctx;

    @Override
    public Set<Object> getSingletons() {
        Set<Object> set = new HashSet<Object>();
        final String environment = ctx.getInitParameter("environment");
        //final String environment = ... get context parameter from web xml
        set.add(new AbstractBinder() {

            @Override
            protected void configure() {
                bind(new BaseDataAccess(environment)).to(DataAccess.class);             
            }
        });
        //...
        return set;
    }
}

Grâce.

source d'informationauteur Industrious

Depuis Jersey 2.5, ServletContext peut être injecté directement dans le constructeur:
https://java.net/jira/browse/JERSEY-2184

public class MyApplication extends ResourceConfig {
    public MyApplication(@Context ServletContext servletContext) {
       //TODO
    }
}

@Context peut être mis à disposition sur ResoureConfig par injection comme un paramètre de constructeur à l'aide de @Context. Un autre moyen d'y accéder est par l'intermédiaire d'un gestionnaire d'événement.

Essayer le code ci-dessous.

@ApplicationPath("...")
public class MyApplication extends ResourceConfig {
    public MyApplication() {
        register(StartupHandler.class);
    }

    private static class StartupHandler extends  AbstractContainerLifecycleListener {
        @Context
        ServletContext ctx;

        @Override
        public void onStartup(Container container) {
            //You can put code here for initialization. 
        }
    }
//...

1

Injection se produit lorsque vous entrez méthode de service. Vérifiez si c'est un problème.
1

Il est intéressant exposé de la documentation pour le Jersey version 1.18 pour la classe
com.soleil.jersey.le spi.le conteneur.servlet.ServletContainer

La servlet ou un filtre peut être configuré pour avoir une initialisation
le paramètre "com.soleil.jersey.config.de la propriété.resourceConfigClass" ou
"javax.ws.rs.L'Application" et dont la valeur est un nom pleinement qualifié de
une classe qui implémente ResourceConfig ou de l'Application. Si le béton
la classe a un constructeur qui prend un seul paramètre de type de la Carte
puis la classe est instanciée avec ce constructeur et une instance
de la Carte qui contient tous les paramètres d'initialisation est passé comme
le paramètre.

Si ma compréhension est correcte, le constructeur suivant doit être invoced avec "une instance de la Carte qui contient tous les paramètres d'initialisation"
```
public class ExampleApplication extends Application {
    public ExampleApplication(Map initParams) {
    }
    ...
}
```
Ici est approprié une partie de web.xml:
```
<servlet>
  <servlet-name>Jersey Web Application</servlet-name>
  <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
    <init-param>
       <param-name>javax.ws.rs.Application</param-name>
       <param-value>experiment.service.ExampleApplication</param-value>
    </init-param>
</servlet>
```
Mais de toute façon il a échoué pour moi avec le message suivant:

SÉVÈRE: dépendance Manquante pour le constructeur public
expérience.service.ExampleApplication(java.util.Carte) au paramètre
l'index 0

Et pour la version actuelle de Jersey (2.5.1) il n'y a aucune déclaration de ce type documentstion:
https://jersey.java.net/apidocs/latest/jersey/org/glassfish/jersey/servlet/ServletContainer.html

Vous pouvez utiliser le ApplicationEventListener interface pour obtenir les ServletContext. Après l'initialisation est terminée, vous pouvez "attraper" un ApplicationEvent et d'utiliser l'injection de ServletContext de travailler avec.

Fonctionne très bien avec: org.glassfish.jersey : 2.12

Pour les versions supplémentaires, veuillez utiliser les commentaires - je ne sais pas, sry.

Maillot Docs - 20.1.2. Les Écouteurs D'Événement

Votre MainApplication:

@ApplicationPath("/")
public class MainApplication extends Application {
    @Override
    public Set<Class<?>> getClasses() {     
        Set<Class<?>> set = new HashSet<Class<?>>();
        set.add(MainApplicationListener.class);
        return classes;
    }
}

... ou alternative MainResourceConfig (je préfère utiliser celui-ci):

public class MainResourceConfig extends ResourceConfig {
    public MainResourceConfig() {
        register(MainApplicationListener.class);
    }
}

Et la ApplicationEventListener:

public class MainApplicationListener implements ApplicationEventListener {

    @Context
    private ServletContext ctx; //not null anymore :)

    @Override
    public void onEvent(ApplicationEvent event) {
        switch (event.getType()) {
            case INITIALIZATION_FINISHED:
            //do whatever you want with your ServletContext ctx
            break;
    }

    @Override
    public RequestEventListener onRequest(RequestEvent requestEvent) {
        return null;
    }

}

Ne pas utiliser @Context dans votre Application mais dans une classe de Ressource.

@Path("/foos")
public class FooResource {

  @Context
  ServletContext ctx;

  @GET
  public Response getFoos() {
    return Response.ok().build();
  }
}

Vous devez vous connecter pour publier un commentaire.