Belajar Menggunakan JSON Processing

Java EE 7 Development with NetBeans 8
David R. Heffelfinger
Copyright © 2015 Packt Publishing
Belajar menggunakan JSON Processing
JSON (singkatan dari JavaScript Object Notation) adalah format pertukaran data yang ringan.
Keunggulan utama JSON dibandingkan format pertukaran data lainnya seperti XML adalah itu JSON
mudah dibaca manusia dan mudah dibuat dan diuraikan oleh komputer. Ini biasanya digunakan di
banyak aplikasi web modern.
Java EE 7 memperkenalkan Java API for JSON Processing (JSON-P), yang merupakan a API Java EE
standar untuk mengurai dan menghasilkan data JSON.
JSON-P menyediakan dua cara untuk mengurai dan menghasilkan data JSON: model objek API dan
API streaming.
Dalam bab ini, kita akan membahas topik-topik berikut:
 API model objek JSON-P:

 Menghasilkan data JSON dengan API model objek JSON-P
 Mem-parsing data JSON dengan API model objek JSON-P
 API streaming JSON-P:
 Menghasilkan data JSON dengan API streaming JSON-P
 Mem-parsing data JSON dengan API streaming JSON-P
JSON-P objek model API
API model JSON-P memungkinkan kita menghasilkan struktur pohon dalam memori representasi
objek JSON. JSON-P API menggunakan pola pembangun, yaitu memungkinkan kita sebagai
pengembang aplikasi untuk dengan mudah membuat representasi JSON dari a objek Jawa.
Menghasilkan data JSON dengan objek JSON-P Model API
Saat menggunakan API model objek JSON-P, biasanya kita mulai dengan memanggil add() metode
implementasi antarmuka JsonObjectBuilder. Metode ini mengembalikan instance implementasi
antarmuka JsonObjectBuilder lainnya. Kita dapat pemanggilan berantai dari JsonObject.add()
bersama-sama, memungkinkan kita membuat JSON dengan mudah representasi dari objek Java.
Contoh berikut mengilustrasikan proses ini:
package com.ensode.jsonpmodelapi;
//imports omitted
@Named
@RequestScoped
public class JsonPModelApiBean {
@Inject
private Person person;
private String jsonStr;
public String generateJson() {

JsonObjectBuilder jsonObjectBuilder =
Json.createObjectBuilder();
JsonObject jsonObject = jsonObjectBuilder.
add("firstName", person.getFirstName()).
add("middleName", person.getMiddleName()).
add("lastName", person.getLastName()).
add("gender", person.getGender()).
add("age", person.getAge()).
build();
StringWriter stringWriter = new StringWriter();
try (JsonWriter jsonWriter = Json.createWriter(stringWriter))
{
jsonWriter.writeObject(jsonObject);
}
setJsonStr(stringWriter.toString());
//JSF Dynamic navigation
return "generated_json";
}
//other methods omitted
}
Ini contoh bagian dari aplikasi JSF, khususnya CDI bernama bean.
Kami hanya menampilkan kode yang relevan dengan diskusi.
Dalam contoh ini, kami membuat representasi JSON dari Person Java sederhana kelas yang berisi
beberapa properti sederhana seperti firstName, middleName, lastName, dan seterusnya,
bersama dengan metode pengambil dan penyetel yang sesuai.
Hal pertama yang kami lakukan dalam contoh kami adalah mendapatkan turunan dari implementasi
kelasantarmuka JsonObjectBuilder dengan mengaktifkan createObjectBuilder() statis metode
pada kelas Json. Metode ini mengembalikan sebuah instance dari implementasi kelas antarmuka
JsonObjectBuilder, yang dapat kita gunakan sebagai titik awal untuk menghasilkan representasi
JSON dari objek Java.
Setelah kami mendapatkan instance JsonObjectBuilder, kami perlu memanggil salah

satunyakelebihan beban add() metode, yang semuanya menerima string sebagai parameter
pertama mereka dan nilai sebagai parameter kedua. Metode ini mengembalikan instance lain dari
JsonObjectBuilder, seperti yang terlihat pada contoh kita. Kita dapat merangkai doa dari add()
metode untuk menghasilkan representasi JSON akhir yang kita butuhkan dengan cepat dan mudah.
Apa yang kita lihat di sini adalah pola pembangun yang sedang beraksi.
Dalam contoh kami, kami menggunakan dua versi metode JsonObjectBuilder.add() , satu
menerima string sebagai parameter kedua dan satu lagi menerima bilangan bulat sebagai parameter
kedua. (Dalam contoh kami, kami meneruskan objek Integer ke this metode. Unboxing Java
menangani konversi parameter kami menjadi primitif int) Ada beberapa versi
JsonObjectBuilder.add() yang kelebihan muatan lainnya. Ini memungkinkan fleksibilitas yang
besar saat membangun representasi JSON dari objek Java melalui API model objek JSON-P. Tabel
berikut menjelaskan semua versi kelebihan muatan JsonObjectBuilder.add(); dalam semua

kasus, parameter pertama sesuai dengan namanya properti JSON pada objek JSON yang dihasilkan,
dan parameter kedua adalah nilai yang sesuai dalam JSON yang dihasilkan.
add method Description

add(String name, BigDecimal This adds a JsonNumber representation of a
value) BigDecimal value to the generated JSON object
add(String name, BigInteger This adds a JsonNumber representation of a
value) BigInteger value to the generated JSON object
This adds either a JsonValue.TRUE or JsonValue.
add(String name, boolean FALSE value to the generated JSON object,
value) depending on the Boolean value passed as a
parameter
add(String name, double This adds a JsonNumber representation of a double
value) value to the generated JSON object
This adds a JsonNumber representation of an int
add(String name, int value)
value to the generated JSON object
add(String name, This adds an array of JSON objects to the generated
JsonArrayBuilder builder) JSON object
add(String name, This adds another JSON object to the generated JSON
JsonObjectBuilder builder) object
add(String name, JsonValue This adds an implementation of the JsonValue
value) interface to the generated JSON object
This adds a JsonNumber representation of a long
add(String name, long value)
value to the generated JSON object
add(String name, String value) This adds a string value to the generated JSON object
Mari kita kembali ke contoh kita. Setelah memanggil rangkaian metode add(), kita memanggil
metode build() pada implementasi JsonObjectBuilder yang dihasilkan. Ini pemanggilan metode
mengembalikan turunan dari kelas yang mengimplementasikan JsonObject.
Setelah kami memiliki implementasi JsonObject, biasanya kami ingin mengonversi ke representasi
stringnya. Untuk mengonversi implementasi JsonObject menjadi JSON string, kita perlu memanggil
metode static createWriter() pada kelas Json, melewati instance baru dari StringWriter sebagai
parameter. Metode ini mengembalikan sebuah contoh kelas yang mengimplementasikan antarmuka
JsonWriter. Sekarang, kita perlu memohon metode writeObject() dari JsonWriter, meneruskan
instance JsonObject kita buat sebelumnya sebagai parameter. Doa metode ini mengisi Objek
StringWriter yang kami gunakan untuk membuat antarmuka JsonWriter kami. Kita bisa
mendapatkan representasi string JSON dari objek kita dengan hanya memanggil toString()
metode objek StringWriter kami.
Teladan kita dalam tindakan

Contoh kami terdiri dari aplikasi web sederhana yang menggunakan JSF untuk mengisi CDI bernama
bean dan menghasilkan string JSON dari bean ini. Markup untuk sederhana kami Halaman JSF yang
mengisi CDI bernama bean adalah sebagai berikut:
<?xml version='1.0' encoding='UTF-8' ?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://xmlns.jcp.org/jsf/html">
<h:head>
<title>Object to JSON With the JSON-P Object Model API</title>
</h:head>
<h:body>
<h:form>
<h:panelGrid columns="2">
<h:outputLabel for="firstName" value="First Name"/>
<h:inputText id="firstName" value="#{person.
firstName}"/>
<h:outputLabel for="middleName" value="Middle Name"/>
<h:inputText id="middleName"
value="#{person.middleName}"/>
<h:outputLabel for="lastName" value="Last Name"/>
<h:inputText id="lastName" value="#{person.
lastName}"/>
<h:outputLabel for="gender" value="Gender"/>
<h:inputText id="gender" value="#{person.gender}"/>
<h:outputLabel for="age" value="Age"/>
<h:inputText id="age" value="#{person.age}"/>
<h:panelGroup/>
<h:commandButton value="Submit"
action="#{jsonPModelApiBean.generateJson()}"/>
</h:panelGrid>
</h:form>
</h:body>
</html>
Seperti yang bisa kita lihat, markup sebelumnya sangat sederhana. Ini terdiri dari formulir dengan
beberapa kolom teks input terikat ke properti di Person CDI bernama bean. Ada juga tombol
perintah yang mentransfer kontrol ke metode generateJson() dari Kelas JsonPModelApiBean telah
kita bahas di bagian sebelumnya.
Berikut adalah kode sumber untuk kacang Orang:
import java.io.Serializable;
import javax.enterprise.context.SessionScoped;
import javax.inject.Named;
@Named
@SessionScoped
public class Person implements Serializable {
private String firstName;
private String middleName;
private String lastName;
private String gender;
private Integer age;
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getMiddleName() {
return middleName;
}
public void setMiddleName(String middleName) {
this.middleName = middleName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
Sekali lagi, tidak ada yang spesial dari kelas Person; itu hanya nama CDI sederhana bean dengan
properti pribadi dan metode penyetel dan pengambil yang sesuai.
Kami dapat menjalankan aplikasi kami seperti biasa dengan mengklik kanan pada proyek dan
memilih Run.
Setelah beberapa detik, browser akan muncul dan merender halaman JSF kita.
Saat kita mengklik tombol Submit, kontrol masuk ke pengontrol yang kita diskusikan di bagian
sebelumnya. Kemudian, kami menavigasi ke halaman JSF yang menampilkan JSON representasi
objek Person.
Berikut markup halaman JSF yang menampilkan string JSON:

<h:head>
<title>Generated JSON with the JSON-P Object Model API</title>
</h:head>
<h:body>
<h:form>
<h:panelGrid columns="2">
<h:outputLabel for="parsedJson" value="Parsed JSON"/>
<h:inputTextarea
value="#{jsonPModelApiBean.jsonStr}" rows="4"/>
<h:panelGroup/>
<h:commandButton value="Submit"
action="#{jsonPModelApiBean.parseJson()}"/>
</h:panelGrid>
</h:form>
</h:body>
</html>
Ini hanya menampilkan area teks yang berisi representasi JSON dari Orang tersebut objek, seperti
yang ditunjukkan pada tangkapan layar berikut:
Perhatikan bagaimana nama properti cocok dengan yang kita gunakan untuk membuat objek JSON
di bagian sebelumnya, dan semua nilai cocok dengan nilai yang kita masukkan pada input halaman
yang baru saja kita bahas. Pada titik ini, kita dapat memodifikasi string JSON yang ditampilkan area
teks (memastikan bahwa itu masih diformat JSON dengan benar). Ketika pengguna klik tombol Kirim,
objek Orang akan diisi ulang dari yang diperbarui rangkaian JSON.
Mem-parsing data JSON dengan objek JSON-P Model API
Sekarang kita tahu cara menghasilkan JSON dari objek Java, mari fokuskan perhatian kita pada fungsi
sebaliknya, mengisi objek Java dari string JSON.
Kode berikut mengilustrasikan cara melakukannya:
//imports omitted
@Named
@RequestScoped
public class JsonPModelApiBean {
@Inject
//body omitted for brevity
}
public String parseJson() {
JsonObject jsonObject;
try (JsonReader jsonReader = Json.createReader(
new StringReader(jsonStr))) {
jsonObject = jsonReader.readObject();
}
person.setFirstName(jsonObject.getString("firstName"));
person.setMiddleName(jsonObject.getString(
"middleName"));
person.setLastName(jsonObject.getString("lastName"));
person.setGender(jsonObject.getString("gender"));
person.setAge(jsonObject.getInt("age"));
return "display_populated_obj";
}
public String getJsonStr() {

return jsonStr;
}
public void setJsonStr(String jsonStr) {
this.jsonStr = jsonStr;
}
}
Hal pertama yang perlu kita lakukan adalah membuat instance baru dari java.io.StringReader
dari string JSON kami. Kami melakukan ini dengan meneruskan string yang berisi data JSON kami ke
konstruktor dari StringReader. Kemudian, kami meneruskan instance StringReader yang
dihasilkan ke metode createReader() statis dari kelas javax.json.Json JSON-P. Metode ini doa
mengembalikan implementasi antarmuka javax.json.JsonReader, yang kemudian kami gunakan
untuk mendapatkan implementasi javax.json.JsonObject.
Objek JSON berisi beberapa metode get yang bisa kita gunakan untuk mendapatkan data dari
rangkaian JSON. Metode ini mengambil nama properti JSON sebagai parameter dan kembali nilai
yang sesuai. Dalam contoh kami, kami menggunakan dua metode ini, yaitu getString() dan
getInt(), dan kami menggunakannya untuk mengisi instance dari Objek Person. Tabel berikut
merangkum semua metode get yang tersedia:
get method Description

This returns the value of the specified property as a
getBoolean(String name)
Boolean.
This returns the value of the specified property as
etInt(String name)
an integer.
This returns the value of the specified property as
getJsonArray(String name)
an array in the form of a JsonArray implementation.
This returns the value of the specified numeric
This returns the value of the
property as a JsonNumber implementation. The
specified property as an array
value can then be converted to int, long, or double
in the form of a JsonArray
by invoking intValue(), longValue(), or
implementation.
doubleValue(), respectively.
getJsonObject(String This returns the value of the specified property as a
name) JsonObject implementation.
his returns the value of the specified property as a
getJsonString(String name)
JsonString implementation.
This returns the value of the specified property as a
getString(String name)
string.
Mari kita kembali ke contoh kita. Anda dapat melihat bahwa metode parseJson() dari kami kelas
pengontrol JsonModelApiBean mengembalikan string display_populated_obj. Oleh karena itu,
berdasarkan konvensi JSF, kita tahu bahwa itu akan mengarah ke halaman JSF bernama
display_populated_obj.xhtml. Markup untuk halaman ini adalah sebagai berikut:

<h:head>
<title>Java Object Properties Populated from JSON</title>
</h:head>
<h:body>
<table>
<tr>
<td>
First Name:
</td>
<td>
#{person.firstName}
</td>
</tr>
<tr>
<td>
Middle Name:
</td>
<td>
#{person.middleName}
</td>
</tr>
<tr>
<td>
Last Name:
</td>
<td>
#{person.lastName}
</td>
</tr>
<tr>
<td>
Gender:
</td>
<td>
#{person.gender}
</td>
</tr>
<tr>
<td>
Age:
</td>
<td>
#{person.age}
</td>
</tr>
</table>
</h:body>
</html>
Seperti yang bisa kita lihat, yang dilakukannya hanyalah menampilkan semua properti objek Person
melalui Unified Bahasa Ekspresi. Properti objek diisi ulang dari string JSON yang ditampilkan di
halaman sebelumnya, yang terikat ke properti jsonStr dari JsonPModelApiBean.
Seperti yang bisa kita lihat, mengisi dan mem-parsing JSON menggunakan API model objek JSON-P
adalah cukup mudah dan intuitif. Ini bekerja dengan baik ketika kita berurusan dengan yang lebih
kecil jumlah data. Namun, mungkin saja mengalami masalah kinerja ketika berhadapan dengan
sejumlah besar data. Dalam kasus seperti itu, kita dapat menggunakan JSON-P's streaming API.
JSON-P streaming API
API streaming JSON-P memungkinkan kita untuk membaca dan menulis data JSON ke dan dari a
stream (subkelas dari java.io.OutputStream atau subkelas dari java.io.Writer). Itu API streaming
JSON-P memiliki kinerja yang lebih baik dan efisiensi memori yang lebih baik daripada API model
objek JSON-P. Namun, peningkatan kinerja dan efisiensi ini datang dengan beberapa keterbatasan.
API streaming JSON-P hanya memungkinkan data JSON dibaca berurutan; kita tidak bisa mengakses
properti JSON secara langsung seperti yang bisa kita lakukan dengan objek Model API. Secara umum,
kita harus menggunakan API streaming jika kita perlu menangani yang besar jumlah data JSON; jika
tidak, API model objek yang lebih sederhana harus digunakan.
Di bagian berikut, kami akan menerapkan kembali contoh dari bagian sebelumnya menggunakan API
streaming JSON-P.
Karena contoh di bagian ini mencerminkan fungsi yang kami diterapkan di

bagian sebelumnya, kami tidak akan menampilkan tangkapan layar apa pun
aplikasi sampel kami beraksi. Mereka akan identik dengan yang kita lihat
sebelumnya di bab ini.
Menghasilkan data JSON dengan JSON-P streaming API
Saat menggunakan API streaming JSON-P, kami menghasilkan data JSON melalui kelas
JsonGenerator, memanggil satu atau lebih dari beberapa write() yang kelebihan beban metode
untuk menambahkan properti JSON dan nilai terkait ke data JSON.
Contoh berikut mengilustrasikan cara menghasilkan data melalui JSON-P streaming API:
package com.ensode.jsonpstreamingapi;
//imports omitted
@Named
@RequestScoped
public class JsonPStreamingApiBean {
@Inject
StringWriter stringWriter = new StringWriter();
try (JsonGenerator jsonGenerator
= Json.createGenerator(stringWriter)) {
jsonGenerator.writeStartObject().
write("firstName", person.getFirstName()).
write("middleName", person.getMiddleName()).
write("lastName", person.getLastName()).
write("gender", person.getGender()).
write("age", person.getAge()).
writeEnd();
}
setJsonStr(stringWriter.toString());
return "generated_json";
}
}
Contoh ini adalah bagian dari aplikasi JSF, khususnya CDI bernama bean, dan
kami hanya menampilkan kode yang relevan dengan diskusi kami.
Untuk menghasilkan data JSON menggunakan API streaming JSON-P, pertama-tama kita perlu
memohon panggilan ke metode Json.createGenerator() statis. Metode ini mengembalikan
sebuah contoh kelas yang mengimplementasikan javax.json.stream.JsonGenerator. Ada dua
versi metode Json.createGenerator() yang kelebihan beban, yang satu membutuhkan instance
java.io.OutputStream (atau salah satu subkelasnya) sebagai parameter dan yang lainnya
mengambil turunan dari java.io.Writer (atau salah satu subkelasnya) sebagai aparameter. Dalam
contoh kami, kami memilih versi kedua, memberikan contoh dari java.io.StringWriter ke
Json.createGenerator().
Setelah kami mendapatkan turunan dari JsonGenerator, kami perlu memanggil metode
writeStartObject() di atasnya. Metode ini menulis karakter objek awal dari JSON (kurung kurawal
pembuka {) ke OutputStream atau Writer yang kami teruskan Json.createGenerator(). Metode
writeStartObject() mengembalikan yang lain instance dari JsonGenerator, memungkinkan kita
untuk segera memanggil fungsi write() metode pada JsonGenerator yang dihasilkan.
Metode write() dari JsonGenerator menambahkan properti JSON ke data JSON kita. Nya
parameter pertama adalah string yang berisi nilai properti, dan parameter keduanya adalah nilai
yang sesuai. Ada beberapa versi kelebihan dari write() metode, satu untuk setiap jenis nilai JSON
yang didukung yang sesuai (baik String atau a tipe numerik seperti BigInteger atau double).
Dalam contoh kami, kami hanya menambahkan properti bertipe String dan Integer, oleh karena itu
kami menggunakan yang sesuai versi dari metode write(). Tabel berikut mencantumkan semua
versi yang ada dari metode write():
write() method Description

Adds a numeric property of type BigDecimal to
write(String name, BigDecimal value)
our JSON data
Adds a numeric property of type BigInteger to our
write(String name, BigInteger value)
JSON data
Adds a property of type JsonValue or one of its
write(String name, JsonValue value) subinterfaces (JsonArray, JsonNumber, JsonObject,
JsonString or JsonStructure) to our JSON data
write(String name, String value) Adds a property of type String to our JSON data
write(String name, boolean value) Adds a boolean property to our JSON data
Adds a numeric property of type double to our
write(String name, double value)
JSON data
Writes a numeric property of type int to our JSON
write(String name, int value)
data
Writes a numeric property of type long to our
write(String name, long value)
JSON data
Setelah kita selesai menambahkan properti ke data JSON kita, kita perlu memohon metode
writeEnd() dari JsonGenerator, yang menambahkan karakter objek akhir JSON (diwakili oleh
kurung kurawal penutup }) ke string JSON kita.
Pada titik ini, Penulis atau OutputStream kami berikan ke Json.createGenerator() berisi objek
JSON lengkap. Apa yang kita lakukan dengan itu tergantung pada aplikasi kita Persyaratan; dalam
contoh kami, kami hanya memanggil metode toString() dari Instance StringWriter kami
menggunakan dan menetapkan nilai pengembaliannya ke variabel jsonStr.
Parsing data JSON dengan JSON-P streaming API
Contoh berikut mengilustrasikan bagaimana kita dapat mengurai data JSON menggunakan JSON-P
streaming API:
package com.ensode.jsonpstreamingapi;
//imports omitted
@Named
@RequestScoped
public class JsonPStreamingApiBean {
@Inject
public String parseJson() {
StringReader stringReader = new StringReader(jsonStr);
JsonParser jsonParser = Json.createParser(stringReader);
Map<String, Object> jsonMap = new HashMap<>();

String jsonKeyNm = null;
Object jsonVal = null;
while (jsonParser.hasNext()) {
JsonParser.Event event = jsonParser.next();
if (event.equals(Event.KEY_NAME)) {
jsonKeyNm = jsonParser.getString();
} else if (event.equals(Event.VALUE_STRING)) {
jsonVal = jsonParser.getString();
} else if (event.equals(Event.VALUE_NUMBER)) {
jsonVal = jsonParser.getInt();
}
jsonMap.put(jsonKeyNm, jsonVal);
}
person.setFirstName((String) jsonMap.get("firstName"));
person.setMiddleName((String) jsonMap.get("middleName"));
person.setLastName((String) jsonMap.get("lastName"));
person.setGender((String) jsonMap.get("gender"));
person.setAge((Integer) jsonMap.get("age"));
return "display_populated_obj";
}
}
Untuk membaca dan mengurai data JSON menggunakan API streaming JSON-P, kita perlu untuk
mendapatkan implementasi antarmuka JsonParser. Kelas Json memiliki dua versi kelebihan dari
metode createParser() yang dapat kita gunakan untuk mendapatkan a implementasi
JsonParser. Satu versi Json.createParser() memerlukan sebuah instance
java.io.InputStream (atau salah satu subkelasnya) sebagai satu-satunya parameter, dan versi
lainnya mengambil turunan dari java.io.Reader (atau salah satu subkelasnya) sebagai satu-
satunya parameternya. Dalam contoh kami, kami menggunakan versi kedua, meneruskan sebuah
instance dari java.io.StringReader (yang memperluas java.io.Reader) yang berisi JSON kami
string sebagai parameter.
Setelah kami mendapatkan referensi ke JsonParser, kami memanggil metode hasNext() di a while
loop. Metode JsonParser.hasNext() mengembalikan true jika ada lebih banyak nama atau nilai
properti untuk dibaca dari string JSON, jika tidak maka akan mengembalikan false.
Di dalam while loop, kita memanggil JsonParser.next(). Metode ini mengembalikan sebuah contoh
enum JsonParser.Event. Nilai spesifik dari JsonParser. Event enum yang kita dapatkan dari
JsonParser.next() memberi tahu kita jenis data apa yang kita miliki sedang membaca (nama kunci,
nilai string, nilai numerik, dan sebagainya). Dalam contoh kita, milik kita String JSON hanya berisi
string dan nilai numerik, jadi kami hanya memeriksa keduanya jenis nilai dengan membandingkan
instance JsonParser.Event yang kami dapatkan dari JsonParser. next() terhadap
Event.VALUE_STRING dan Event.VALUE_NUMBER, masing-masing. Kita periksa juga nama kunci
JSON dengan membandingkan nilai yang diperoleh dengan Event.KEY_NAMA. Setelah kita membaca
kombinasi pasangan kunci/nilai dari string JSON kita, apa kami melakukannya tergantung pada
persyaratan aplikasi kami. Dalam contoh kita, kita sederhana mengisi peta hash menggunakan nilai
yang sesuai dari string JSON kami.
Kami hanya melihat tiga kemungkinan nilai yang dapat kami peroleh saat membaca secara berurutan
Data JSON dengan memanggil JsonParser.next(). Tabel berikut mencantumkan semua kemungkinan
nilai:
Event enum Value Description

Event.START_OBJECT Indicates the beginning of a JSON object
Event.END_OBJECT Indicates the end of a JSON object
Event.KEY_NAME Indicates the name of a JSON property
Event.VALUE_STRING Indicates a String value was read
Event.VALUE_NUMBER Indicates a numeric value was read
Event.VALUE_TRUE Indicates a Boolean true value was read
Event.VALUE_FALSE Indicates a Boolean false value was read
Event.VALUE_NULL Indicates that a null value was read
Event.VALUE_START_ARRAY Indicates that the start of an array was read
EVENT.VALUE_END_ARRAY Indicates that the end of an array was read
Selesai.....

Belajar Menggunakan JSON Processing

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Belajar Menggunakan JSON Processing

Uploaded by

Copyright:

Available Formats

Java EE 7 Development with NetBeans 8

Belajar menggunakan JSON Processing

Dalam bab ini, kita akan membahas topik-topik berikut:

 API model objek JSON-P:

JSON-P objek model API

Menghasilkan data JSON dengan objek JSON-P Model API

public String generateJson() {

Setelah kami mendapatkan instance JsonObjectBuilder, kami perlu memanggil salah

berikut menjelaskan semua versi kelebihan muatan JsonObjectBuilder.add(); dalam semua

add method Description

Teladan kita dalam tindakan

<?xml version='1.0' encoding='UTF-8' ?>

Berikut adalah kode sumber untuk kacang Orang:

Berikut markup halaman JSF yang menampilkan string JSON:

<?xml version='1.0' encoding='UTF-8' ?>

Mem-parsing data JSON dengan objek JSON-P Model API

Kode berikut mengilustrasikan cara melakukannya:

public String getJsonStr() {

get method Description

<?xml version='1.0' encoding='UTF-8' ?>

JSON-P streaming API

Karena contoh di bagian ini mencerminkan fungsi yang kami diterapkan di

Menghasilkan data JSON dengan JSON-P streaming API

write() method Description

Parsing data JSON dengan JSON-P streaming API

JsonParser jsonParser = Json.createParser(stringReader);

Map<String, Object> jsonMap = new HashMap<>();

Event enum Value Description

You might also like