Introduktion till JSON-Java (org.json)

1. Introduktion till JSON-Java

JSON (en förkortning för JavaScript Object Notation) är ett lättformat datautbytesformat och används oftast för klient-serverkommunikation. Det är både lätt att läsa / skriva och språkoberoende. Ett JSON-värde kan vara ett annat JSON- objekt, array, nummer, sträng, boolean (true / false) eller null.

I den här handledningen ser vi hur vi kan skapa, manipulera och analysera JSON med hjälp av ett av de tillgängliga JSON-behandlingsbiblioteken, dvs. JSON-Java-biblioteket kallas också org.json.

2. Förutsättning

Innan vi börjar måste vi lägga till följande beroende i vår pom.xml :

 org.json json 20180130 

Den senaste versionen finns i Maven Central-arkivet.

Observera att detta paket redan har inkluderats i Android SDK, så vi bör inte inkludera det när vi använder detsamma.

3. JSON i Java [paket org.json]

JSON-Java-biblioteket är också känt som org.json (inte förväxlas med Googles org.json.simple) ger oss klasser som används för att analysera och manipulera JSON i Java.

Dessutom kan detta bibliotek också konvertera mellan JSON, XML, HTTP-rubriker, kakor, kommaavgränsad lista eller text, etc.

I den här handledningen tittar vi på:

  1. JSONObject - liknar Java: s ursprungliga kartliknande objekt som lagrar oordnade nyckel-värdepar
  2. JSONArray - en ordnad sekvens av värden som liknar Java: s ursprungliga Vector-implementering
  3. JSONTokener - ett verktyg som delar upp en bit text i en serie tokens som kan användas av JSONObject eller JSONArray för att analysera JSON-strängar
  4. CDL - ett verktyg som ger metoder för att konvertera kommaseparerad text till en JSONArray och vice versa
  5. Cookie - konverterar från JSON String till cookies och vice versa
  6. HTTP - används för att konvertera från JSON- sträng till HTTP-rubriker och vice versa
  7. JSONException - detta är ett standardundantag som kastas av detta bibliotek

4. JSONObject

Ett JSONObject är en oordnad samling av nyckel- och värdepar, som liknar Java: s ursprungliga kartimplementeringar .

  • Nycklar är unika strängar som inte kan vara noll
  • Värden kan vara allt från ett booleskt , nummer , sträng , JSONArray eller till och med ett JSONObject.NULL- objekt
  • Ett JSONObject kan representeras av en sträng som är innesluten i lockiga hakparenteser med nycklar och värden åtskilda av ett kolon och par åtskilda av ett kommatecken
  • Den har flera konstruktörer för att konstruera ett JSONObject

Det stöder också följande huvudmetoder:

  1. get (String key) - hämtar objektet som är associerat med den medföljande nyckeln, kastar JSONException om nyckeln inte hittas
  2. opt (String key) - hämtar objektet som är associerat med den medföljande nyckeln, annars annars noll
  3. put (String key, Object value) - infogar eller ersätter ett nyckel-värdepar i nuvarande JSONObject.

Den put () metoden är en överbelastad metod som accepterar en nyckel av typen String och multipla typer för värdet.

För den fullständiga listan över metoder som stöds av JSONObject , besök den officiella dokumentationen.

Låt oss nu diskutera några av de viktigaste operationerna som stöds av denna klass.

4.1. Skapa JSON direkt från JSONObject

JSONObject exponerar ett API som liknar Java: s Map- gränssnitt . Vi kan använda put () -metoden och ange nyckeln och värdet som ett argument:

JSONObject jo = new JSONObject(); jo.put("name", "jon doe"); jo.put("age", "22"); jo.put("city", "chicago");

Nu skulle vårt JSONObject se ut:

{"city":"chicago","name":"jon doe","age":"22"}

Det finns sju olika överbelastade signaturer av JSONObject.put () -metoden. Medan nyckeln bara kan vara unik, icke-nollsträng , kan värdet vara vad som helst.

4.2. Skapa JSON från Map

Istället för att direkt ange nyckel och värden i ett JSONObject kan vi konstruera en anpassad karta och sedan skicka den som ett argument till JSONObject- konstruktören.

Detta exempel ger samma resultat som ovan:

Map map = new HashMap(); map.put("name", "jon doe"); map.put("age", "22"); map.put("city", "chicago"); JSONObject jo = new JSONObject(map);

4.3. Skapa JSONObject från JSON- sträng

För att analysera en JSON- sträng till en JSONObject kan vi bara skicka strängen till konstruktören.

Detta exempel ger samma resultat som ovan:

JSONObject jo = new JSONObject( "{\"city\":\"chicago\",\"name\":\"jon doe\",\"age\":\"22\"}" );

Det godkända strängargumentet måste vara en giltig JSON, annars kan den här konstruktören kasta en JSONException .

4.4. Serialisera Java-objekt till JSON

En av JSONObject- konstruktörerna tar en POJO som argument. I exemplet nedan använder paketet getters från DemoBean- klassen och skapar ett lämpligt JSONObject för detsamma.

För att få en JSONObject från ett Java-objekt måste vi använda en klass som är en giltig Java Bean:

DemoBean demo = new DemoBean(); demo.setId(1); demo.setName("lorem ipsum"); demo.setActive(true); JSONObject jo = new JSONObject(demo);

Den JSONObject jo för detta exempel kommer att bli:

{"name":"lorem ipsum","active":true,"id":1}

Även om vi har ett sätt att serieera ett Java-objekt till JSON-sträng, finns det inget sätt att konvertera tillbaka det med det här biblioteket.

Om vi ​​vill ha den typen av flexibilitet kan vi byta till andra bibliotek som Jackson.

5. JSONArray

En JSONArray är en ordnad samling värden som liknar Java: s ursprungliga Vector- implementering.

  • Values can be anything from a Number, String, Boolean, JSONArray, JSONObject or even a JSONObject.NULL object
  • It's represented by a String wrapped within Square Brackets and consists of a collection of values separated by commas
  • Like JSONObject, it has a constructor that accepts a source String and parses it to construct a JSONArray

The following are the primary methods of the JSONArray class:

  1. get(int index) – returns the value at the specified index(between 0 and total length – 1), otherwise throws a JSONException
  2. opt(int index) – returns the value associated with an index (between 0 and total length – 1). If there's no value at that index, then a null is returned
  3. put(Object value) – append an object value to this JSONArray. This method is overloaded and supports a wide range of data types

For a complete list of methods supported by JSONArray, visit the official documentation.

5.1. Creating JSONArray

Once we've initialized a JSONArray object, we can simply add and retrieve elements using the put() and get() methods:

JSONArray ja = new JSONArray(); ja.put(Boolean.TRUE); ja.put("lorem ipsum"); JSONObject jo = new JSONObject(); jo.put("name", "jon doe"); jo.put("age", "22"); jo.put("city", "chicago"); ja.put(jo);

Following would be contents of our JSONArray(code is formatted for clarity):

[ true, "lorem ipsum", { "city": "chicago", "name": "jon doe", "age": "22" } ]

5.2. Creating JSONArray Directly from JSON String

Like JSONObject the JSONArray also has a constructor that creates a Java object directly from a JSON String:

JSONArray ja = new JSONArray("[true, \"lorem ipsum\", 215]");

This constructor may throw a JSONException if the source String isn't a valid JSON String.

5.3. Creating JSONArray Directly from a Collection or an Array

The constructor of JSONArray also supports collection and array objects as arguments.

We simply pass them as an argument to the constructor and it will return a JSONArray object:

List list = new ArrayList(); list.add("California"); list.add("Texas"); list.add("Hawaii"); list.add("Alaska"); JSONArray ja = new JSONArray(list);

Now our JSONArray consists of:

["California","Texas","Hawaii","Alaska"]

6. JSONTokener

A JSONTokener takes a source String as input to its constructor and extracts characters and tokens from it. It's used internally by classes of this package (like JSONObject, JSONArray) to parse JSON Strings.

There may not be many situations where we'll directly use this class as the same functionality can be achieved using other simpler methods (like string.toCharArray()):

JSONTokener jt = new JSONTokener("lorem"); while(jt.more()) { Log.info(jt.next()); }

Now we can access a JSONTokener like an iterator, using the more() method to check if there are any remaining elements and next() to access the next element.

The tokens received from the previous example will be:

l o r e m

7. CDL

We're provided with a CDL (Comma Delimited List) class to convert comma delimited text into a JSONArray and vice versa.

7.1. Producing JSONArray Directly from Comma Delimited Text

In order to produce a JSONArray directly from the comma-delimited text, we can use the static method rowToJSONArray() which accepts a JSONTokener:

JSONArray ja = CDL.rowToJSONArray(new JSONTokener("England, USA, Canada"));

Our JSONArray now consists of:

["England","USA","Canada"]

7.2. Producing Comma Delimited Text from JSONArray

In order to reverse of the previous step and get back the comma-delimited text from JSONArray, we can use:

JSONArray ja = new JSONArray("[\"England\",\"USA\",\"Canada\"]"); String cdt = CDL.rowToString(ja);

The Stringcdt now contains:

England,USA,Canada

7.3. Producing JSONArray of JSONObjects Using Comma Delimited Text

To produce a JSONArray of JSONObjects, we'll use a text String containing both headers and data separated by commas.

The different lines are separated using a carriage return (\r) or line feed (\n).

The first line is interpreted as a list of headers and all the subsequent lines are treated as data:

String string = "name, city, age \n" + "john, chicago, 22 \n" + "gary, florida, 35 \n" + "sal, vegas, 18"; JSONArray result = CDL.toJSONArray(string);

The object JSONArray result now consists of (output formatted for the sake of clarity):

[ { "name": "john", "city": "chicago", "age": "22" }, { "name": "gary", "city": "florida", "age": "35" }, { "name": "sal", "city": "vegas", "age": "18" } ]

Notice that in this example, both data and header were supplied within the same String.There's an alternative way of doing this where we can achieve the same functionality by supplying a JSONArray that would be used to get the headers and a comma-delimited String working as the data.

Different lines are separated using a carriage return (\r) or line feed (\n):

JSONArray ja = new JSONArray(); ja.put("name"); ja.put("city"); ja.put("age"); String string = "john, chicago, 22 \n" + "gary, florida, 35 \n" + "sal, vegas, 18"; JSONArray result = CDL.toJSONArray(ja, string);

Here we'll get the contents of object result exactly as before.

8. Cookie

The Cookie class deals with web browser cookies and has methods to convert a browser cookie into a JSONObject and vice versa.

Here are the main methods of the Cookie class:

  1. toJsonObject(String sourceCookie) – converts a cookie string into a JSONObject

  2. toString(JSONObject jo) – this is reverse of the previous method, converts a JSONObject into a cookie String.

8.1. Converting a Cookie String into a JSONObject

To convert a cookie String to a JSONObject, well use the static method Cookie.toJSONObject():

String cookie = "username=John Doe; expires=Thu, 18 Dec 2013 12:00:00 UTC; path=/"; JSONObject cookieJO = Cookie.toJSONObject(cookie);

8.2. Converting a JSONObject into Cookie String

Now we'll convert a JSONObject into cookie String. This is reverse of the previous step:

String cookie = Cookie.toString(cookieJO);

9. HTTP

The HTTP class contains static methods that are used to convert HTTP headers to JSONObject and vice versa.

This class also has two main methods:

  1. toJsonObject(String sourceHttpHeader) – converts a HttpHeader String to JSONObject
  2. toString(JSONObject jo) – converts the supplied JSONObject to String

9.1. Converting JSONObject to HTTP Header

HTTP.toString() method is used to convert a JSONObject to HTTP header String:

JSONObject jo = new JSONObject(); jo.put("Method", "POST"); jo.put("Request-URI", "//www.example.com/"); jo.put("HTTP-Version", "HTTP/1.1"); String httpStr = HTTP.toString(jo);

Here, our String httpStr will consist of:

POST "//www.example.com/" HTTP/1.1

Note that while converting an HTTP request header, the JSONObject must contain “Method”,“Request-URI” and “HTTP-Version” keys, whereas, for response header, the object must contain “HTTP-Version”,“Status-Code” and “Reason-Phrase” parameters.

9.2. Converting HTTP Header String Back to JSONObject

Here we will convert the HTTP string that we got in the previous step back to the very JSONObject that we created in that step:

JSONObject obj = HTTP.toJSONObject("POST \"//www.example.com/\" HTTP/1.1");

10. JSONException

The JSONException is the standard exception thrown by this package whenever any error is encountered.

Detta används i alla klasser från detta paket. Undantaget följs vanligtvis av ett meddelande som anger vad som exakt gick fel.

11. Slutsats

I den här handledningen tittade vi på en JSON med Java - org.json - och vi fokuserade på några av de kärnfunktioner som finns här.

De fullständiga kodavsnitten som används i den här artikeln finns på GitHub.