JSON & Java — A Beginner-Friendly Guide

Modern applications constantly exchange data between browsers, servers, and mobile apps. To make this communication simple and universal, we use a lightweight data format called JSON.

This blog explains:

What is JSON?
Why JSON is so popular
How JavaScript uses JSON
How Java interacts with JSON
How to create and read JSON objects (with examples)

1. What is JSON?

JSON (JavaScript Object Notation) is a lightweight, text-based format for storing and exchanging data.

It is:

Human readable
Language independent
Easy for machines to parse
Universally supported

✔ JSON represents data using:

Key–value pairs
Arrays
Nested objects

✔ JSON is widely used in:

REST APIs
Web applications
Mobile apps
Server-to-server communication
Configuration files

2. Why JSON Is So Popular

JSON became the standard for data exchange because:

Feature	Why It Matters
Lightweight	Smaller size → faster communication
Readable	Easy for humans and developers
Language-free	Works in JavaScript, Java, Python, Go, etc.
Native in JavaScript	Perfect for web browsers
Easy to parse	Simple tools available in all languages

3. JSON in JavaScript

JSON was originally inspired by JavaScript object syntax.
In fact, JavaScript treats JSON almost like a native object.

Example:


var person = {
  "name": "Vinod",
  "address": "Bangalore",
  "designation": "Open source Publisher",
  "employer": "Self Business"
};

Accessing values:


console.log(person.name);
console.log(person.address);

4. JSON in Java

Java uses libraries to parse and create JSON because Java is strictly typed.

Popular Java libraries:

Jackson
Gson
JSON.simple
Org.JSON

Typical Java JSON operations:

➤ Convert JSON string → Java Object

➤ Convert Java Object → JSON string

➤ Read fields from JSON

➤ Create nested JSON structures

Example in Java using Jackson:


ObjectMapper mapper = new ObjectMapper();

String json = "{\"name\":\"Vinod\", \"address\":\"Bangalore\"}";
Person person = mapper.readValue(json, Person.class);
System.out.println(person.getName());

5. JSON Connecting Java ↔ JavaScript

✔ Browser → Server → Browser flow

JavaScript creates JSON
Sends JSON to Java backend using REST API
Java backend processes JSON
Java sends JSON response back
JavaScript reads JSON and updates UI

This is the core flow of all modern websites.

6. Creating JSON in JavaScript (Full Example)

Here is your example cleaned and formatted for blog readers:

📄 Example: Creating & Displaying a JSON Object in JavaScript


<html>
<head>
<title>Creating JSON Object</title>

<script>
    // Creating a JSON object
    var jsonObject = {
        "address": "Bangalore",
        "designation": "Open source Publisher",
        "employer": "Self Business",
        "name": "Vinod"
    };

    document.write("<h1>JSON Object Details</h1>");
    document.write("<h3>Name: " + jsonObject.name + "</h3>");
    document.write("<h3>Address: " + jsonObject.address + "</h3>");
    document.write("<h3>Designation: " + jsonObject.designation + "</h3>");
    document.write("<h3>Employer: " + jsonObject.employer + "</h3>");
</script>

</head>
<body>
</body>
</html>

Output


JSON Object Details

Name: Vinod
Address: Bangalore
Designation: Open source Publisher
Employer: Self Business

7. Convert JSON ↔ String in JavaScript

Convert object → JSON string:


var jsonStr = JSON.stringify(jsonObject);
console.log(jsonStr);

Convert JSON string → object:


var obj = JSON.parse(jsonStr);
console.log(obj.name);

8. Java + JSON Example

Java object to JSON:


ObjectMapper mapper = new ObjectMapper();
Person p = new Person("Vinod", "Bangalore");
String json = mapper.writeValueAsString(p);
System.out.println(json);

JSON to Java object:


String json = "{\"name\":\"Vinod\"}";
Person p = mapper.readValue(json, Person.class);

9. Summary

JSON is the most popular format for data exchange because:

It is simple and readable
Works across all languages
JavaScript handles it naturally
Java has rich libraries to parse and generate JSON

Whether you're building a web application, mobile app, or backend system, JSON is at the heart of modern development.

Spring Beans AutoWiring examples

Spring Autowiring

Spring frameworks provides autowiring feature, it enables you to inject the object dependency implicitly. It internally uses setter or constructor injection.
it helps cut down on the amount of XML configuration you write for a big Spring based application.

Types of Autowiring

There are couple of autowiring modes which can be used to instruct Spring container to use autowiring for dependency injection. Some of them are

no
This is default setting which means no autowiring and you should use explicit bean reference for wiring.
byName
Spring container looks at the properties of the beans on which autowire attribute is set to byName in the XML configuration file.
byType
Spring container looks at the properties of the beans on which autowire attribute is set to byType in the XML configuration file.
constructor
Similar to byType, but type applies to constructor arguments.
autodetect
Spring first tries to wire using autowire by constructor, if it does not work, Spring tries to autowire by byType

XML Based example

We have below two classes, CarInsurance and CarOrder and in CarOrder class we want to inject CarInsurance class,

CarInsurance.java

public class CarInsurance {
     private String name;
     private String policyDetails;

//Getters and setters

CarOrder.java

public class CarOrder {
 
     private String carDetails;
     private CarInsurance carInsurance;
     public CarOrder(CarInsurance carInsurance) {
         super();
         this.carInsurance = carInsurance;
     }   
     public CarOrder() {}
 //Getters and setters

Next, our goal is to inject CarInsurance bean to CarOrder bean..

<!-- Car insurance bean -->
     <bean id="carInsurance" class="com.vinod.test.CarInsurance">
         <property name="name" value="Progressive" />
         <property name="policyDetails" value="Full cover" />
     </bean>
     
     <!-- Autowiring by name -->
     <bean id="carOrder" class="com.vinod.test.CarOrder" autowire="byName">
     </bean>
     
     <!-- Autowiring by constructor -->
     <bean id="carOrder1" class="com.vinod.test.CarOrder"  autowire="constructor">
     </bean>

The above configuration, the bean carOrder will get the CarInsurance bean reference via auto wiring by name as we declared the property name in CarOrder, the second bean carOrder1 bean will get the CarInsurance reference via constructor as we defined the Constructor in CarOrder.

Annotation based Autowiring example

Annotation based auto wiring is very easy and it helps to inject dependencies via @Autowired annotation., see this example

1. Do the component scan in our Spring configuration

 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration; 
 @Configuration
 @ComponentScan("com.vinod.test")
 public class MySpringConifg {
     
 }

2. Create Java components with @Component annotaions

package com.vinod.test;
 import org.springframework.stereotype.Component;
 
 @Component
 public class Customer {
     public String getCustomer() {
         return "Thomas....Regular customer";
     }
 }
  

package com.vinod.test;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 @Component
 public class CustomerDetails {
     @Autowired
     Customer customer;
     public Customer getCustomerDetails() {
         return customer;
     }
 }
  

The CustomerDetails class we are using the @Autowired annotation to inject Customer bean, let us execute this program

3. Test class

package com.vinod.test;
 
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
 public class CustomerTest {
 
     public static void main(String[] args) {
         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
         context.register(MySpringConifg.class);
         context.refresh();
         CustomerDetails cd = context.getBean(CustomerDetails.class);
         System.out.println(cd.getCustomerDetails().getCustomer());
     }
 
 }
  

Output

Thomas....Regular customer

Done!!!!

Download this complete example..

https://github.com/kkvinodkumaran/spring

Spring Injecting Collection Example

Spring Injecting Collection

Spring framework facilitates to configure primitive data type using value attribute and object reference using ref attribute of the <property> tag. Both the cases it is dealing with passing singular value to bean. But Spring provides the option to pass the plural values like Java Collection types List, Set, Mat etc.

Here is one example to pass List of items to the bean from the configuration xml file

Example

1. Create Order. java

package com.pretech.dependency; 
  
 import java.util.ArrayList; 
  
 public class Order { 
  
     private String orderNumber;
     private ArrayList orderItems; 
  
     public ArrayList getOrderItems() {
         return orderItems;
     } 
  
     public void setOrderItems(ArrayList orderItems) {
         this.orderItems = orderItems;
     } 
  
     public String getOrderNumber() {
         return orderNumber;
     } 
  
     public void setOrderNumber(String orderNumber) {
         this.orderNumber = orderNumber;
     }
 }

2. Create spring configuration file (OrderDetails.xml)

<?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    <bean id="Order" class="com.pretech.dependency.Order">
       <property name="orderNumber" value="1212" />
     <property name="orderItems">
     <list>
         <value>PEPSI</value>
         <value>COCA-COLA</value>
         <value>MIRINDA</value>
         <value>FANTA</value>
     </list>
 </property>
     </bean> 
 </beans>

Note: Added List and its values

4. Create a Main program (OrderDetails.java)

package com.pretech.dependency; 
  
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext; 
  
 public class OrderDetails { 
  
     /**
      * @param args
      */
 
     public static void main(String[] args) { 
  
         ApplicationContext context = new ClassPathXmlApplicationContext(
                 "OrderDetails.xml");
         Order order = (Order) context.getBean("Order");
         System.out.println("Order item details "+order.getOrderNumber()""+order.getOrderItems());
     } 
  
 }

5. Output

Order item details 1212 [PEPSI, COCA-COLA, MIRINDA, FANTA]

Spring Injecting Inner Beans Example

Inner beans are beans that are defined within the scope of another bean. Inner bean we can add to beans property or constructor-arg tag

See this below example (Insurance class bean is injecting to Car class)

<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 
     <!-- Setter based dependency injection -->
     <!-- Here car order is the parent class and injecting the car insurance 
         bean as property and doing the car insurance bean creation there itself -->
     <bean id="carOrder" class="com.vinod.test.CarOrder">
 
         <property name="carInsurance">
             <bean id="carInsurance" class="com.vinod.test.CarInsurance">
                 <property name="name" value="Progressive" />
                 <property name="policyDetails" value="Full cover" />
             </bean>
         </property>
     </bean>
 
 </beans>    

Spring Dependency Injection (Constructor and Setter based) Example

When writing a complex Java application, application classes should be as independent as possible of other Java classes to increase the possibility to reuse these classes and to test them independently of other classes while doing unit testing. Dependency Injection helps in gluing these classes together and same time keeping them independent

We can achieve more reusable code,more testable code,more readable code using dependency injection

Spring provides two ways of Dependency injection

1. Constructor based

Constructor-based DI is accomplished when the container invokes a class constructor with a number of arguments, each representing a dependency on other class.

2. Setter method

Setter-based DI is accomplished by the container calling setter methods on your beans after invoking a no-argument constructor or no-argument static factory method to instantiate your bean.

Here is one simple examples for both,

Use case: When buying a car they want to update the insurance details as well, basically when creating a Car Order object we need to add insurance as well..

Spring configuration details

Here we are creating the CarOrder bean based one setter injection and constructor injection as well.

<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
     
     <bean id="carInsurance" class="com.vinod.test.CarInsurance">
         <property name="name" value="Progressive" />
         <property name="policyDetails" value="Full cover" />
     </bean>
     
     <!-- Setter based dependency injection -->
     <bean id="carOrder" class="com.vinod.test.CarOrder">
             <property name="carInsurance" ref="carInsurance" /> 
     </bean>
     
     <!-- Constructor based dependency injection -->
     <bean id="carOrder1" class="com.vinod.test.CarOrder">
               <constructor-arg ref="carInsurance" />
 
     </bean>
 </beans>    

CarInsurance.java

package com.vinod.test;
 
 public class CarInsurance {
     private String name;
     private String policyDetails;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getPolicyDetails() {
         return policyDetails;
     }
     public void setPolicyDetails(String policyDetails) {
         this.policyDetails = policyDetails;
     }
     @Override
     public String toString() {
         return "CarInsurance [name=" + name + ", policyDetails=" + policyDetails + "]";
     }
 
 }
  

CarOrder.java

package com.vinod.test;
 
 public class CarOrder {
 
     private String carDetails;
     private CarInsurance carInsurance;
     public String getCarDetails() {
         return carDetails;
     }
     public void setCarDetails(String carDetails) {
         this.carDetails = carDetails;
     }
     public CarInsurance getCarInsurance() {
         return carInsurance;
     }
     public void setCarInsurance(CarInsurance carInsurance) {
         this.carInsurance = carInsurance;
     }
     public CarOrder(CarInsurance carInsurance) {
         super();
         this.carInsurance = carInsurance;
     }
     public CarOrder() {}
     @Override
     public String toString() {
         return "CarOrder [carDetails=" + carDetails + ", carInsurance=" + carInsurance + "]";
     }
     
 }
  

Test class

package com.vinod.test;
 
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 
 public class SpringDIExample {
 
     public static void main(String[] args) {
 
         // Test Setter based dependency injection
         ApplicationContext context = new ClassPathXmlApplicationContext("spring-di-core.xml");
 
         CarOrder cardOder = (CarOrder) context.getBean("carOrder");
         System.out.println(cardOder);
 
         // Test Constructor based dependency injection
 
         ApplicationContext context1 = new ClassPathXmlApplicationContext("spring-di-core.xml");
 
         CarOrder cardOder1 = (CarOrder) context1.getBean("carOrder1");
         System.out.println(cardOder1);
     }
 
 }
  

Output

CarOrder [carDetails=null, carInsurance=CarInsurance [name=Progressive, policyDetails=Full cover]]

Download Example

https://github.com/kkvinodkumaran/spring

Spring Bean Definition Template Example

Spring Bean Definition Template

We can create a Bean definition template which can be used by other child bean definitions without any additional coding. While defining a Bean Definition Template, you should not specify class attribute and should specify abstract attribute with a value of true as shown below:

Here is one simple example as Vechicle class is parent and Car class is child and Car class is getting wheel property via inheritance configured in the xml

Example

1. Create a Parent class (Vechicle.java)

package com.inheritance;

public class Vehicle {

private String wheel;

    public String getWheel() {
        return wheel;
    }

    public void setWheel(String wheel) {
        this.wheel = wheel;
    }
}

2. Create a Child class (Car.java)

package com.inheritance;

public class Car {
private String dicky;
private String wheel;

    public String getWheel() {
        return wheel;
    }

    public void setWheel(String wheel) {
        this.wheel = wheel;
    }

    public String getDicky() {
        return dicky;
    }

    public void setDicky(String dicky) {
        this.dicky = dicky;
    }
}

3. Create Beans configuration file (VehicleTemplate.xml)

Add bean details

Note: In the above car bean definition mentioned the parent bean.

4. Create a Main program (VehicleTemplateMain.java)

package com.inheritance;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class VehicleTemplateMain {

    /**
     * @param args
     */
    public static void main(String[] args) {

        ApplicationContext context = new ClassPathXmlApplicationContext(
                "VehicleTemplate.xml");
        Car c = (Car) context.getBean("car");
        System.out.println("From vehicle abstract   "+c.getWheel());
        System.out.println("From car"+c.getDicky());

}

5. Output

From vehicle abstract Four wheeler
From carFlat dicky

Spring Bean Definition Inheritance Example

Spring Bean Definition Inheritance

Spring Bean definition inheritance has nothing to do with Java class inheritance but inheritance concept is same. You can define a parent bean definition as a template and other child beans can inherit required configuration from the parent bean

Here is one simple example as Vehicle class is parent and Car class is child and Car class is getting wheel property via inheritance configured in the xml

Example

1. Create a Parent class (Vehicle.java)

package com.inheritance; 
public class Vehicle { 
    private String wheel; 
    public String getWheel() {
        return wheel;
    } 
    public void setWheel(String wheel) {
        this.wheel = wheel;
    }
}

2. Create a Child class (Car.java)

package com.inheritance; 
public class Car {
    private String dicky;
    private String wheel; 
    public String getWheel() {
        return wheel;
    } 
    public void setWheel(String wheel) {
        this.wheel = wheel;
    } 
    public String getDicky() {
        return dicky;
    } 
    public void setDicky(String dicky) {
        this.dicky = dicky;
    }
}

3. Create Beans configuration file (Vehicle.xml)

Add bean details

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    <bean id="vehicle" class="com.inheritance.Vehicle">
<property name="wheel" value="Four wheeler"/>
</bean>
<bean id="car" class="com.inheritance.Car"
parent="vehicle">
<property name="dicky" value="Flat dicky"/>
</bean>
</beans>

Note: In the above car bean definition mentioned the parent bean.

4. Create a Main program (CarMain.java)

package com.inheritance; 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; 
public class CarMain { 
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "Vehicle.xml");
        Vehicle v = (Vehicle) context.getBean("vehicle");
        System.out.println("From Vehicle"+v.getWheel());
        Car c = (Car) context.getBean("car");
        System.out.println("From car"+c.getWheel());
        System.out.println("From car"+c.getDicky()); 
    } 
}

5. Project Structure

6. Output

From VehicleFour wheeler
From carFour wheeler
From carFlat dicky

JSON & Java — A Beginner-Friendly Guide

1. What is JSON?

✔ JSON represents data using:

✔ JSON is widely used in:

2. Why JSON Is So Popular

3. JSON in JavaScript

Accessing values:

4. JSON in Java

Typical Java JSON operations:

➤ Convert JSON string → Java Object

➤ Convert Java Object → JSON string

➤ Read fields from JSON

➤ Create nested JSON structures

5. JSON Connecting Java ↔ JavaScript

✔ Browser → Server → Browser flow

6. Creating JSON in JavaScript (Full Example)

📄 Example: Creating & Displaying a JSON Object in JavaScript

Output

7. Convert JSON ↔ String in JavaScript

Convert object → JSON string:

Convert JSON string → object:

8. Java + JSON Example

Java object to JSON:

JSON to Java object:

9. Summary

Spring Autowiring

Types of Autowiring

XML Based example

Spring Injecting Collection

Example

1. Create Order. java

2. Create spring configuration file (OrderDetails.xml)

4. Create a Main program (OrderDetails.java)

5. Output

Spring provides two ways of Dependency injection

Spring configuration details

CarInsurance.java

Spring Bean Definition Template

Example

2. Create a Child class (Car.java)

3. Create Beans configuration file (VehicleTemplate.xml)

4. Create a Main program (VehicleTemplateMain.java)

5. Output

Spring Bean Definition Inheritance

Example

1. Create a Parent class (Vehicle.java)

2. Create a Child class (Car.java)

3. Create Beans configuration file (Vehicle.xml)

4. Create a Main program (CarMain.java)

5. Project Structure

6. Output

Featured Posts