Die Integration Jersey 2 und Spring mit Java-Basierter Konfiguration

Ich bin mit Jersey 2.10 und jersey-spring3 und Feder 4.
Ich möchte erreichen, DI - (im wesentlichen Dienstleistungen), die in jersey Ressourcen sowie in anderen Orten und wollen zu erstellen, Spring-Bohnen, die durch die Java-Konfiguration.

Derzeit bin ich nicht in der Lage, um herauszufinden, jede Art und Weise, dies zu tun.
Irgendeine Idee, wie dies zu tun?

meine web.xml sieht so aus

<web-app>
    <display-name>Restful Web Application</display-name>
    <servlet>
        <servlet-name>jersey-serlvet</servlet-name>
        <servlet-class>
             org.glassfish.jersey.servlet.ServletContainer 

        </servlet-class>
        <init-param>
            <param-name>
                jersey.config.server.provider.packages
            </param-name>
            <param-value>com.xyz</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/application-context.xml</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <servlet-mapping>
        <servlet-name>jersey-serlvet</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

Und außer den deployment-descriptor, was hast du bisher ausprobiert, um einige Bohnen verwaltet ein container? Alle Bemühungen?
Ich weiß, dass annotationconfigapplicationcontext geladen wird @Konfigurierbare Klasse zu erstellen/verwalten Bohnen.aber weiß nicht, wie das zu erreichen ist mit Jersey.

InformationsquelleAutor beinghuman | 2014-09-06

web-app:

<context-param>
    <param-name>contextClass</param-name>
    <param-value>
      org.springframework.web.context.support.AnnotationConfigWebApplicationContext
  </param-value>
</context-param>

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>xxx.xxx.configuration.ApplicationConfiguration</param-value>
</context-param>

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<servlet>
    <servlet-name>SpringApplication</servlet-name>
    <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
    <init-param>
        <param-name>jersey.config.server.provider.classnames</param-name>
        <param-value>xxx.xxx.controllers.HelloController</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>SpringApplication</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

JavaBased Konfiguration:

@Configuration
public class ApplicationConfiguration {
  @Bean
  HelloService helloService () {
    return new HelloServiceImpl();
  }
}

und einfache Steuerung:

@Component
@Path("/helloController")
public class HelloController {

  @Autowired
  @Qualifier("helloService")
  private HelloService helloService ;


   @GET
   @Path("/hello")
   public String hello() {
    helloService.service();
  }
}

zur Prüfung:

localhost:8080/[AppName]/helloController/Hallo

daran denken, ohne alte Feder Abhängigkeiten, die Sie möglicherweise haben einige Konflikte, wenn Sie nicht. Sie können dies tun, dasselbe wie auf dem Beispiel unten oder durch DependencyManagement.

<dependencies>

    <!-- Jersey -->

    <dependency>
        <groupId>org.glassfish.jersey.ext</groupId>
        <artifactId>jersey-spring3</artifactId>
        <version>2.11</version>
        <exclusions>
            <exclusion>
                <artifactId>spring-context</artifactId>
                <groupId>org.springframework</groupId>
            </exclusion>
            <exclusion>
                <artifactId>spring-beans</artifactId>
                <groupId>org.springframework</groupId>
            </exclusion>
            <exclusion>
                <artifactId>spring-core</artifactId>
                <groupId>org.springframework</groupId>
            </exclusion>
            <exclusion>
                <artifactId>spring-web</artifactId>
                <groupId>org.springframework</groupId>
            </exclusion>
            <exclusion>
                <artifactId>jersey-server</artifactId>
                <groupId>org.glassfish.jersey.core</groupId>
            </exclusion>
            <exclusion>
                <artifactId>
                    jersey-container-servlet-core
                </artifactId>
                <groupId>org.glassfish.jersey.containers</groupId>
            </exclusion>
            <exclusion>
                <artifactId>hk2</artifactId>
                <groupId>org.glassfish.hk2</groupId>
            </exclusion>
        </exclusions>
    </dependency>

    <!-- Spring 4 dependencies -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.0.6.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.0.6.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.0.6.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>4.0.6.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>4.0.6.RELEASE</version>
    </dependency>

</dependencies>

können Sie bitte teilen Sie diesen code? als Beispiel, zum Beispiel. 🙂
Funktioniert wie ein Charme. Danke.
AFAIK die @Component annotation ist nur erforderlich, wenn Sie benötigen, Frühjahr Funktionalität, die erfordert, proxying, wie @Transactional.
was das für ein Projekt müssen wir schaffen, um zu verwenden, jersey und Frühling? Ich habe versucht, erstellen eines dynamic web project und ich habe keine bekommen pom.xml Datei. in welche Datei müssen wir hinzufügen, die oben genannten Abhängigkeiten und AUSSCHLÜSSE?
In Eclipse benutze ich plugin: 'M2E - Maven Integration for Eclipse'. Dann können Sie mit der rechten Maustaste auf Ihr Projekt -> Konfiguration -> Convert to Maven project. Dann sehen Sie die pom.xml Datei.

InformationsquelleAutor Marek Raszewski

2

Altmodische Weise:

Da Sie bereits initialisiert die ContextLoaderListener einen einfachen trick: benutzen Sie die WebApplicationContext rufen Sie Ihre Bohnen bei jeder Anwendung Punkt:
```
WebApplicationContext ctx = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
SomeBean someBean = (SomeBean) ctx.getBean("someBean");
```
Jersey-Unterstützung:

Oder verwenden Sie den annotation-basierte Erkennung, da Jersey hat bereits Unterstützung für Spring DI. Sie haben, um registrieren Sie Ihre Bohnen unter Ihrer main application entry point. Eintrag Punkt, im Beispiel unten wird some.package.MyApplication, die bereitgestellt werden sollten, als <init-param> von der servlet-container:
```
<servlet>
  <servlet-name>SpringApplication</servlet-name>
  <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
  <init-param>
    <param-name>javax.ws.rs.Application</param-name>
    <param-value>some.package.MyApplication</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
</servlet>
```
Registrieren Sie Bohnen in Ihrer Anwendung:
```
package some.package;

import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.server.spring.scope.RequestContextFilter;

public class MyApplication extends ResourceConfig {
  public MyApplication () {
    register(RequestContextFilter.class);
    register(SomeBean.class);
    //...
  }
}
```
Hier können Sie einen Blick auf eine ready-to-run Beispiel aus Jersey Git repo.
- 1.wie Sie Ihre alten Konzept.In welche Klasse würde ich schaffen den Rahmen.Ich meine Jersey ist das Scannen der annotierten Klassen zu registrieren, für die Ressourcen.Wie ist die Kontext-Klasse komponiert.?
- 2.Warum sollte ich mein Trikot Ressource Frühjahr Verwalteten Ressource durch die Verwendung von @ - Komponente.3.Dein link verweist auf die Verwendung von Datei ApplicationContext(Bohnen erstellt werden in der Datei ApplicationContext)4.Kann ich mich @ Konfigurierbare Klasse(mit meinen Bohnen) in MyApplication Klasse.
- Hier berühren sich auch mehrere Feder-Gesichter in einem einzigen Schuss, und ich habe absolut nicht mehr Fragen, weil es wird weit aus dem Haupt-Problem und seit dem ich annehme, Magd meine Antwort ganz klar und sogar zwei Möglichkeiten, das zu erreichen OP Ziel. Besser als zu sagen, kann ich dies oder jenes tun, ist, es selbst zu versuchen und durchsuchen Sie die Ergebnisse, wenn Sie Stapel oder verwirrt irgendwann nur wieder hier sein und ich persönlich werde froh sein, Sie zu unterstützen, wenn ich zu fangen Ihre post 🙂
- Ich wirklich zu schätzen Ihre Antwort.Ich werde versuchen, was Sie vorgeschlagen, und dann, wenn es funktioniert, akzeptiere ich es.
InformationsquelleAutor tmarwen

Hier ist etwas, das ich fand, ausgehend von verschiedenen tutorials. In Kombination mit anderen Antworten sollten Sie haben ein komplettes Beispiel.

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;

import com.sun.jersey.spi.spring.container.servlet.SpringServlet;
import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;

public class WebInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(AppConfig.class);
        ctx.setServletContext(servletContext);
        servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ctx);
        ServletRegistration.Dynamic servlet = servletContext.addServlet("jersey-serlvet", new SpringServlet());
        servlet.addMapping("/");
        servlet.setLoadOnStartup(1);
    }
}

InformationsquelleAutor oldfashionednewidea

Für diejenigen, die versuchen, es zu tun mit Java-config:

    public static void main(String[] args) throws IOException {
        HttpServer server = new HttpServer();
        NetworkListener listener = new NetworkListener("grizzly2", "localhost", 2088);
        server.addListener(listener);

        WebappContext ctx = new WebappContext("ctx","/");
        final ServletRegistration reg = ctx.addServlet("spring", new SpringServlet());
        reg.addMapping("/*");
        ctx.addContextInitParameter( "contextClass", "org.springframework.web.context.support.AnnotationConfigWebApplicationContext" );
        ctx.addContextInitParameter( "contextConfigLocation", "com.example.AppConfig" );
        ctx.addListener( "org.springframework.web.context.ContextLoaderListener" );
        ctx.addListener("org.springframework.web.context.request.RequestContextListener");

        ctx.deploy(server);

        server.start();

        System.in.read();

}

InformationsquelleAutor Georgi Staykov

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Altmodische Weise:

Jersey-Unterstützung: