L'intégration de Jersey 2 et le Printemps avec Java en Fonction de la Configuration

Je suis à l'aide de Jersey 2.10 et jersey-spring3 de Printemps et 4.
Je veux réaliser DI(essentiellement des services) en jersey de ressources ainsi que dans d'autres lieux et souhaitez créer des Beans Spring via Java Configuration.

Actuellement,je ne suis pas en mesure de trouver toute façon pour ce faire.
Une idée de comment faire cela?

mon web.xml on dirait que cette

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

Et si le descripteur de déploiement, ce que vous avez essayé jusqu'à présent pour obtenir des haricots géré par un conteneur? Tous les efforts?
Je sais que annotationconfigapplicationcontext est utilisé pour charger @Configurable classe pour créer/gérer des haricots.mais vous ne savez pas comment réaliser cela à l'aide de Jersey.

OriginalL'auteur 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 Configuration:

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

et de contrôleur simple:

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

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


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

pour les essais de:

localhost:8080/[Nom]/helloController/bonjour

retenir à propos de l'exclusion de l'ancien Ressort de dépendances, vous pourriez avoir des conflits si vous ne le faites pas. Vous pouvez le faire comme sur l'exemple ci-dessous, ou par le biais de 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>

pouvez-vous s'il vous plaît partager ce code? à titre d'exemple, par exemple. 🙂
Fonctionne comme un charme. Je vous remercie.
Autant que je sache, le @Component annotation n'est nécessaire que si vous avez besoin de Printemps fonctionnalité qui nécessite l'utilisation de proxy, comme @Transactional.
quel type de projet avons-nous à créer dans le but d'utiliser jersey et le printemps? J'ai essayé de créer un projet web dynamique et je n'ai pas tout pom.xml fichier. dans ce fichier, nous devons ajouter les mentionnés ci-dessus les dépendances et les exclusions?
Dans Eclipse, j'ai utiliser le plugin: 'M2E - Intégration de Maven pour Eclipse'. Ensuite, vous pouvez faire un clic droit sur votre projet -> Configuration> Convertir en projet Maven. Ensuite, vous verrez pom.xml fichier.

OriginalL'auteur Marek Raszewski

1

Ancienne:

Puisque vous avez déjà initialisé le ContextLoaderListener une simple astuce consiste à utiliser la WebApplicationContext pour récupérer vos haricots à n'importe quel point d'application:
```
WebApplicationContext ctx = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
SomeBean someBean = (SomeBean) ctx.getBean("someBean");
```
Maillot De Soutien:

Ou vous pouvez utiliser l'annotation basée sur la découverte, depuis Jersey a déjà le soutien de Printemps DI. Vous devez inscrire vos haricots en vertu de votre application principal point d'entrée. Ce point d'entrée, dans l'exemple ci-dessous seront some.package.MyApplication, doivent être présentés comme un <init-param> du conteneur de servlet:
```
<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>
```
Inscrivez-vous les haricots dans votre application:
```
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);
//...
}
}
```
Ici vous pouvez prendre un coup d'oeil à un prêt à exécuter l'exemple de Jersey repo Git.

1.comment utiliser votre ancienne approche.Dans la classe à laquelle serais-je créer le contexte.Je veux dire Jersey est l'analyse des classes annotées de s'inscrire pour les ressources.Comment utiliser le contexte composée de classe.?
2.Pourquoi devrais-je faire mon maillot de ressources Printemps de ressources Gérées par l'aide de @Composant.3.Votre lien pointe vers l'utilisation de l'applicationContext(haricots sont créés dans applicationContext)4.Puis-je enregistrer @ Configurable Classe(qui contient mes haricots) MyApplication Classe.
Ici, vous touchez trop de multiples Printemps visages en un seul coup et j'ai absolument ne pas demander à ceux qui, parce qu'à l'échelle de la question principale, et comme je suppose que je ménage ma réponse tout à fait claire et même deux façons d'atteindre les OP objectif. Mieux que de dire, je peux faire ceci ou cela c'est de l'essayer vous-même et d'explorer les résultats, si vous êtes de la pile ou de la confusion à un certain point, juste être de retour ici et personnellement je serai heureux de vous aider, si je l'attrape ton post 🙂
J'apprécie vraiment votre réponse.Je vais essayer ce que vous avez suggéré et puis si ça marche, je l'accepte.

OriginalL'auteur tmarwen

Ici est quelque chose que j'ai trouvé à partir de différents tutoriels. Combiné avec d'autres réponses, vous devriez avoir un exemple complet.

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

OriginalL'auteur oldfashionednewidea

Pour ceux qui essaient de le faire avec 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();
}

OriginalL'auteur Georgi Staykov

Vous devez vous connecter pour publier un commentaire.

Ancienne:

Maillot De Soutien: