import json
import os
TYPE_MAPPING = {
"string": "String",
"integer": "Integer",
"number": "Double",
"boolean": "Boolean",
}
def capitalize(s):
return s[0].upper() + s[1:] if s else s
def generate_class(name, schema, indent=0):
indent_str = " " * indent
lines = []
imports = set()
lines.append(f"{indent_str}public class {name} " + "{")
properties = schema.get("properties", {})
required = schema.get("required", [])
# Fields
for prop, prop_schema in properties.items():
java_type, nested_imports, nested_classes = get_java_type(prop, prop_schema, indent + 1)
imports.update(nested_imports)
# Jackson annotation
lines.append(f'{indent_str} @com.fasterxml.jackson.annotation.JsonProperty("{prop}")')
lines.extend(nested_classes) # add nested classes if any
lines.append(f"{indent_str} private {java_type} {prop};\n")
# Getters and setters
for prop, prop_schema in properties.items():
java_type, _, _ = get_java_type(prop, prop_schema, indent + 1)
prop_camel = capitalize(prop)
# Getter
lines.append(f"{indent_str} public {java_type} get{prop_camel}() " + "{")
lines.append(f"{indent_str} return {prop};")
lines.append(f"{indent_str} }}\n")
# Setter
lines.append(f"{indent_str} public void set{prop_camel}({java_type} {prop}) " + "{")
lines.append(f"{indent_str} this.{prop} = {prop};")
lines.append(f"{indent_str} }}\n")
lines.append(f"{indent_str}}}")
return imports, lines
def get_java_type(prop_name, prop_schema, indent):
"""Return (java_type, imports_set, nested_class_lines)"""
imports = set()
nested_classes = []
# Handle enum
if "enum" in prop_schema:
enum_name = capitalize(prop_name)
enum_lines = generate_enum(enum_name, prop_schema["enum"], indent)
nested_classes.extend(enum_lines)
return enum_name, imports, nested_classes
prop_type = prop_schema.get("type")
if prop_type == "object":
# Nested class
class_name = capitalize(prop_name)
imports_inner, class_lines = generate_class(class_name, prop_schema, indent)
imports.update(imports_inner)
nested_classes.extend(class_lines)
return class_name, imports, nested_classes
elif prop_type == "array":
imports.add("java.util.List")
items = prop_schema.get("items", {})
item_type, imports_inner, nested_inner = get_java_type(prop_name + "Item", items, indent)
imports.update(imports_inner)
nested_classes.extend(nested_inner)
return f"List<{item_type}>", imports, nested_classes
else:
# Simple types
java_type = TYPE_MAPPING.get(prop_type, "Object")
return java_type, imports, nested_classes
def generate_enum(name, values, indent=1):
indent_str = " " * indent
lines = []
lines.append(f"{indent_str}public enum {name} " + "{")
# Add enum values in uppercase
enum_values = [v.upper().replace(" ", "_") for v in values]
lines.append(f"{indent_str} " + ", ".join(enum_values) + ";")
lines.append(f"{indent_str}}}\n")
return lines
def json_schema_to_pojo(schema_path, output_dir="generated", package="com.example", class_name="RootPojo"):
with open(schema_path) as f:
schema = json.load(f)
os.makedirs(output_dir, exist_ok=True)
imports, class_lines = generate_class(class_name, schema)
# Prepare import statements
import_lines = []
if imports:
import_lines.append("import " + ";\nimport ".join(sorted(imports)) + ";")
# Add Jackson imports
import_lines.append("import com.fasterxml.jackson.annotation.JsonProperty;")
# Compose full Java file content
java_code = []
java_code.append(f"package {package};\n")
java_code.extend(import_lines)
java_code.append("\n")
java_code.extend(class_lines)
java_file_path = os.path.join(output_dir, f"{class_name}.java")
with open(java_file_path, "w") as f:
f.write("\n".join(java_code))
print(f"✅ Java POJO generated at: {java_file_path}")
if __name__ == "__main__":
json_schema_to_pojo(
schema_path="Output_Schema.json",
output_dir="generated",
package="com.example.generated",
class_name="MyPojo"
)
No comments:
Post a Comment