webentwicklung-frage-antwort-db.com.de

Wie migriere ich von Jersey 1.0 nach Jersey 2.0?

Ich versuche, ein Upgrade auf Jersey 2.0 durchzuführen, und habe große Probleme, da sich die Gruppen- und Artefakten von Jersey vollständig geändert haben und ich keinen Migrationsplan in den Jersey-Dokumenten finden kann.

So sah meine pom.xml früher aus und diese wurde gut kompiliert:

        <dependency>
            <groupId>com.Sun.jersey</groupId>
            <artifactId>jersey-server</artifactId>
            <version>1.17</version>
        </dependency>
        <dependency>
            <groupId>com.Sun.jersey</groupId>
            <artifactId>jersey-servlet</artifactId>
            <version>1.17</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.Sun.jersey</groupId>
            <artifactId>jersey-server-linking</artifactId>
            <version>1.17.1</version>
        </dependency>
        <dependency>
            <groupId>com.Sun.jersey</groupId>
            <artifactId>jersey-client</artifactId>
            <version>1.17.1</version>
        </dependency>

In was sollen diese geändert werden? Diese nicht verwandte StackOverflow-Frage war etwas hilfreich, aber ich habe Probleme, Dinge zu finden, z. B. wo die @Ref-Annotation verschoben wurde.


Aktualisieren

  1. Es scheint, dass @Ref nicht mehr existiert oder zumindest es wird in der Dokumentation nicht mehr erwähnt . Jetzt verwenden Sie eine UriBuilder.
  2. Ich habe einen sehr hilfreichen Abschnitt in der Dokumentation gefunden, der meine Fragen beantwortet .
  3. Die HTTPBasicAuthFilter wurde in HttpBasicAuthFilter umbenannt. Beachten Sie die Großschreibung.
  4. Client client = Client.create(); ist zu Client client = ClientBuilder.newClient(); geworden
  5. Diese:

        String json = client
            .resource(getBaseUrl() + url)
            .accept(MediaType.APPLICATION_JSON_TYPE)
            .get(String.class);
    

    wurde

    String json = client
            .target(getBaseUrl())
            .path(url)
            .request(MediaType.APPLICATION_JSON_TYPE)
            .get(String.class);
    
19
Daniel Kaplan

Du nicht.

In Jersey 2.0 fehlt eine große Funktionalität von Jersey 1.0. Im Gegensatz zu dem, was die Committer Ihnen sagen werden, sind einige Dinge derzeit nicht realisierbar (z. B. Guice, Spring-Integration). Die Dinge scheinen an der Oberfläche zu funktionieren, aber sobald Sie tiefer eingedrungen sind, werden viele Funktionen immer noch beschädigt.

Viele der 1.x-Plugins sind in 2.x nicht vorhanden, hauptsächlich wegen des oben genannten Bruchs.

Vor diesem Hintergrund schlage ich vor, Jersey 2.x auf absehbare Zeit abzuhalten. Hoffentlich werden die Kommissare dies im kommenden Jahr aufräumen.

10
Gili

Es ist Schmerzen im Nacken, ich muss sagen. Wir befinden uns derzeit im Knie in der Migration eines relativ großen Client-Server-Projekts, das 3 Jahre alt ist, und ich möchte mir den Hals beißen. Hoffentlich sind wir am Ende des Kampfes ... Obwohl es einen Migrationsleitfaden gibt, ist dieser zwar keinesfalls umfassend.

  • UniformInterfaceException (und andere) gibt es nicht mehr. 

Stattdessen wird es durch die Ausnahme WebApplication und deren Nachfolger ersetzt. Es gibt kein Wort darüber im Migrationsleitfaden und das ist sehr wichtig.

  • JSON-Unterstützung

Der Migrationsleitfaden sagt:

Der JSON-Support hat in Jersey 2.x einige Änderungen erfahren. Der größte sichtbare Unterschied für den Entwickler liegt in der Initialisierung und in der Konfiguration von .

In Jersey 1.x wurde der JAXB/JSON-Support als eine Reihe von MessageBodyReaders und MessageWriters im Jersey-Json-Modul implementiert. Intern gab es mehrere Implementierungen von JSON für Object [.____. .] Mapping reicht von der eigenen kundenspezifischen Lösung von Jersey bis zu - Anbietern von Drittanbietern wie Jackson oder Jettison. Die Konfiguration der JSON - Unterstützung wurde in den Klassen JSONConfiguration und JSONJAXBContext Zentralisiert.

Großartig. Was ist, wenn Sie sich für die "benutzerdefinierte Lösung von Jersey" entschieden haben (was wir aus irgendeinem Grund getan haben)? Es gibt keine Alternative zu Trikot 2. Ich habe versucht, dasselbe JSON-Format mit Jettison-, Jackson- und Moxy-Providern herzustellen. Es gelang mir nicht Als Referenz, meine unbeantwortete Frage hier: Jersey 2 JSON Jettison Entpackung des Wurzelelements

8
Svilen

Weitere Informationen finden Sie im Migrationshandbuch 1.x zu 2.0 in den Jersey-Dokumenten.

6
Justin Emery

Anscheinend ist @InjectLink der Ersatz für @Ref.

Über diesen Link konnte ich dies in meine pom.xml einfügen:

    <dependency>
        <groupId>org.glassfish.jersey.ext</groupId>
        <artifactId>jersey-declarative-linking</artifactId>
        <version>2.6</version>
    </dependency>

und dann nahm ich einen vorhandenen @Ref und konnte mich durch @InjectLink ersetzen.

public Long id; // This id is referenced below in the link

@InjectLink(resource = FavoriteResource.class, method = "updateFavorites", bindings = {
        @Binding(name = "listId", value = "${instance.id}")
})
public URI linkURI;

Es sieht so aus, als wären einige der JavaDocs von @Ref in @InjectLink gerade, was eine weitere Bestätigung wäre, dass es der Ersatz ist:

/**
 * ...
 * @Ref(resource=SomeResource.class)
 * @Ref(resource=SomeResource.class, bindings={
 *   @Binding(name="id" value="${instance.id}"}
 * )
*/

BEARBEITEN:

Trickiges Zeug. Ich brauchte noch ein Stück, um diese Arbeit für mich zu machen. In web.xml, Habe ich jetzt:

<servlet>
    <servlet-name>jersey-servlet</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.mycompany.root</param-value>
    </init-param>
    <init-param>
        <param-name>jersey.config.server.provider.classnames</param-name>
        <param-value>com.mycompany.root.web.filter.AuditResourceFilterFactory;com.mycompany.root.web.filter.OtherAuditResourceFilterFactory</param-value>
    </init-param>
    <init-param>
        <param-name>javax.ws.rs.Application</param-name>
        <param-value>com.mycompany.root.web.resource.config.CustomResourceConfig</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

und schließlich sieht CustomResourceConfig.Java so aus

import org.glassfish.jersey.linking.DeclarativeLinkingFeature;
import org.glassfish.jersey.server.ResourceConfig;

public class CustomResourceConfig extends ResourceConfig {
    public CustomResourceConfig() {
        packages("org.glassfish.jersey.examples.linking");
        register(DeclarativeLinkingFeature.class);
    }
}
3
Patrick

Für die Migration von Jersey 1 nach Jersey 2 können Sie folgende Schritte ausführen:

Fügen Sie folgende Abhängigkeiten in der POM-Datei hinzu: Jersey 2.23.2-Abhängigkeiten 

   <dependency>
    <groupId>org.glassfish.jersey.containers</groupId>
    <artifactId>jersey-container-servlet-core</artifactId>
    <version>2.23.2</version>
   </dependency>
   <dependency>
    <groupId>org.glassfish.jersey.ext</groupId>
    <artifactId>jersey-spring3</artifactId>
    <version>2.23.2</version>
    <exclusions>
     <exclusion>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
     </exclusion>
     <exclusion>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
     </exclusion>
     <exclusion>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
     </exclusion>
    </exclusions>
   </dependency>
   <dependency>
    <groupId>org.glassfish.jersey.core</groupId>
    <artifactId>jersey-client</artifactId>
    <version>2.23.2</version>
   </dependency>
   <dependency>
    <groupId>org.glassfish.jersey.media</groupId>
    <artifactId>jersey-media-moxy</artifactId>
    <version>2.23.2</version>
   </dependency>
   <dependency>
    <groupId>org.glassfish.jersey.ext</groupId>
    <artifactId>jersey-entity-filtering</artifactId>
    <version>2.23.2</version>
   </dependency>
   <dependency>
    <groupId>org.glassfish.jersey.core</groupId>
    <artifactId>jersey-server</artifactId>
    <version>2.23.2</version>
   </dependency>
   <dependency>
    <groupId>org.glassfish.jersey.core</groupId>
    <artifactId>jersey-common</artifactId>
    <version>2.23.2</version>
   </dependency>
   <dependency>
    <groupId>org.glassfish.jersey.bundles.repackaged</groupId>
    <artifactId>jersey-guava</artifactId>
    <version>2.23.2</version>
   </dependency>
   <dependency>
      <groupId>org.glassfish.jersey.media</groupId>
      <artifactId>jersey-media-json-jackson</artifactId>
      <version>2.23.2</version>
      <exclusions>
       <exclusion>
        <groupId>com.fasterxml.jackson.core</groupId>
         <artifactId>jackson-annotations</artifactId>
       </exclusion>
      </exclusions>
   </dependency>
   <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.5.4</version>
   </dependency>
   <dependency>
       <groupId>org.glassfish.jersey.media</groupId>
       <artifactId>jersey-media-multipart</artifactId>
       <version>2.23.2</version>
   </dependency>

   <dependency>
       <groupId>org.jvnet</groupId>
       <artifactId>mimepull</artifactId>
       <version>1.6</version>
   </dependency>

Machen Sie folgenden Eintrag in Web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="3.0" xmlns="http://Java.Sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://Java.Sun.com/xml/ns/javaee http://Java.Sun.com/xml/ns/javaee/web-app_3_0.xsd">

 <servlet>
  <servlet-name>jersey-servlet</servlet-name>
  <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
  <init-param>
   <param-name>javax.ws.rs.Application</param-name>
   <param-value>com.jsg.resource.initializer.RestResourceInitializer</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
 </servlet>
 <servlet-mapping>
  <servlet-name>jersey-servlet</servlet-name>
  <url-pattern>/rest/*</url-pattern>
 </servlet-mapping> '

       <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>
 <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:applicationContext.xml</param-value>
 </context-param>
      <resource-ref>
        <description>DB Connection</description>
        <res-ref-name>jdbc/myAppName</res-ref-name>
       <res-type>javax.sql.DataSource</res-type>
       <res-auth>Container</res-auth>
   </resource-ref>
</web-app>

Schreiben Sie den folgenden Code in RestResourceIntializer 

    package com.jsg.resource.initializer;

    import Java.util.HashSet;
    import Java.util.Set;
    import javax.ws.rs.core.Application;

    public class RestResourceInitializer extends Application {

     /**
      * Gets the classes.
      *
      * @return the classes
      */
     public Set<Class<?>> getClasses() {
      Set<Class<?>> classes = new HashSet<Class<?>>(); 

      // Resources
      classes.add(org.glassfish.jersey.jackson.JacksonFeature.class);
      classes.add(org.glassfish.jersey.server.spring.scope.RequestContextFilter.class);
      classes.add(org.glassfish.jersey.media.multipart.MultiPartFeature.class);

                   //Rest classes within Application.
                    classes.add(com.jsg.rest.AbcRestService.class);

      classes.add(com.jsg.rest.CdeRestService.class);
      return classes;
     }
    }

Wenn Sie nun Code mit den oben genannten Änderungen in websphere bereitstellen, wird die folgende Ausnahme angezeigt:

Caused by: Java.lang.NoSuchMethodError: javax/ws/rs/core/Application.getProperties()Ljava/util/Map; at org.glassfish.jersey.server.ApplicationHandler.(ApplicationHandler.Java:287) at org.glassfish.jersey.servlet.WebComponent.(WebComponent.Java:311)

Grund für die oben genannte Ausnahme ist, dass Websphere die JAX-RS 1-Implementierung unterstützt. Wir implementieren jedoch Jersey 2-Code, der Jax-rs 2-Implementierung ist.

Schritte zum Lösen der obigen Ausnahme:

Im Grunde müssen wir also WebSphere zwingen, unsere Jersey 2-Gläser anstelle von Standard-Jax-rs 1 zu wählen. Dazu müssen wir die folgenden Schritte befolgen 

1) Deaktivieren Sie den eingebauten JAX-RS, indem Sie die folgende JVM-Eigenschaft auf true setzen

com.ibm.websphere.jaxrs.server.DisableIBMJAXRSEngine=true

Diese Eigenschaft kann über die Administrationskonsole von WebSphere festgelegt werden. Gehen Sie zu Server-> Alle Server -> -> Serverinfrastruktur -> Java- und Prozessverwaltung -> Prozessdefinition -> Zusätzliche Eigenschaften -> Java Virtual Machine -> Zusätzliche Eigenschaften -> Benutzerdefiniert Eigenschaften

2) Erstellen Sie eine isolierte gemeinsam genutzte Bibliothek mit den Jersey-2-Gläsern und Spring 4-Gläsern Eine isolierte gemeinsam genutzte Bibliothek kann über die Administrationskonsole von Websphere erstellt werden, indem Sie auf Umgebung-> Gemeinsam genutzte Bibliotheken -> Neu gehen

im Klassenpfad-Feld müssen wir den Pfad des Ordners auf dem Server eingeben, in den wir alle Jersey 2- und Spring 4-Gläser gelegt haben

/var/was/server2/jerseyLib1/spring-context-4.3.4.RELEASE.jar
/var/was/server2/jerseyLib1/spring-core-4.3.4.RELEASE.jar
/var/was/server2/jerseyLib1/spring-beans-4.3.4.RELEASE.jar
/var/was/server2/jerseyLib1/spring-aop-4.3.4.RELEASE.jar
/var/was/server2/jerseyLib1/spring-web-4.3.4.RELEASE.jar
/var/was/server2/jerseyLib1/spring-expression-4.3.4.RELEASE.jar
/var/was/server2/jerseyLib1/spring-bridge-2.5.0-b05.jar
/var/was/server2/jerseyLib1/hk2-locator-2.5.0-b05.jar
/var/was/server2/jerseyLib1/hk2-api-2.5.0-b05.jar
/var/was/server2/jerseyLib1/hk2-utils-2.5.0-b05.jar
/var/was/server2/jerseyLib/javax.inject-2.5.0-b05.jar
/var/was/server2/jerseyLib1/javax.annotation-api-1.2-b03.jar
/var/was/server2/jerseyLib1/javax.ws.rs-api-2.0.1.jar
/var/was/server2/jerseyLib1/jersey-client-2.23.2.jar
/var/was/server2/jerseyLib1/jersey-spring3-2.23.2.jar
/var/was/server2/jerseyLib1/jersey-container-servlet-core-2.23.2.jar
/var/was/server2/jerseyLib1/jersey-server-2.23.2.jar
/var/was/server2/jerseyLib1/jersey-common-2.23.2.jar

/var/was/server2/jerseyLib1/jersey-guava-2.23.2.jar

Wählen Sie auch im Abschnitt zum Laden von Klassen "Verwenden eines isolierten Klassenladeprogramms für diese gemeinsam genutzte Bibliothek" aus.

klicken Sie anschließend auf Übernehmen und Ok. Nun ist die Erstellung einer isolierten gemeinsam genutzten Bibliothek abgeschlossen.

  1. Binden Sie diese isolierte gemeinsam genutzte Bibliothek mit Ihrer Anwendungs-War-Datei wie folgt in der Admin-Konsole

    a) Anwendung -> Alle Anwendungen -> Klicken Sie auf den Namen Ihrer Anwendung b) Gehen Sie zu Referenzen -> Shared Library-Referenzen -> Referenz Shared Libraries -> Wählen Sie Ihren Application War (Nicht ohr) aus und klicken Sie auf OK. c) Wählen Sie die Bibliothek aus, die wir in Schritt 2 im Kombinationsfeld "Verfügbar" auf der linken Seite erstellt haben, und platzieren Sie sie rechts im Kombinationsfeld "Ausgewählt". Klicken Sie anschließend auf OK. Damit haben wir das verknüpft Freigegebene gemeinsam genutzte Bibliothek mit Anwendungsdatei.

  2. Starten Sie den Server und die Anwendung sollte betriebsbereit sein.

Referenz mit Screenshots -> http://javasolutionsguide.blogspot.nl/2017/03/howtomigratefromjersey1tojersey2InWebsphere.html

0
user2603985