JSON เป็น Java

แปลง JSON เป็น Java POJO, DTO หรือ model class ได้อย่างรวดเร็ว แล้วนำโค้ดที่สร้างเสร็จไปใช้ใน IDE ได้ทันที ทุกอย่างทำงานในเบราว์เซอร์แบบโลคัล

คำแนะนำที่เกี่ยวข้อง

เครื่องมือ JSON เป็น Java ใช้ทำอะไร?

เครื่องมือ JSON เป็น Java จะวิเคราะห์โครงสร้าง JSON แล้วแปลงให้เป็นคลาส Java POJO มาตรฐานโดยอัตโนมัติ คุณจึงไม่ต้องเขียน package, import, field แบบ private, getter หรือ setter ซ้ำๆ ด้วยตัวเอง

สิ่งนี้มีประโยชน์มากใน Spring Boot, Android, MyBatis และการเชื่อมต่อ API ภายนอก เมื่อคุณต้องแปลงตัวอย่าง JSON ให้เป็น Java model ที่นำไปใช้ได้ทันที Object ที่ซ้อนกันจะถูกแยกเป็นคลาสย่อย และ array จะถูกตีความเป็น `List<T>`

เครื่องมือของ GeekFormat รองรับ Gson, Jackson, Fastjson, Lombok, Serializable, Builder, กลยุทธ์การตั้งชื่อฟิลด์ และการดาวน์โหลด ZIP โค้ดที่ได้สามารถนำเข้าโปรเจกต์ได้ทันที

กรณีการใช้งาน

  • แปลง JSON ตัวอย่างจาก Spring Boot API เป็น DTO และ VO
  • สร้าง JavaBean สำหรับ Android หรือ Java client จาก API response
  • สร้าง Jackson / Gson model อย่างรวดเร็วเพื่อเชื่อมต่อบริการภายนอก
  • ใช้ Lombok เพื่อให้ POJO สั้นลงและลดโค้ดซ้ำ
  • แยก JSON ที่ซ้อนกันซับซ้อนให้เป็นคลาส Java ที่อ่านง่ายขึ้น
  • ดาวน์โหลดทุกคลาสเป็น ZIP แล้วนำเข้า IDE

วิธีการใช้งาน

  1. วาง JSON ที่ด้านซ้าย โหลดตัวอย่าง หรืออัปโหลดไฟล์ `.json` / `.txt`
  2. ใน Settings กำหนดชื่อคลาสหลัก, package, ไลบรารี annotation, กลยุทธ์ตั้งชื่อ และตัวเลือก Lombok / Serializable
  3. รอการสร้างอัตโนมัติหรือกด Convert เพื่อดูรายการคลาส Java ทางด้านขวา
  4. คัดลอกคลาสที่ต้องการหรือดาวน์โหลดทั้งหมดผ่าน Download ZIP

คุณสมบัติ

  • รองรับหลายไลบรารี annotation: Gson, Jackson, Fastjson และ Lombok
  • ย่อโค้ดด้วย Lombok: เปิด `@Data`, `@Builder` และ constructor เพื่อลด boilerplate ได้
  • ตั้งกลยุทธ์ชื่อฟิลด์: คงชื่อเดิมหรือแปลง snake_case เป็น camelCase
  • สร้าง nested class อัตโนมัติ: object ที่ซ้อนใน JSON จะกลายเป็นคลาส Java แยกต่างหาก
  • แปลง array เป็น List<T>: ระบบเดาประเภทสมาชิกของ array ให้อัตโนมัติ
  • เลือกสร้างโค้ดเสริมได้: `toString`, `equals`, `hashCode`, Serializable และ constructor
  • ดาวน์โหลดหลายไฟล์เป็น ZIP: เก็บไฟล์ `.java` หลายคลาสพร้อมโครงสร้าง package ได้ในครั้งเดียว
  • ประมวลผลในเบราว์เซอร์: การ parse JSON, สร้างโค้ด และ ZIP ทำในเครื่องทั้งหมด

ตัวอย่างโค้ด

ตัวอย่างเดาประเภท Java จากค่า JSON ด้วย JavaScript

javascript
function toJavaFieldType(value) {
  if (value === null) return 'Object';
  if (Array.isArray(value)) return 'List<Object>';
  if (typeof value === 'number') return Number.isInteger(value) ? 'Integer' : 'Double';
  if (typeof value === 'boolean') return 'Boolean';
  if (typeof value === 'string') return 'String';
  if (typeof value === 'object') return 'NestedType';
  return 'Object';
}

console.log(toJavaFieldType({ id: 1 }.id));
// => Integer

ตัวอย่างสร้าง field Java จาก JSON ด้วย Python

python
import json

def java_type(value):
    if value is None:
        return 'Object'
    if isinstance(value, bool):
        return 'Boolean'
    if isinstance(value, int):
        return 'Integer'
    if isinstance(value, float):
        return 'Double'
    if isinstance(value, str):
        return 'String'
    if isinstance(value, list):
        return 'List<Object>'
    if isinstance(value, dict):
        return 'NestedType'
    return 'Object'

sample = json.loads('{"name":"Alice","age":18}')
for key, value in sample.items():
    print(f'private {java_type(value)} {key};')

ตัวอย่าง Lombok POJO หลังการสร้างโค้ด

java
import lombok.Data;
import lombok.Builder;

@Data
@Builder
public class User {
    private Integer id;
    private String name;
}

คำถามที่พบบ่อย

จะแปลง JSON เป็น Java POJO ได้อย่างไร?

วาง JSON ในแผงด้านซ้าย จากนั้นเครื่องมือจะสร้างคลาส Java ให้อัตโนมัติหรือเมื่อกด Convert แล้ว คุณสามารถคัดลอกทีละคลาสหรือดาวน์โหลดทั้งหมดเป็น ZIP ได้

รองรับ annotation อะไรบ้าง?

รองรับ `@SerializedName` ของ Gson, `@JsonProperty` ของ Jackson, `@JSONField` ของ Fastjson และ annotation ของ Lombok เช่น `@Data` กับ `@Builder`

object JSON ที่ซ้อนกันถูกจัดการอย่างไร?

แต่ละ object ที่ซ้อนกันจะถูกสร้างเป็นคลาส Java แยก และคลาสแม่จะมี field ที่อ้างอิงไปยังประเภทนั้น ทำให้โครงสร้างลึกๆ เข้าใจง่ายขึ้น

array จะกลายเป็น List<T> อัตโนมัติหรือไม่?

ใช่ array ของ string จะกลายเป็น `List<String>` ส่วน array ของ object อาจกลายเป็น `List<User>` และถ้าเป็น array ว่าง ระบบมักใช้ `List<Object>`

แปลง snake_case เป็น camelCase ได้หรือไม่?

ได้ เมื่อเลือกกลยุทธ์ camelCase เช่น `user_name` จะกลายเป็น `userName` โดยยังคงชื่อ key เดิมไว้ใน annotation ได้หากต้องการ

โค้ดในโหมด Lombok มีหน้าตาอย่างไร?

เมื่อเปิด Lombok เครื่องมือจะสร้างคลาสแบบสั้นลงด้วย `@Data`, `@Builder`, `@NoArgsConstructor`, `@AllArgsConstructor` แทนการเขียน getter และ setter เอง

ผลลัพธ์ใช้กับ Spring Boot ได้หรือไม่?

ได้ หากเลือก Jackson หรือ Lombok คลาสที่สร้างขึ้นจะเหมาะกับการใช้เป็น DTO, request/response model และ bean มาตรฐานใน Spring Boot

JSON ของฉันถูกอัปโหลดไปยังเซิร์ฟเวอร์หรือไม่?

ไม่ ทุกขั้นตอนทำงานในเบราว์เซอร์แบบโลคัล จึงใช้งานกับ JSON ภายในหรือข้อมูลที่ละเอียดอ่อนได้สบายขึ้น

การแก้ไขปัญหา

พบข้อผิดพลาด Invalid JSON

ให้ตรวจ syntax ของ JSON ก่อน เช่น comma เกิน, single quote หรือ key ที่ไม่มี quote สามารถแก้เบื้องต้นได้ด้วย JSON Repair

ประเภทของ array ไม่ตรงกับที่คาดไว้

array ว่างหรือ array ที่มีหลายประเภทปนกันมักถูกตีเป็น `List<Object>` ถ้าต้องการผลที่แม่นขึ้นควรใส่สมาชิกตัวแทนไว้ตัวแรก

ชื่อ field ยังเป็น snake_case อยู่

อาจเป็นเพราะใน Settings ยังเลือกกลยุทธ์ `asis` อยู่ ให้เปลี่ยนเป็น camelCase แล้วสร้างใหม่

IDE ไม่รู้จักโค้ด Lombok

ต้องเพิ่ม dependency ของ Lombok ในโปรเจกต์ และเปิด annotation processing หรือ plugin Lombok ใน IDE

JSON ขนาดใหญ่ทำให้เกิดคลาสจำนวนมากเกินไป

สำหรับโครงสร้างที่ใหญ่มาก ควรแบ่ง JSON ออกเป็นส่วนๆ แล้วสร้างทีละชุด และอาจใช้ root model หลายตัวตามความเหมาะสม

อภิธานศัพท์

POJO
Plain Old Java Object หรือ object Java ทั่วไปที่ไม่ผูกติดกับ framework มากนัก มักใช้เป็น model ของข้อมูล JSON
JavaBean
รูปแบบคลาส Java แบบดั้งเดิมที่มี field แบบ private, getter/setter และมักมี constructor ว่าง
DTO
Data Transfer Object ใช้เป็นคลาสสำหรับส่งข้อมูลระหว่าง layer, service หรือ API
Lombok
ไลบรารี Java ที่ช่วยสร้าง getter, setter, builder และ boilerplate อื่นๆ ผ่าน annotation
@JsonProperty
annotation ของ Jackson สำหรับแมป key JSON ไปยัง field ของ Java
@SerializedName
annotation ของ Gson สำหรับเก็บชื่อ key JSON เดิมไว้ตอนแมปเข้ากับ field Java
Serializable
marker interface ของ Java ที่ทำให้ object สามารถ serialize เพื่อเก็บหรือส่งต่อได้
List<T>
ชนิด collection แบบ generic ใน Java ที่นิยมใช้แทน array ของ JSON

การแมประหว่างประเภท JSON กับ Java

ค่า JSONประเภท Javaคำอธิบาย
"Alice"Stringสตริงทั่วไป
18Integerจำนวนเต็ม
3.14Doubleเลขทศนิยม
[{...}]List<User>array ของ object → List<T>

แนวทางเลือกไลบรารี annotation

ไลบรารีannotation หลักเหมาะเมื่อ
Jackson@JsonPropertyใช้แมป JSON มาตรฐานใน Spring Boot
Gson@SerializedNameAndroid และ serialization แบบเบา
Fastjson@JSONFieldโปรเจกต์ Java ที่ใช้ Fastjson อยู่แล้ว
Lombok@Data / @BuilderPOJO ที่สั้นลงและมี boilerplate น้อย

Authoritative References