Das serialisieren von Java-primitiven mit Jersey REST

In meiner Anwendung verwende ich Jersey-REST zum serialisieren von komplexen Objekten. Das funktioniert ganz gut. Aber es gibt ein paar Verfahren, die einfach mit return einen int-oder boolean.

Jersey können nicht mit primitiven Typen (nach meinem wissen), wahrscheinlich, weil Sie nicht kommentiert und Jersey hat keine Standard-annotation für Sie. Ich arbeitete um, dass durch die Schaffung von komplexen Typen wie ein RestBoolean oder RestInteger, die einfach halten ein int-oder boolean-Werte und die entsprechenden Anmerkungen.

Gibt es nicht einen einfacheren Weg, als das schreiben dieser container-Objekte?

JAX-RS/Jersey unterstützt nicht die Serialisierung von primitiven Typen oder auch die wrapper-Typen wie Integer, Boolean usw.. AFAIK, ist der Ansatz, den Sie genommen haben, scheint nur so.
Okay, danke!

InformationsquelleAutor Olvagor | 2010-04-13

Haben Sie einen Blick auf Genson.Es hat mir geholfen, eine Menge mit einem ähnlichen problem.Mit Genson, die Sie nutzen könnten Generika wie int,boolean, Listen und so weiter...Hier ist ein kurzes Beispiel.

@GET
@Produces(MediaType.APPLICATION_JSON)
public Response getMagicList() {
    List<Object> objList = new ArrayList<>();
    stringList.add("Random String");
    stringList.add(121); //int
    stringList.add(1.22); //double
    stringList.add(false); //bolean

    return Response.status(Status.OK).entity(objList).build();
}

Dies wird produzieren ein gültiges JSON-Hexe abgerufen werden können, sehr einfach wie diese:

    Client client = Client.create();
    WebResource webResource = client.resource("...path to resource...");
    List objList = webResource.accept(MediaType.APPLICATION_JSON).get(ArrayList.class);
    for (Object obj : objList) {
        System.out.println(obj.getClass());
    }

Werden Sie sehen, dass Genson helfen Sie decodieren des JSON-auf der client-Seite auch-und Ausgang die richtige Klasse für jeden.

Richtigen html-link zu Genson Projekt code.google.com/p/genson

InformationsquelleAutor mvlupan

3

Schreiben Sie eine Dienstleistung oder ein client? In der service-Seite der Dinge, Sie würde einfach schreiben MessageBodyWriter serialisieren, die einen Strom von Daten an ein Java-Objekt für Ihre Arten. In meinem use-cases, die Dienstleistungen, die ich Schreibe die Ausgabe in JSON oder XML, und XML ist der Fall, ich werfe gerade einen JAXB-annotation auf der Oberseite meiner Klassen und ich bin fertig.

Haben Sie schaute auf die Jersey-Benutzerhandbuch in Bezug auf diese?

3.6. Hinzufügen der Unterstützung für neue zusagen

InformationsquelleAutor Nick Klauer

Eigentlich Ihre beste Wette ist, zum schreiben eines benutzerdefinierten ContextResolver Anbieter wie den folgenden, verwendet Natürliche Aufbau von JSON.

   @Provider
   public class YourContextResolver implements ContextResolver<JAXBContext> {

    private JAXBContext context;
    private Class<?>[] types = { YourSpecialBean.class };

    public YourContextResolver() throws Exception {
        this.context = new JSONJAXBContext(
                JSONConfiguration.natural().build(), types);
    }

    public JAXBContext getContext(Class<?> objectType) {
        for (int i = 0; i < this.types.length; i++)
            if (this.types[i].equals(objectType)) return context;

        return null;
    }
}

Das einzige, was hier das Besondere auffällt, ist die YourSpecialBean.class in der Klasse[]. Dies definiert ein array von class-Typen, dass dieser Anbieter natürlich löst.

InformationsquelleAutor Alex Winston

2

Erzählen Jersey generieren, die richtigen JSON-Dokumente (Natürliche json). Ich benutze dieselbe Klasse für den rest app und JAXBContext resolver, fanden es die saubere Kapselung.

Besserer Programmierer umsetzen konnte-Helfer zu Durchlaufen .die class-Dateien und die Liste der entsprechenden Klassen automatisch durch die Identifizierung von @Annotation tags. Ich weiß nicht, wie es zu tun, die Laufzeit in einem eigenen source-code.

Diese beiden links waren hilfreich, das Studium dieses extra java-jargon. Ich weiß nicht warum, es gibt keine Jersey-parameter, um alle nur Arbeit out of the box.
WEB-INF/web.xml (snippet):
```
<servlet>
  <servlet-name>RESTServlet</servlet-name>
  <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
  <init-param>
    <param-name>javax.ws.rs.Application</param-name>
    <param-value>com.myapp.rest.RESTApplication</param-value>
  </init-param>
</servlet>
<servlet-mapping>
  <servlet-name>RESTServlet</servlet-name>
  <url-pattern>/servlet/rest/*</url-pattern>
</servlet-mapping>
```
com.myapp.rest.RESTApplication.java
```
package com.myapp.rest;

import java.util.*;
import javax.ws.rs.core.Application;
import javax.ws.rs.ext.ContextResolver;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import com.sun.jersey.api.json.JSONConfiguration;
import com.sun.jersey.api.json.JSONJAXBContext;

public class RESTApplication extends Application implements ContextResolver<JAXBContext> {
    private JAXBContext context;
    private Class<?>[] types;

    public RESTApplication() throws JAXBException {
        //list JAXB bean types to be used for REST serialization
        types = new Class[] {
            com.myapp.rest.MyBean1.class, 
            com.myapp.rest.MyBean2.class, 
        };
        context = new JSONJAXBContext(JSONConfiguration.natural().build(), types);
    }

    @Override
    public Set<Class<?>> getClasses() {
        //list JAXB resource/provider/resolver classes
        Set<Class<?>> classes = new HashSet<Class<?>>();
        //for(Class<?> type : types)
        //   classes.add(type);
        classes.add(MyBeansResource.class);
        classes.add(this.getClass()); //used as a ContextResolver class
        return classes;
    }

    @Override
    public JAXBContext getContext(Class<?> objectType) {
        //this is called each time when rest path was called by remote client
        for (Class<?> type : types) {
            if (type==objectType)
                return context;
        }
        return null;
    }
}
```
Klassen MyBean1,MyBean2 sind Reine java-Objekte und MyBeansResource-Klasse ist mit @Path rest-Funktionen. Es ist nichts besonderes, Sie erwarten, dass standard jaxp @Anmerkungen hier und da. Nach dieser java-jargon JSON-Dokumente haben
- null-oder einelementige Liste arrays sind immer so geschrieben, als json-array ein ([] Feld)
- primitive Ganzzahlen und Boolesche Felder geschrieben werden als json primitive (ohne Anführungszeichen)
Benutze ich folgende Umgebung
- Sun Java JDK1.6.x
- Apache Tomcat 6.x
- Jersey v1.14 Bibliotheken (jersey-archive-1.14.zip)
- webapps/myapp/WEB-INF/lib-Ordner hat asm-3.3.1.jar, jackson-core-asl.jar, jersey-client.jar, jersey-core.jar, jersey-json.jar, jersey-server.jar, jersey-servlet.jar Bibliotheken
- fügen Sie optional annotation-detector.jar wenn Sie infomas-asl-discovery-tool
jersey-archive.zip hatte ältere asm-3.1.jar Datei, die wahrscheinlich funktioniert, aber chapter_deps.html links auf eine neuere Datei. Siehe link-Liste oben.

Bearbeiten
Fand ich eine ausgezeichnete(schnell, leicht, nur 15KB) Anmerkung discovery-tool. Finden Sie in diesem Beitrag darüber, wie ich die AutoErmittlung-Typen zur Laufzeit und nicht mehr Bearbeiten müssen RESTApplication jedes mal neue java(jaxb) bean Hinzugefügt.

https://github.com/rmuller/infomas-asl/issues/7

InformationsquelleAutor Whome

Ich hatte das gleiche problem heute und nicht aufgeben, bis ich eine wirklich gute, passende Lösung. Ich kann nicht aktualisieren, jersey library von 1.1.5 es ist ein Legacy-System. Mein Rest-Service liefert eine Liste, und Sie sollten Folgen Sie diesen Regeln zu.

Leere Listen sind so dargestellt, als [] (fast unmöglich)
Ein Listen-Element gerendert werden als [] (schwierig, aber nur mapping-Konfiguration)
Viele Element-Listen sind so dargestellt, als [] (leicht)

Starten, von leicht bis unmöglich.

3) nichts ist heute normaler JSON-Mapping

2) Registrieren JAXBContextResolver wie die folgenden

@Provider
public class JAXBContextResolver implements ContextResolver<JAXBContext> {
    private final JAXBContext context;
    private final Set<Class<?>> types;
    private Class<?>[] ctypes = { Pojo.class }; //your pojo class
    public JAXBContextResolver() throws Exception {
        this.types = new HashSet<Class<?>>(Arrays.asList(ctypes));
        this.context = new JSONJAXBContext(JSONConfiguration.mapped()
                .rootUnwrapping(true)
                .arrays("propertyName") //that should rendered as JSONArray even if the List only contain one element but doesn't handle the empty Collection case
                .build()
                , ctypes);
    }

    @Override
    public JAXBContext getContext(Class<?> objectType) {
        return (types.contains(objectType)) ? context : null;
    }
}

1) Die folgende Vorgehensweise funktioniert nur für Sammlungen$EmptyList Klasse. Vielleicht finden Sie einen Weg, um es generell für alle Kollektionen, Sie sind leer. Kann code deal mit EmptyList so.

@Provider
@Produces(value={MediaType.APPLICATION_JSON})
public class EmptyListWriter implements MessageBodyWriter<AbstractList> {

    private static final String EMPTY_JSON_ARRAY = "[]";

    @Override
    public long getSize(AbstractList list, Class<?> clazz, Type type, Annotation[] annotations, MediaType mediaType) {
        return EMPTY_JSON_ARRAY.length();
    }

    @Override
    public boolean isWriteable(Class<?> clazz, Type type, Annotation[] annotations, MediaType mediaType) {
        return clazz.getName().equals("java.util.Collections$EmptyList");
    }

    @Override
    public void writeTo(AbstractList list, Class<?> clazz, Type type, Annotation[] annotations, MediaType mediaType, 
            MultivaluedMap<String, Object> headers, OutputStream outputStream) throws IOException, WebApplicationException {
        if (list.isEmpty())
            outputStream.write(EMPTY_JSON_ARRAY.getBytes());            
    }
}

InformationsquelleAutor Frank Ittermann

2

Ich habe gerade entdeckt, dass eine Rückkehr zu einem primitiven Typ mit Jersey ist problematisch. Ich habe entschieden, die Rückgabe-Zeichenkette statt. Dies ist vielleicht nicht sauber, aber ich glaube nicht, es ist zu schmutzig. Der Java-client, der wurde vom gleichen Autor geschrieben der server die meiste Zeit wickeln kann so ein string-Wert zurückgeben und konvertieren es zurück zu int. Clients in anderen Sprachen geschrieben sind, müssen sich bewusst sein, Rückgabetypen keiner Weise.

Definieren RestInteger, RestBoolean kann eine andere option sein, aber es ist eher umständlich, und ich sehe auch kaum Vorteile, die es attraktiv zu sein.

Oder vielleicht bin ich etwas fehlt hier wichtig?
- diese sollten auf jeden Fall nicht so umständlich und in das Trikot Klasse meiner Meinung nach. Ich machte den gleichen Abschluss Sonntag um 10 Uhr werde ich nur um die verflixte string ha.
InformationsquelleAutor zakmck

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.