1. JSON-Grundformat:
Es gibt viele hervorragende Einführungen im Blog-JSON-Format. Die Einführung des folgenden Blogs ist meiner Meinung nach relativ vollständig:
Portal: JSON-Basisdatenformat
2. Einführung in den JSON-Parser:
JSON-Parser bestehen im Allgemeinen aus zwei Hauptfunktionen: 解析和生成. Die Parsing-Funktion analysiert eine JSON-Zeichenfolge in eine speicherinterne Datenstruktur, typischerweise ein Objekt, ein Array oder eine Sammlung von Schlüssel-Wert-Paaren. Die Funktion „Generieren“ konvertiert die In-Memory-Datenstruktur in einen JSON-String.
Viele Programmiersprachen bieten integrierte JSON-Parser und -Generatoren, die problemlos mit JSON-Daten umgehen können. Beispielsweise wird die Funktion JSON.parse() in JavaScript verwendet, um einen JSON-String zu analysieren und in ein JavaScript-Objekt zu konvertieren; die Funktion JSON.stringify() wird verwendet, um ein JavaScript-Objekt in einen JSON-String zu konvertieren. Auch andere Programmiersprachen wie Python, Java, C# usw. bieten ähnliche Funktionen.
Mithilfe des JSON-Parsers können Sie Daten zwischen verschiedenen Anwendungen, insbesondere für Webanwendungen und , einfach übertragen und verarbeiten 客户端-服务器通信. Unabhängig davon, ob Sie JSON-Daten aus dem Web empfangen oder Daten an einen Remote-Server senden, ist ein JSON-Parser ein unverzichtbares Werkzeug.
3. Häufig verwendete JSON-Parser:
1. Jackson:
Jackson ist eine sehr beliebte JSON-Verarbeitungsbibliothek, die leistungsstarke und flexible JSON-Analyse- und Generierungsfunktionen bietet. Es kann JSON-Daten in Java-Objekte abbilden und Java-Objekte in das JSON-Format konvertieren. Jackson unterstützt auch Annotationen, mit denen sich die Zuordnungsbeziehung zwischen JSON- und Java-Objekten weiter steuern lässt.
首先，您需要在您的Java项目中添加Jackson库的依赖。如果使用Maven进行项目管理，
可以在pom.xml文件中添加以下依赖项：
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.12.3</version>
</dependency>
接下来，假设您有一个JSON字符串如下：
{
"name": "John Doe",
"age": 30,
"email": "[email protected]"
}
现在，让我们看一下如何使用Jackson将该JSON字符串解析为Java对象，并将Java对象转换回JSON字符串：
import com.fasterxml.jackson.databind.ObjectMapper;
public class JsonExample {
public static void main(String[] args) {
String json = "{\"name\":\"John Doe\",\"age\":30,\"email\":\"[email protected]\"}";
try {
// 创建ObjectMapper对象
ObjectMapper objectMapper = new ObjectMapper();
// 解析JSON字符串为Java对象
Person person = objectMapper.readValue(json, Person.class);
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
System.out.println("Email: " + person.getEmail());
// 将Java对象转换为JSON字符串
String jsonString = objectMapper.writeValueAsString(person);
System.out.println("JSON: " + jsonString);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Person {
private String name;
private int age;
private String email;
// 必须有无参数的构造函数
public Person() {
}
// getters 和 setters
// name getter 和 setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// age getter 和 setter
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// email getter 和 setter
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
在上面的示例中，我们首先创建了一个ObjectMapper对象，它是Jackson库中用于解析和生成JSON的主要类。
然后，我们使用readValue()方法将JSON字符串解析为Person类的对象，
并使用writeValueAsString()方法将Person对象转换回JSON字符串。
请注意，Person类必须具有无参数的构造函数，并为每个属性提供相应的getter和setter方法，
以便Jackson可以正确地进行对象与JSON之间的映射。
以上是一个简单的示例，使用Jackson库进行JSON解析和生成的基本功能。
根据需要扩展和修改该示例以满足具体的业务逻辑。
2. Sohn:
Gson ist eine einfache und leistungsstarke JSON-Parsing-Bibliothek von Google. Es kann JSON-Strings in Java-Objekte analysieren und Java-Objekte in JSON-Strings konvertieren. Gson bietet viele praktische APIs und Anmerkungen zum Konfigurieren der Details des Parsing- und Generierungsprozesses.
首先，您需要在您的Java项目中添加Gson库的依赖。如果使用Maven进行项目管理，
可以在pom.xml文件中添加以下依赖项：
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.9</version>
</dependency>
接下来，假设您有一个JSON字符串如下：
{
"name": "John Doe",
"age": 30,
"email": "[email protected]"
}
现在，让我们看一下如何使用Gson将该JSON字符串解析为Java对象，并将Java对象转换回JSON字符串：
import com.google.gson.Gson;
public class JsonExample {
public static void main(String[] args) {
String json = "{\"name\":\"John Doe\",\"age\":30,\"email\":\"[email protected]\"}";
try {
// 创建Gson对象
Gson gson = new Gson();
// 解析JSON字符串为Java对象
Person person = gson.fromJson(json, Person.class);
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
System.out.println("Email: " + person.getEmail());
// 将Java对象转换为JSON字符串
String jsonString = gson.toJson(person);
System.out.println("JSON: " + jsonString);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Person {
private String name;
private int age;
private String email;
// 必须有无参数的构造函数
public Person() {
}
// getters 和 setters
// name getter 和 setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// age getter 和 setter
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// email getter 和 setter
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
在上面的示例中，我们首先创建了一个Gson对象，它是Gson库中用于解析和生成JSON的主要类。
然后，我们使用fromJson()方法将JSON字符串解析为Person类的对象，并使用toJson()方法
将Person对象转换回JSON字符串。
3. JSON-B:
JSON-B (JSON-Bindung) ist Teil von Java EE 8, das eine Standard-API für JSON-Analyse und -Generierung bereitstellt. JSON-B bietet Anmerkungen und Konfigurationsoptionen zur Steuerung der Zuordnung zwischen JSON- und Java-Objekten. JSON-B kann nahtlos in die Standardannotationen von Java und das JAX-RS-Framework (Java API for RESTful Web Services) integriert werden.
4. org.json:
org.json ist ein einfacher JSON-Parser und -Generator, der von Java bereitgestellt wird. Es ist in der Java-Standardbibliothek enthalten und bietet grundlegende Funktionen zum Parsen und Generieren von JSON-Daten. Obwohl die Funktionalität relativ einfach ist, handelt es sich um eine leichte und benutzerfreundliche Wahl für die einfache JSON-Manipulation.
在Java标准库中的org.json包中，可以使用JSONObject和JSONArray类来解析和生成JSON数据。
以下是一个使用org.json实现JSON解析和生成的示例代码：
import org.json.JSONArray;
import org.json.JSONObject;
public class JsonExample {
public static void main(String[] args) {
String json = "{\"name\":\"John Doe\",\"age\":30,\"email\":\"[email protected]\"}";
try {
// 解析JSON字符串
JSONObject jsonObject = new JSONObject(json);
String name = jsonObject.getString("name");
int age = jsonObject.getInt("age");
String email = jsonObject.getString("email");
System.out.println("Name: " + name);
System.out.println("Age: " + age);
System.out.println("Email: " + email);
// 生成JSON字符串
JSONObject newJsonObject = new JSONObject();
newJsonObject.put("name", "Jane Smith");
newJsonObject.put("age", 25);
newJsonObject.put("email", "[email protected]");
String newJsonString = newJsonObject.toString();
System.out.println("JSON: " + newJsonString);
} catch (Exception e) {
e.printStackTrace();
}
}
}
这是一个简单的示例，展示了使用org.json进行JSON解析和生成的基本功能。
尽管功能相对简单，但对于简单的JSON操作，org.json是一个轻量级且易于使用的选择。
如果需求更加复杂，可能需要考虑使用其他功能更强大的JSON库，如Jackson或Gson。
Zusammenfassen
- Folge
- 1. Erstellen Sie ein ObjectMapper-Objekt
- 2. Rufen Sie die ObjectMapper-
readValueMethode auf, um die JSON-Zeichenfolge als Java-Objekt zu realisieren - 3. Rufen Sie die ObjectMapper-
writeValueAsStringMethode auf, um das Java-Objekt in einen JSON-String zu konvertieren
- Gson
- 1. Erstellen Sie ein Gson-Objekt
- 2. Rufen Sie
fromJsondie Methode von gson auf, um die JSON-Zeichenfolge als Java-Objekt zu realisieren - 3. Rufen Sie die Methode von gson auf
toJson, um die Konvertierung von Java-Objekten in JSON-Strings zu realisieren
Ein einfacher JSON-Parser und -Generator, bereitgestellt von org.json Java. Es ist in der Java-Standardbibliothek enthalten und bietet grundlegende Funktionen zum Parsen und Generieren von JSON-Daten. Es kann nur JSON-Strings analysieren und generieren, aber keine Konvertierung zwischen Java-Objekten.
Jeder Parser hat seine Eigenschaften und anwendbaren Szenarien. Sie können je nach Projektanforderungen und persönlichen Vorlieben einen geeigneten JSON-Parser auswählen.
Springboot integrierte JSON-Ergänzung
Im Springboot-Framework ist es nicht erforderlich, Objekte und JSON manuell zu analysieren, zu generieren und zu konvertieren. Springboot hat uns durch Anmerkungen bei der Integration geholfen.
Fügen Sie als Nächstes die Annotation @ResponseBody zu der mit @RestController annotierten Klasse hinzu und 或verwenden Sie die Annotation @ResponseBody für die spezifische Methode, um Spring explizit anzuweisen, 返回的Java对象automatisch in JSON zu konvertieren.
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
//@ResponseBody
public class MyController {
@GetMapping("/example")
@ResponseBody
public MyObject getExample() {
// 返回的MyObject会自动转换为JSON
return new MyObject();
}
}
Im Folgenden wird die Annotation @RequestBody für den Methodenparameter verwendet. Spring Boot 接收到的JSON数据konvertiert ihn automatisch in ein Personenobjekt und übergibt es als Parameter der Methode.
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MyController {
@PostMapping("/person")
public Person createPerson(@RequestBody Person person) {
// 在这里可以对person对象进行业务逻辑处理
return person;
}
}