RSS

Archiv der Kategorie: IT

JSON Provider erstellen. Part 7: Konvertierung JSONXML


Im folgenden wird die Umwandlung von JSON in XML mit Java beschrieben. Die JSON-lib bietet mit dem JSONSerializer die Möglichkeit nahezu jedes Java-Objekt in die JSON-Notation zu konvertieren. Mit dem XMLSerializer kann man JSON Objekte in die XML-Notation und zurück umwandeln.

Um die JSON-lib benutzen zu können, sind mindestens folgende Libraries zusätzlich notwendig:

Vorbereitung

Erstellen Sie z.B. in Eclipse ein neues Java Projekt und binden Se die o.g. Libraries (inklusive der JSON-lib) in Ihr Projekt ein.
 

 

JSON>XML

Im folgenden Beispiel wird ein JSON String erstellt und aus diesem der korrespondierende XML String erstellt. Die Klasse „XMLSerializer“ bietet über die write-Methode alle Voraussetzungen, um diese Aufgabe zu erledigen:

package org.jkhofmann.dyndns;

import net.sf.json.JSON;
import net.sf.json.JSONArray;
import net.sf.json.JSONSerializer;
import net.sf.json.xml.XMLSerializer;

public class JSON2XMLConverter {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		String jsonStr = "{'foo':'bar'," +
						 "'coolness':2.0," +
				         "'altitude':39000," +
				         "'pilot':{'firstName':'Buzz'," +
				         "'lastName':'Aldrin'}," +
				         "'mission':'apollo 11'}";

        XMLSerializer serializer = new XMLSerializer();
        JSON json = JSONSerializer.toJSON( jsonStr );
        String xml = serializer.write( json );
        System.out.println(xml);
	}
}

Die (formatierte) Ausgabe:

<?xml version="1.0" encoding="UTF-8"?>
<o>
  <altitude type="number">39000</altitude>
  <coolness type="number">2.0</coolness>
  <foo type="string">bar</foo>
  <mission type="string">apollo 11</mission>
  <pilot class="object">
    <firstName type="string">Buzz</firstName>
    <lastName type="string">Aldrin</lastName>
  </pilot>
</o>

Will man den Typen-Hinweis ausschalten, gibt man folgenden Befehl „serializer.setTypeHintsEnabled(false);“ vor der Serialisierung ein:

...

        JSON json = JSONSerializer.toJSON( jsonStr );
        serializer.setTypeHintsEnabled(false);
        String xml = serializer.write( json );
...

Die entsprechende Ausgabe sieht dann so aus:

<?xml version="1.0" encoding="UTF-8"?>
<o>
  <altitude>39000</altitude>
  <coolness>2.0</coolness>
  <foo>bar</foo>
  <mission>apollo 11</mission>
  <pilot>
    <firstName>Buzz</firstName>
    <lastName>Aldrin</lastName>
  </pilot>
</o>

Soll der Name des Wurzel-Knotens von „<o>“ z.B. nach „<SampleJSON>“ umbenannt werden, dann gibt man den Befehl „serializer.setRootName(„SampleJSON“)“ ein. Die Ausgabe sieht dann so aus:

<?xml version="1.0" encoding="UTF-8"?>
<SampleJSON>
  <altitude>39000</altitude>
  <coolness>2.0</coolness>
  <foo>bar</foo>
  <mission>apollo 11</mission>
  <pilot>
    <firstName>Buzz</firstName>
    <lastName>Aldrin</lastName>
  </pilot>
</SampleJSON>

 

Hinweis: Will man anstelle eines String einen InputStream umwandeln, leistet die Apache Commons IOUtils Library hilfreiche Dienste.

// is comes as a InputStream object and will be
// converted to a String:
String jsonData = IOUtils.toString(is);

 

XML > JSON

Um einen XML String in einen JSON String umzuwandeln, kann man wieder die Klasse „XMLSerializer“ verwenden, diesmal aber über die read-Methode:

JSON jsonout = serializer.read( xml );

Beispiel: Die Klasse wandelt einen JSON String in einen XML String um und anschließend wieder in einen JSON String:

package org.jkhofmann.dyndns;

import net.sf.json.JSON;
import net.sf.json.JSONArray;
import net.sf.json.JSONSerializer;
import net.sf.json.xml.XMLSerializer;

public class JSON2XMLConverter {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		// JSON Eingabestring:
		String jsonStr = "{'foo':'bar'," +
						 "'coolness':2.0," +
				         "'altitude':39000," +
				         "'pilot':{'firstName':'Buzz'," +
				         "'lastName':'Aldrin'}," +
				         "'mission':'apollo 11'}";

		// Konvertierung nach XML:
        XMLSerializer serializer = new XMLSerializer();
        JSON json = JSONSerializer.toJSON( jsonStr );
        serializer.setTypeHintsEnabled(false);
        serializer.setRootName("SampleJSON");
        String xml = serializer.write( json );
        System.out.println(xml);
        // Konvertierung zurück nach JSON:
        JSON jsonout = serializer.read( xml );
        System.out.println( jsonout );
	}
}

Ausgabe des JSON Strings:

{"altitude":"39000",
 "coolness":"2.0",
 "foo":"bar",
 "mission":"apollo 11",
 "pilot":{
    "firstName":"Buzz",
    "lastName":"Aldrin"
 }
}

 

Links

Wie immer ist ein Großteil der Kenntnisse und Beispiele, de ich hier wiedergebe, nicht auf meinem „eigenen Mist“ gewachsen. Deshalb möchte ich hier die verwendeten Links und weitere Fundstellen nennen:

 
Hinterlasse einen Kommentar

Verfasst von - Februar 23, 2012 in IT, WebServices

 

Schlagwörter: , , ,

Tomcat auf Ubuntu für Eclipse verwenden

Tomcat auf Ubuntu für Eclipse verwenden

Wenn man versucht einen installierten Tomcat-Server z.B. für Debugging in Eclipse zu verwenden und bekommt die Fehlermeldung, dass die Runtime nicht verwendet werden kann, dann kann das an den unterschiedlichen Installationsverzeichnissen der Tomcat Installation liegen.

Nachdem man Tomcat installiert hat, wird die Installation auf /usr/share, /var/lib, /var/log etc. verteilt. Damit scheint zumindest die „Indigo“ Version von Eclipse, Probleme zu haben. Fasst man die verteilten Verzeichnisse über Softlinks wieder in ein Verzeichnis zusammen, dann funktioniert die Einbindung von Tomcat in Eclipse.

sudo apt-get install tomcat6
cd /usr/share/tomcat6
sudo ln -s /var/lib/tomcat6/conf conf
sudo ln -s /etc/tomcat6/policy.d/03catalina.policy conf/catalina.policy
sudo ln -s /var/log/tomcat6 log
sudo chmod -R 777 /usr/share/tomcat6/conf

Anschließend muss man noch die Runtime über Window/Preferences/Sever/Runtime Environments hinzufügen, das entsprechende Verzeichnis (zum obigen Beispiel) wäre dann  /usr/share/tomcat6.

Falls der Tomcat Server nicht gestartet werden kann, liegt das oft daran, dass er bereits beim Booten des OS über ein Skript gestartet wurde. Das Stoppen geht einfach über:

sudo service tomcat6 stop

Anschließend sollte sich der Tomcat Server in Eclipse starten lassen.

Hinweis: Die Informationen wurden aus stackoverflow entnommen und aufbereitet!

 
Hinterlasse einen Kommentar

Verfasst von - Februar 22, 2012 in IT

 

Schlagwörter: ,

JSON Provider erstellen. Part 6: Ressourcen, Sub-Ressourcen


Im letzten Teil ging es um „Ressourcen, Parameter, CRUD, JSON etc.„, in diesem Artikel soll das Thema „Ressourcen“ vertieft werden.

Mit Root- und Sub-Ressourcen, sowie mit Sub-Ressource-Locators ist es möglich einen Rest-Service und dessen Ressourcen in einer Klassen-Hierarchie zu strukturieren.

Root-Ressourcen

Eine Root-Ressource zeichnet sich dadurch aus, dass sie zum einen als POJO (Plain Old Java Object) definiert ist. Die Klasse selbst ist mit @Path annotiert und enthält mindestens eine Methode, die mit @Path, @GET, @PUT, @POST oder @DELETE annotiert ist.

Beispiel:

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.sun.jersey.spi.resource.Singleton;

@Singleton
@Path("/printers")
public class ResourcesSubResources {

    // Root -Resource:
    @GET
	@Produces(MediaType.TEXT_PLAIN)
    public String getMyResources() {
    	return "Root-Resource: Method: getMyResources, URI: /printers";
    }
}

Ausgabe:

 

Sub-Ressourcen

Eine Sub-Ressource zeichnet sich dadurch aus, dass es sich entweder um eine Methode handelt, die mit @GET, @POST, @PUT, @DELETE, zusammen mit @Path annotiert ist, oder über Sub-Ressource-Locators delegiert wird.

Beispiel:

package org.jkhofmann.dyndns;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.sun.jersey.spi.resource.Singleton;

@Singleton
@Path("/printers")
public class ResourcesSubResources {

    // Root -Resource:
    @GET
	@Produces(MediaType.TEXT_PLAIN)
    public String getMyResources() {
    	return "Root-Resource: Method: getMyResources, URI: /printers";
    }

    // Sub-Resource:
    @GET @Path("/list")
	@Produces(MediaType.TEXT_PLAIN)
    public String getListOfPrinters() {
    	return "Sub-Resource: Method: getListOfPrinters, URI: /printers/list";
    }

    // Sub-Resource:
    @GET @Path("/ids/{printerid}")
	@Produces(MediaType.TEXT_PLAIN)
    public String getPrinter(@PathParam("printerid") String printerId) {
    	return "sub-Resource: Method: getPrinter, URI: /printers/ids/" + printerId;
    }
}

Dazu die entsprechenden Aufrufe in einem Browser:

 

Sub-Ressource-Locators

Man muss nicht alle Root- und Sub-Ressourcen in einer Klasse zusammenfassen. Mit sog. Sub Ressource Locators ist es möglich aus einer Ressource Klasse heraus weitere Ressource Klassen aufzurufen.

Beispiel:

package org.jkhofmann.dyndns;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.sun.jersey.spi.resource.Singleton;

@Singleton
@Path("/printers")
public class ResourcesSubResources {

    // Root -Resource:
    @GET
	@Produces(MediaType.TEXT_PLAIN)
    public String getMyResources() {
    	return "Root-Resource: Method: getMyResources, URI: /printers";
    }
...

    // Sub-Resource-Locator:
    @Path("subresource")
    public SubResource getSubResource() {
        return new SubResource();
    }
}

 

Sub Ressource Klasse:

package org.jkhofmann.dyndns;

import javax.ws.rs.GET;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

public class SubResource {
	@GET
	@Produces(MediaType.TEXT_PLAIN)
    public String getMyResources() {
    	return "Sub-Resource: Method: getMyResources, URI: /printers/subresource with subresource locator";
    }

    @GET
    @Path("{version}")
	@Produces(MediaType.TEXT_PLAIN)
    public String getPrinter(@PathParam("version") String version) {
    	return "sub-Resource: Method: getPrinter, URI: /printers/subresource/{version}" + version;
    }
}

 

Aufruf im Browser:

 

Links

Chapter 2. Overview of JAX-RS 1.1.1

 
Hinterlasse einen Kommentar

Verfasst von - Februar 21, 2012 in IT, WebServices

 

JAXB mit Eclipse nutzen

JAXB mit Eclipse nutzen

Java Architecture for XML Binding (JAXB) ermöglicht den einfachen Umgang mit XML Dateien und Java. Man kann damit Java-Klassen erstellen, die auf Schema-Definitionen (z.B. XSD) von XML Dateien beruhen und diese dann einlesen und weiterverarbeiten. Die umgekehrte Richtung, also das Generieren von XML Dateien aus Java-Klassen ist damit ebenfalls möglich. Beides wird in diesem Artikel behandelt.

 

Voraussetzungen:

Java 1.6

Eclipse IDE for Java EE Developers, ich verwende hier das Indigo Release

Download einer aktuellen JAXB Version, z.B. 2.2.41.

Download JAXB-Eclipse-Plugin, z.B. JAXB-Builder

 

Installation/Konfiguration:

Java und die Eclipse IDE kann man einfach herunterladen und installieren. JAXB kann man an einem zentralen Ort speichern, um später die Libraries und evtl. Tools verwenden zu können (z.B. in den Classpath des Eclipse-Projektes einzubinden) – ich verwende hierfür meist das Verzeichnis „C:Program Files (x86)Java“

Das JAXB Eclipse Plugin muss man entpacken und im Plugin-Verzeichnis der Eclipse-Installation kopieren. Danach Eclipse neu starten. Falls der Wizard über „File > New > Project > JAXB“ nicht sichtbar ist, sollte man Eclipse beenden und mit dem Parameter „-clean“ neu starten, um den Plugin-Cache zu leeren.

 

Erst mal ohne Plugin…:

Um einen ersten Einblick in JAXB zu gewinnen, will ich veranschaulichen, wie man Klassen erstellt, ohne das Eclipse-Plugin zu nutzen. Der erste Schritt besteht darin, sich im Klaren zu sein, welche Daten man verarbeiten will und wie man diese in einer XML-Datei darstellen würde.

Im folgenden Beispiel will ich eine Anwendung erstellen, die in der Lage ist XML-Dateien zu verarbeiten, die Kontakte beinhaltet. Der Aufbau dieser XML-Datei könnte wie folgt aussehen:

<Kontakte>
	<Kontakt>
		<Name>Name1</Name>
		<Vorname>Vorname1</Vorname>
		<eMail>eMail1</eMail>
	</Kontakt>
	<Kontakt>
		<Name>Name2</Name>
		<Vorname>Vorname2</Vorname>
		<eMail>eMail2</eMail>
	</Kontakt>
	<Kontakt>
		<Name>Name3</Name>
		<Vorname>Vorname3</Vorname>
		<eMail>eMail3</eMail>
	</Kontakt>
</Kontakte>

Es gibt eine Vielzahl von Online-Tools, die eine Umwandlung der XML-Datei in eine XSD-Datei (XML-Schema) ermöglichen, z.B. http://www.xmlforasp.net. Das Ergebnis sieht dann wie folgt aus:

<?xml version="1.0" encoding="utf-16"?>
<xsd:schema attributeFormDefault="unqualified" elementFormDefault="qualified" version="1.0" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <xsd:element name="Kontakte">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element maxOccurs="unbounded" name="Kontakt">
          <xsd:complexType>
            <xsd:sequence>
              <xsd:element name="Name" type="xsd:string" />
              <xsd:element name="Vorname" type="xsd:string" />
              <xsd:element name="eMail" type="xsd:string" />
            </xsd:sequence>
          </xsd:complexType>
        </xsd:element>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>
</xsd:schema>

Jetzt ist es an der Zeit mit Eclipse ein Java Projekt zu erstellen. Die XSD- und die XML-Datei können der Vollständigkeit halber in das Projektverzeichnis kopiert oder dort angelegt werden.

Mit dem Download der JAXB Version werden zwei Skriptdateien mit ausgeliefert, die im „bin“ Unterverzeichnis zu finden sind:

  • „xjc“, um eine XML-Schemadatei in vollständig annotierte Java-Klassen zu kompilieren
  • „schemagen“, um eine XML-Schemadatei aus Java-Klassen zu generieren

Mit dem „xjc“ Tool ist es also möglich, aus der Schema-Datei „Kontakte.xsd“ die entsprechenden JAXB-Java-Klassen zu generieren:

Die generierten Klassen werden im Unterverzeichnis „generated“ gespeichert. Ich kopieren das Verzeichnis in den src Unterordner des Eclipse Projektes und aktualisiere das Projektverzeichnis:

Es werden folgende Klassen und Methoden generiert:

Um die JAXB-Klassen nutzen zu können, müssen die im „lib“-Unterverzeichnis vorhandenen jar Dateien in den Build-Path des Projektes eingebunden werden:

Eine Anwendung, die die XML-Datei parst und weiterverarbeitet könnte etwa so aussehen:

package org.jkhofmann.dyndns;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

import generated.*;

public class ParseKontakte {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			// create JAXB context and instantiate marshaller
			JAXBContext context = JAXBContext.newInstance(Kontakte.class);
			Marshaller m = context.createMarshaller();

			// get variables from our xml file, created before
			System.out.println();
			System.out.println("Kontakte XML File: ");
			Unmarshaller um = context.createUnmarshaller();
			Kontakte kontakte = (Kontakte) um.unmarshal(new FileReader(
					"Kontakte.xml"));

			for (int i = 0; i < kontakte.getKontakt().toArray().length; i++) {
				System.out.println("Kontakt " + (i + 1) + ": "
						+ "Name: " + kontakte.getKontakt().get(i).getName() + ", "
						+ "Vorame: " + kontakte.getKontakt().get(i).getVorname() + ", "
						+ "eMail: " + kontakte.getKontakt().get(i).getEMail() + ", "
						);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

Die entsprechende Ausgabe:

Kontakte XML File:
Kontakt 1: Name: Name1, Vorame: Vorname1, eMail: eMail1,
Kontakt 2: Name: Name2, Vorame: Vorname2, eMail: eMail2,
Kontakt 3: Name: Name3, Vorame: Vorname3, eMail: eMail3,

In einem weiteren Schritt will ich den Inhalt bearbeiten und erweitern:

package org.jkhofmann.dyndns;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

import generated.*;

public class ParseKontakte {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			// create JAXB context and instantiate marshaller
			JAXBContext context = JAXBContext.newInstance(Kontakte.class);
			Marshaller m = context.createMarshaller();

			// get variables from our xml file, created before
			System.out.println();
			System.out.println("Kontakte XML File: ");
			Unmarshaller um = context.createUnmarshaller();
			Kontakte kontakte = (Kontakte) um.unmarshal(new FileReader(
					"Kontakte.xml"));

			for (int i = 0; i < kontakte.getKontakt().toArray().length; i++) {
				System.out.println("Kontakt " + (i + 1) + ": "
						+ "Name: " + kontakte.getKontakt().get(i).getName() + ", "
						+ "Vorame: " + kontakte.getKontakt().get(i).getVorname() + ", "
						+ "eMail: " + kontakte.getKontakt().get(i).getEMail() + ", "
						);
			}

			// Add a new contact:
			Kontakte.Kontakt k = new Kontakte.Kontakt();
			k.setName("Name4");
			k.setVorname("Vorname4");
			k.setEMail("eMail4");

			kontakte.getKontakt().add(k);

			// write the enhanced contact list in a new XML file:
			m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
			m.marshal(kontakte, System.out);

			Writer w = null;
			try {
				w = new FileWriter("Kontakte2.xml");
				m.marshal(kontakte, w);
			} finally {
				try {
					w.close();
				} catch (Exception e) {
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

Die Ausgabe („Kontakte2.xml“):

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Kontakte>
    <Kontakt>
        <Name>Name1</Name>
        <Vorname>Vorname1</Vorname>
        <eMail>eMail1</eMail>
    </Kontakt>
    <Kontakt>
        <Name>Name2</Name>
        <Vorname>Vorname2</Vorname>
        <eMail>eMail2</eMail>
    </Kontakt>
    <Kontakt>
        <Name>Name3</Name>
        <Vorname>Vorname3</Vorname>
        <eMail>eMail3</eMail>
    </Kontakt>
    <Kontakt>
        <Name>Name4</Name>
        <Vorname>Vorname4</Vorname>
        <eMail>EMail4</eMail>
    </Kontakt>
</Kontakte>

Ich finde, die Anwendung von JAXB ist im Vergleich zur Anwendung von SAX- oder DOM-Parsern (z.B. Xerces oder allgemeiner  Java API for XML Processing – JAXP), wesentlich einfacher und zeitsparender. Anwender der Eclipse IDE können sich zusätzlich das Plugin „JAXB-Builder“ installieren. Die Anwendung wird im folgenden erläutert.

Jetzt mit dem Plugin…

Dazu erstellt man sich ein neues Projekt über „File > New > Project > JAXB“ und kopiert die XSD-Datei hinein:

Damit das Plugin funktioniert, muss man (wie gehabt) den Build-Path des Projektes um die JAXB-Libraries erweitern:

Durch einen Rechtsklick auf die XSD-Datei > Generate > JAXB Classes… kann man sich die JAXB-Klassen generieren lassen. Das Ergebnis ist das Gleiche wie oben, d.h. das Ausprogrammieren ist noch notwendig.

Man erspart sich allerdings den Umweg über die Kommandozeile, zum Generieren der JAXB-Java-Klassen.

 
Ein Kommentar

Verfasst von - Februar 3, 2012 in Formate, IT

 

Schlagwörter: , , , ,

OData: die Daten API des Webs

OData: die Daten API des Webs

Es gibt mittlerweile eine Vielzahl an Libraries, die es Applikationen in verschiedenen Programmiersprachen erlauben, auf eine Ressource (z.B. Datenbanken, WebServices etc.) zuzugreifen – beispielsweise gibt es für C++ die ODBC Library oder für Java die JDBC Library. In den Datenbanken, Dateien, oder sonstigen Informationsquellen liegen die Daten bzw. die Daten-Schicht, oder allgemeiner, die Ressourcen.

Aus Sicht der Applikation ist die Daten-Schicht (Data API) und damit auch die Ressource transparent, also herstellerunabhängig. Das ist dem Umstand zu verdanken, dass sich gewisse Standards, wie z.B. JDBC oder ODBC für Datenbanken oder XML für Textdateien etabliert haben.

OData

OData ist das Equivalent für Web-Applikation, d.h. OData ist die Daten API, die beispielsweise über Web-Services den Zugriff auf Ressourcen erlaubt. Anstelle von ODBC, JDBC oder XML, werden die Standards HTML, REST und AtomPub verwendet. Die Data API wird nicht direkt in die Applikation gelinkt, sondern über REST (Representational State Transfer) Webservices mit er Anwendung verbunden. Der Zugriff auf die Ressourcen (Datenbanken, Dateien etc.) erfolgt, wie vorher, über Standards wie ODBC, JDBC etc.

Genau genommen, kommt also zum „konventionellen“ Modell noch eine weitere Abstraktionsschicht hinzu, ich will Sie den „Web-Layer“ nennen. Diese weitere Schicht bietet theoretisch den Vorteil, von „überall“ her, Ressourcen an die eigene Applikation anzubinden – natürlich nur, wenn die Ressourcen mit dem Web verbunden sind und einen entsprechenden Web-Service zur Verfügung stellen. Dieser Web-Service wird im Jargon als OData-Publisher bezeichnet.

Des weiteren wird, aus meiner Sicht, die Applikation von den Ressourcen stärker getrennt. Es wäre beispielsweise denkbar auf die Ressourcen einer „fremden“ Firma zuzugreifen, ohne sie selbst programmieren zu müssen, so wie es bereits Google (Maps etc.) oder andere Hersteller realisiert haben. Es ist dann nicht notwendig, das entsprechende Know-How firmenintern aufzubauen, mit dem Nachteil, dass evtl. Kosten für die Nutzung der Ressourcen erhoben werden.

Request

Der Zugriff auf die OData-Ressourcen erfolgt aus Sicht der Applikation über CRUD-Operationen, also über Create-, Read-, Update-, Delete-Befehle. Diese werden über die HTTP-Operationen GET, POST, PUT und DELETE abgebildet. Parameter werden in der URL abgebildet. Will man beispielsweise in einer fiktiven Datenbank über SQL alle Anwälte ermitteln, die in Aschaffenburg ansässig sind und sich auf Mietrecht spezialisiert haben, dann würde man das in etwa so realisieren:

SELECT * from lawyers where city='Aschaffenburg' and area='rent';

Analog würde man im OData Modell einen REST-Service, z.B. getLawyers über HTTP-GET aufrufen:

http://<url>/Lawyers?city='Aschaffenburg'&area='rent'

Weitere Informationen zum Aufbau der OData URI sind hier zu finden.

Response

Die Rückgabe kann in AtomPub (Atom Publishing Protocol), JSON (JavaScript Object Notation) oder XML (Extensible Markup Langugage) erfolgen.

SDKs

Eine Auswahl an SDKs für OData-Client und -Server steht direkt bei OData.org als Link zur Verfügung.

Security

Wie sieht es mit Security im Zusammenhang mit REST aus? Eine Möglichkeit bietet das Open-Source Protokoll OAuth. Alternativ kann man HTTP-Authentifizierungsmechanismen, OpenID, HMAC etc. verwenden.

 

Links:

OData

Blue Blip

 
Hinterlasse einen Kommentar

Verfasst von - Dezember 20, 2011 in Formate, IT

 

Schlagwörter: , , , , ,

Kontakte von XING nach Google, inklusive Bilder


dp.SyntaxHighlighter.ClipboardSwf = ‚/flash/clipboard.swf‘;dp.SyntaxHighlighter.HighlightAll(‚code‘);Wenn man die Kontakte von XING in das VCARD Format exportiert und diese anschließend in Google importiert, gehen die Bilder der Kontakte „verloren“. Das liegt daran, daß XING nicht die Bilder selbst, sondern nur einen Link auf die Bilder in der VCARD speichert:

XING-VCARD:

...
PHOTO;VALUE=URL;TYPE=JPEG:http://www.xing.com/img/users/1/3/a/58ebb19f7.11990404,2.jpg
...

erwünschte VCARD:

...
PHOTO;TYPE=JPEG;ENCODING=BASE64:
/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9
...

Mit einem Shell-Skript (Bash), kann man den jeweiligen Bilder-Link aufrufen, die Bilder-Datei herunterladen, das Bild kodieren und eine neue VCARD Datei erzeugen, die schließlich das Bild (BASE64-kodiert) enthält.

Hinweis: Dieses Skript ist nicht „auf meinem eigenen Mist“ gewachsen, sondern wurde „geklaut“ von http://superwallah.twoday.net/stories/6377326/

Hier das Skript:

#!/bin/bash
# Copyright 2010 Superwallah, this code is distributed under GPL 3.0
if [ "$1" = "" ] ; then
echo "usage: ./xing2outlook.sh vcards-XING.vcf"
exit
fi
# wget all images
wget -N $(gawk -F";" '/PHOTO/ { print substr($3,11,length($3)-11)}' $1 )
# correct charset settings in XING vcards
sed -e 's/ISO-8859-1/utf-8/g' $1 > neuesvcard_out.vcf
# delete empty address lines
sed -e '/;;;;;;/d' neuesvcard_out.vcf > XING4Outlook.vcf
# convert all pictures into base64
for i in $( ls *.jpeg *.jpg *.gif 2> error.log ); do
base64 --wrap=0 $i > $i.b64
# BASE64 enthält /, daher ! sed-Trennzeichen
sed -e 's!VALUE=URL;TYPE=JPEG:.*'$i'!ENCODING=b;TYPE=JPEG:'$(cat $i.b64)'!g' XING4Outlook.vcf > neuesvcard_out.vcf
cp neuesvcard_out.vcf XING4Outlook.vcf
done
rm neuesvcard_out.vcf
 
Hinterlasse einen Kommentar

Verfasst von - Juni 7, 2011 in IT

 

Schlagwörter: , ,

 
Erstelle eine Website wie diese mit WordPress.com
Jetzt starten