Injection de dépendance avec Jersey 2.0

juste pour répondre à un commentaire dans l'accepte réponse.

"Ce qui ne se lient faire? Que faire si j'ai une interface et une implémentation?"

Il lit simplement bind( implementation ).to( contract ) . Vous pouvez alternative chaîne .in( scope ) . Champ d'application par défaut de PerLookup . Donc, si vous voulez un singleton, vous pouvez

bind( implementation ).to( contract ).in( Singleton.class );

il y a aussi un RequestScoped disponible

aussi, à la place de bind(Class).to(Class) , vous pouvez aussi bind(Instance).to(Class) , qui sera automatiquement être un singleton.

---

ajout à la réponse acceptée

pour ceux qui essaient de comprendre comment enregistrer votre implémentation AbstractBinder dans votre site web.xml (c'est-à-dire que vous n'utilisez pas un ResourceConfig ), il semble que le binder ne sera pas découvert par la numérisation du paquet, c'est-à-dire

<servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
<init-param>
    <param-name>jersey.config.server.provider.packages</param-name>
    <param-value>
        your.packages.to.scan
    </param-value>
</init-param>

ou ce soit

<init-param>
    <param-name>jersey.config.server.provider.classnames</param-name>
    <param-value>
        com.foo.YourBinderImpl
    </param-value>
</init-param>

pour le faire fonctionner, j'ai dû mettre en place un Feature :

import javax.ws.rs.core.Feature;
import javax.ws.rs.core.FeatureContext;
import javax.ws.rs.ext.Provider;

@Provider
public class Hk2Feature implements Feature {

    @Override
    public boolean configure(FeatureContext context) {
        context.register(new AppBinder());
        return true;
    }
}

l'annotation @Provider doit permettre au Feature d'être capté par le balayage du paquet. Ou sans balayage de paquet, vous pouvez enregistrer explicitement le Feature dans le web.xml

<servlet>
    <servlet-name>Jersey Web Application</servlet-name>
    <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
    <init-param>
        <param-name>jersey.config.server.provider.classnames</param-name>
        <param-value>
            com.foo.Hk2Feature
        </param-value>
    </init-param>
    ...
    <load-on-startup>1</load-on-startup>
</servlet>

---

Voir Aussi:

• Personnalisée des paramètres de Méthode d'Injection avec le Maillot de
• comment injecter un objet dans le contexte de jersey request?
• comment configurer correctement un EntityManager dans une application jersey / hk2?
• demande Scoped Injection into Singletons

et pour des informations générales de la documentation De Jersey

• Personnalisée d'Injection et de Gestion du Cycle de vie

---

mise à jour

usines

outre la reliure de base dans la réponse acceptée, vous avez aussi des usines, où vous pouvez avoir une logique de création plus complexe, et aussi avoir accès à des informations de contexte de demande. Pour exemple

public class MyServiceFactory implements Factory<MyService> {
    @Context
    private HttpHeaders headers;

    @Override
    public MyService provide() {
        return new MyService(headers.getHeaderString("X-Header"));
    }

    @Override
    public void dispose(MyService service) { /* noop */ }
}

register(new AbstractBinder() {
    @Override
    public void configure() {
        bindFactory(MyServiceFactory.class).to(MyService.class)
                .in(RequestScoped.class);
    }
});

ensuite, vous pouvez injecter MyService dans votre classe de ressources.

la réponse choisie date d'il y a longtemps. Il n'est pas pratique de déclarer chaque reliure dans un classeur hk2 personnalisé. J'utilise Tomcat et j'ai juste dû ajouter une dépendance. Même s'il a été conçu pour les poissons en verre, il s'adapte parfaitement dans d'autres conteneurs.

   <dependency>
        <groupId>org.glassfish.jersey.containers.glassfish</groupId>
        <artifactId>jersey-gf-cdi</artifactId>
        <version>${jersey.version}</version>
    </dependency>

assurez-vous que votre conteneur est correctement configuré ( voir la documentation ).

en retard mais j'espère que cela aidera quelqu'un.

j'ai mon JAX RS défini comme ceci:

@Path("/examplepath")
@RequestScoped //this make the diference
public class ExampleResource {

puis, dans mon code enfin je peux injecter:

@Inject
SomeManagedBean bean;

dans mon cas, le SomeManagedBean est un haricot dopé.

Espérons que cette aide à la personne.

Oracle recommande d'ajouter l'annotation @Path à tous les types à injecter lors de la combinaison JAX-RS avec CDI: http://docs.oracle.com/javaee/7/tutorial/jaxrs-advanced004.htm Bien que ce soit loin d'être parfait (par exemple vous recevrez un avertissement De Jersey au démarrage), j'ai décidé de prendre cette route, ce qui m'évite de maintenir tous les types supportés dans un classeur.

exemple:

@Singleton
@Path("singleton-configuration-service")
public class ConfigurationService {
  .. 
}

@Path("my-path")
class MyProvider {
  @Inject ConfigurationService _configuration;

  @GET
  public Object get() {..}
}

si vous préférez utiliser Guice et que vous ne voulez pas déclarer toutes les fixations, vous pouvez également essayer cet adaptateur:

guice-pont-jit-injecteur