Abhängigkeitsinjektion mit Jersey 2.0

Um nur einen Kommentar in der Antwort anzunehmen.

"Was macht bind? Was ist, wenn ich eine Schnittstelle und eine Implementierung habe?"

Es liest einfach bind( implementation ).to( contract ). Sie können die alternative Kette .in( scope ). Standardbereich von PerLookup. Wenn Sie also ein Singleton wollen, können Sie

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

Es ist auch eine RequestScoped verfügbar

Anstelle von bind(Class).to(Class) können Sie auch bind(Instance).to(Class) verwenden, die automatisch ein Singleton sein wird.

Hinzufügen zur akzeptierten Antwort

Für diejenigen, die herausfinden möchten, wie Sie Ihre AbstractBinder-Implementierung in Ihrer web.xml registrieren (d. H. Sie verwenden keine ResourceConfig), scheint es, als würden die Ordner nicht durch das Scannen von Paketen entdeckt, d. H. 

<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>

Oder das auch

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

Damit es funktioniert, musste ich eine Feature implementieren:

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;
    }
}

Die @Provider-Annotation sollte es ermöglichen, dass die Feature vom Paketscan abgeholt wird. Ohne das Scannen von Paketen können Sie die Feature explizit im web.xml registrieren.

<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>

Siehe auch:

• Benutzerdefinierte Methodenparameter-Injektion mit Jersey
• Wie füge ich ein Objekt in den Jersey-Anforderungskontext ein?
• Wie konfiguriere ich einen EntityManager in einer Jersey/hk2-Anwendung richtig?
• Scope-Injection für Singletons anfordern

und für allgemeine Informationen aus der Jersey-Dokumentation

• Custom Injection und Lifecycle Management

AKTUALISIEREN

Fabriken

Abgesehen von der grundlegenden Bindung in der akzeptierten Antwort gibt es auch Fabriken, in denen Sie eine komplexere Erstellungslogik haben können und auch Zugriff auf Kontextinformationen anfordern können. Zum Beispiel

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);
    }
});

Dann können Sie MyService in Ihre Ressourcenklasse einfügen.

Die ausgewählte Antwort stammt aus einer Weile zurück. Es ist nicht praktisch, jede Bindung in einer benutzerdefinierten HK2-Mappe zu deklarieren. Ich benutze Tomcat und musste nur eine Abhängigkeit hinzufügen. Obwohl es für Glassfish entworfen wurde, passt es perfekt in andere Behälter. 

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

Stellen Sie sicher, dass auch Ihr Container richtig konfiguriert ist ( siehe Dokumentation ).

Spät aber ich hoffe das hilft jemandem.

Ich habe meinen JAX RS folgendermaßen definiert:

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

Dann kann ich endlich in meinem Code spritzen:

@Inject
SomeManagedBean bean;

In meinem Fall ist SomeManagedBean eine ApplicationScoped-Bean.

Hoffe, das hilft jedem.

Oracle empfiehlt, die @Path-Annotation zu allen Typen hinzuzufügen, die injiziert werden sollen, wenn JAX-RS mit CDI kombiniert wird: http://docs.Oracle.com/javaee/7/tutorial/jaxrs-advanced004.htm Obwohl dies alles andere als perfekt ist (z. B. werden Sie beim Start von Jersey gewarnt), entschied ich mich für diesen Weg, der mich davon abhält, alle unterstützten Typen in einer Sammelmappe zu behalten.

Beispiel:

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

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

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

Für mich funktioniert es ohne die AbstractBinder, wenn ich in meiner Webanwendung (unter Tomcat 8.5, Jersey 2.27) die folgenden Abhängigkeiten aufnehme:

<dependency>
    <groupId>javax.ws.rs</groupId>
    <artifactId>javax.ws.rs-api</artifactId>
    <version>2.1</version>
</dependency>
<dependency>
    <groupId>org.glassfish.jersey.containers</groupId>
    <artifactId>jersey-container-servlet</artifactId>
    <version>${jersey-version}</version>
</dependency>
<dependency>
    <groupId>org.glassfish.jersey.ext.cdi</groupId>
    <artifactId>jersey-cdi1x</artifactId>
    <version>${jersey-version}</version>
</dependency>
<dependency>
    <groupId>org.glassfish.jersey.inject</groupId>
    <artifactId>jersey-hk2</artifactId>
    <version>${jersey-version}</version>
</dependency>

Es funktioniert für mich mit CDI 1.2/CDI 2.0 (jeweils mit Weld 2/3).

Wenn Sie lieber Guice verwenden und nicht alle Bindungen deklarieren möchten, können Sie auch diesen Adapter versuchen:

Guice-Bridge-Jit-Injektor