JSON & XML Processing

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    // A POJO = "Plain Old Java Object": a simple class with fields.
    // Jackson reads/writes JSON straight onto these fields.
    static class User {
        public String name;
        public int age;
        // @JsonProperty renames the JSON key. The field stays camelCase in Java,
        // the JSON shows "is_active" (snake_case, the common API style).
        @JsonProperty("is_active") public boolean isActive;
        // @JsonIgnore keeps a field OUT of the JSON (e.g. a secret/password).
        @JsonIgnore public String password;
    }

    public static void main(String[] args) throws Exception {
        // ObjectMapper is the one object that does all the conversion.
        ObjectMapper mapper = new ObjectMapper();

        // 1) Serialize: Java object -> JSON text (writeValueAsString)
        User u = new User();
        u.name = "Alice"; u.age = 30; u.isActive = true; u.password = "secret123";
        String json = mapper.writeValueAsString(u);
        System.out.println("Serialized: " + json);   // password is omitted

        // 2) Deserialize: JSON text -> Java object (readValue)
        String input = "{\"name\":\"Bob\",\"age\":25,\"is_active\":false}";
        User parsed = mapper.readValue(input, User.class);
        System.out.println("name:   " + parsed.name);     // Bob
        System.out.println("age:    " + parsed.age);      // 25
        System.out.println("active: " + parsed.isActive); // false
    }
}

Serialized: {"name":"Alice","age":30,"is_active":true}
name:   Bob
age:    25
active: false

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    // 🎯 YOUR TURN — finish the POJO and the two conversions

    static class Product {
        public String name;
        public double price;
        // 1) The JSON uses the key "in_stock" but you want a Java field
        //    called inStock. Add the annotation that renames it.
        ___ public boolean inStock;   // 👉 @JsonProperty("in_stock")
    }

    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();

        Product p = new Product();
        p.name = "Mug"; p.price = 9.99; p.inStock = true;

        // 2) Serialize p to a JSON string (Object -> JSON)
        String json = mapper.___(p);          // 👉 writeValueAsString
        System.out.println(json);

        // 3) Deserialize back into a Product (JSON -> Object)
        Product copy = mapper.___(json, Product.class);  // 👉 readValue
        System.out.println("Name: " + copy.name + ", stock: " + copy.inStock);

        // ✅ Expected output:
        // {"name":"Mug","price":9.99,"in_stock":true}
        // Name: Mug, stock: true
    }
}

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        // When you don't want to write matching POJOs, navigate the JSON as a
        // tree. Text block (Java 15+) keeps the JSON readable.
        String orderJson = """
            {
              "id": "ORD-001",
              "customer": { "name": "Alice", "tier": "Gold" },
              "items": [
                { "product": "Laptop", "quantity": 1, "price": 1299.99 },
                { "product": "Hub",    "quantity": 2, "price": 49.99 }
              ]
            }
            """;

        ObjectMapper mapper = new ObjectMapper();
        JsonNode root = mapper.readTree(orderJson);   // parse into a tree

        // .get("key") steps into an object; .asText()/.asInt()/.asDouble() read values.
        System.out.println("Order: " + root.get("id").asText());          // ORD-001
        System.out.println("Tier:  " + root.get("customer").get("tier").asText()); // Gold
        System.out.println("Items: " + root.get("items").size());         // 2

        // A JsonNode array is iterable — loop it like a List.
        double total = 0;
        for (JsonNode item : root.get("items")) {
            double line = item.get("quantity").asInt() * item.get("price").asDouble();
            total += line;
        }
        System.out.printf("Total: $%.2f%n", total);   // Total: $1399.97
    }
}

Order: ORD-001
Tier:  Gold
Items: 2
Total: $1399.97

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        // 🎯 YOUR TURN — read values out of the tree (no POJO)

        String json = "{\"city\":\"Paris\",\"weather\":{\"temp\":21,\"sky\":\"clear\"}}";

        ObjectMapper mapper = new ObjectMapper();

        // 1) Parse the JSON text into a tree
        JsonNode root = mapper.___(json);     // 👉 readTree

        // 2) Read the top-level "city" value as text
        String city = root.get("city").___;   // 👉 asText()

        // 3) Step into "weather" then read "temp" as an int
        int temp = root.get("weather").get("temp").___;  // 👉 asInt()

        System.out.println(city + ": " + temp + "C");

        // ✅ Expected output:
        // Paris: 21C
    }
}

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import java.io.StringReader;
import org.xml.sax.InputSource;

public class Main {
    public static void main(String[] args) throws Exception {
        String xml = "<book><title>Java Basics</title><pages>320</pages></book>";

        // DOM: loads the WHOLE document into a tree in memory. Easy to navigate,
        // but heavy for big files. (SAX/StAX stream instead — see the notes.)
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

        // SECURITY: turn off external entities to block XXE attacks.
        factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
        factory.setExpandEntityReferences(false);

        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.parse(new InputSource(new StringReader(xml)));

        Element rootEl = doc.getDocumentElement();   // <book>
        String title = rootEl.getElementsByTagName("title").item(0).getTextContent();
        String pages = rootEl.getElementsByTagName("pages").item(0).getTextContent();

        System.out.println("Root tag: " + rootEl.getTagName());  // book
        System.out.println("Title:    " + title);                // Java Basics
        System.out.println("Pages:    " + pages);                // 320
    }
}

Root tag: book
Title:    Java Basics
Pages:    320

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        // 🎯 MINI-CHALLENGE: average a JSON array of scores
        // The JSON below holds a "scores" array of numbers.
        // 1. Parse it with ObjectMapper.readTree(...)
        // 2. Loop over root.get("scores") (a JsonNode is iterable)
        // 3. Add up each value with .asInt() and count them
        // 4. Print "Average: X.X" to one decimal place (%.1f)
        //
        // ✅ Expected (scores 90, 80, 70): Average: 80.0

        String json = "{\"scores\":[90,80,70]}";

        // your code here
    }
}