Forem: Ayush Shrivastava

Building AI Applications with Spring AI and Azure OpenAI

Ayush Shrivastava — Fri, 27 Feb 2026 09:54:46 +0000

Artificial Intelligence is no longer optional for modern applications. Whether you're building a chatbot, developer assistant, FAQ engine, or content generator — AI integration is becoming a core backend requirement.

If you're already a Spring Boot developer, the good news is: you don’t need to learn an entirely new ecosystem to build AI-powered apps.

Thanks to Spring AI, integrating models like Azure OpenAI Service becomes clean, structured, and production-friendly.

In this blog, I’ll walk you step-by-step through building a simple AI-powered REST API using Spring AI and Azure OpenAI.

1. What is Spring AI?

Spring AI is a Spring ecosystem project designed to simplify AI integration in Spring Boot applications.

Instead of manually:

Writing HTTP calls
Handling authentication headers
Parsing JSON responses
Managing model-specific configurations

Spring AI provides clean abstractions like:

ChatClient
EmbeddingClient
Model abstraction layer
Auto configuration support

If you already know Spring Boot, you can start building AI applications almost immediately.

2. Why Do We Need Spring AI?

Before Spring AI

Developers had to:

Manually call REST APIs
Handle authentication tokens
Build request bodies
Parse large AI responses
Maintain provider-specific logic

This made code:

Hard to maintain
Hard to scale
Difficult to switch AI providers

With Spring AI

Clean dependency injection
Simple configuration
Provider abstraction
Spring Boot auto configuration
Production-ready structure

AI calls now look like standard Spring code.

That’s powerful.

3. Core Features of Spring AI

ChatClient

Used for sending prompts and receiving AI-generated responses.

Model Abstraction

Switch between providers (OpenAI, Azure OpenAI, etc.) without rewriting business logic.

Auto Configuration

Works seamlessly with Spring Boot auto configuration.

** Simple Prompt Handling**

Send a message and receive output in just a few lines of code.

Integration Friendly

Works smoothly with:

REST APIs
Databases
Microservices
Cloud deployments

4. Project Setup Overview

Let’s understand the project architecture step by step.

We are building:

A Spring Boot application
Connected to Azure OpenAI
Exposing a REST endpoint
Secured using environment variables

5. Maven Dependencies Explained

Spring Boot Parent

Provides dependency management and plugin configuration.

Spring Web MVC

Used to build REST APIs.

Spring AI Azure OpenAI Starter

Connects your application with Azure OpenAI service.

Spring AI BOM

Manages compatible versions of Spring AI libraries.

DevTools

Used for development-time restart.

** Test Dependency**

Used for writing unit and integration tests.

6. application.properties Explained

`spring.application.name=openai

spring.ai.azure.openai.api-key=${AZURE_OPENAI_API_KEY}
spring.ai.azure.openai.endpoint=${AZURE_OPENAI_ENDPOINT}
spring.ai.azure.openai.chat.options.deployment-name=${AZURE_OPENAI_DEPLOYMENT}
spring.ai.azure.openai.chat.options.temperature=1
`

Explanation

application.name → Name of your application
api-key → Azure OpenAI API key (from environment variable)
endpoint → Azure endpoint URL
deployment-name → Your deployed model name
temperature → Controls AI creativity

Using environment variables is a secure way to manage secrets.

Never hardcode your API keys.

7. Main Application Class

`@SpringBootApplication
public class OpenaiApplication {

public static void main(String[] args) {
    SpringApplication.run(OpenaiApplication.class, args);
}

}
`

Explanation

@SpringBootApplication → Enables auto configuration & component scanning
SpringApplication.run() → Starts the application

This is the entry point of your backend.

8. Chat Controller Explained

`@RestController
@RequestMapping("/api")
public class ChatController {

private final ChatClient chatClient;

public ChatController(ChatClient.Builder chatClientBuilder) {
    this.chatClient = chatClientBuilder.build();
}

@GetMapping("/chat")
public String chat(@RequestParam("message") String message) {
    return chatClient
            .prompt(message)
            .call()
            .content();
}

}
`

@RestController

Marks the class as a REST controller.

@RequestMapping("/api")

Base URL path.

ChatClient Injection

Spring automatically provides ChatClient.Builder.

We build it using:

chatClientBuilder.build();

/chat Endpoint

Example:

http://localhost:8080/api/chat?message=Hello

Final Summary

Using:

Spring Boot
Spring AI
Azure OpenAI

You created an intelligent backend system with minimal code.

Spring AI removes complexity and makes AI integration feel native to Spring developers.

This is the modern way of building intelligent backend applications using Java.

Source Code

You can find the complete project here:

GitHub Repository:

ayushstwt / spring-ai-azure-openai-chat-api

Demo project for Spring Ai and OpenAI

Building AI Applications with Spring AI and Azure OpenAI

Author: Ayush Shrivastava

1. What is Spring AI?

Spring AI is a Spring ecosystem project that helps developers build AI-powered applications using simple and familiar Spring Boot concepts.

It provides integration with popular AI providers like OpenAI and Azure OpenAI. Instead of writing complex HTTP calls manually, Spring AI gives you ready-to-use abstractions like ChatClient, EmbeddingClient, and more.

If you already know Spring Boot, you can easily start building AI applications without learning new complicated frameworks.

2. Why Do We Need Spring AI?

Before Spring AI: - Developers had to manually call REST APIs. - They had to handle authentication, request bodies, and response parsing. - Code became complex and hard to maintain.

With Spring AI: - Configuration is simple. - Dependency injection works as usual. - AI calls look clean and readable. - It integrates smoothly with Spring Boot projects.

…

View on GitHub

Building an AI Chat Application with Spring AI and OpenAI

Ayush Shrivastava — Sat, 01 Nov 2025 21:15:16 +0000

Building a Chat Application Backend with Spring AI and OpenAI

Artificial Intelligence is rapidly becoming an essential part of modern applications. From improving automation to enhancing user experience, AI continues to redefine how software systems interact and respond. One of the most practical and engaging ways to explore AI is through chat-based applications, where intelligent responses and contextual understanding create more human-like interactions.

Recently, I started working on a Chat Application Backend that integrates Spring AI with OpenAI to generate real-time, AI-powered responses. The goal of this project is to build a simple yet extendable backend foundation for future conversational and intelligent chat features.

Introduction to Spring AI

Spring AI is an emerging project from the Spring Team designed to simplify the integration of artificial intelligence models into Spring Boot applications. It provides a structured way to connect with AI providers like OpenAI and allows developers to work with AI models using familiar Spring concepts.

Instead of manually handling complex API calls, Spring AI offers clean abstractions that let developers easily send prompts, receive responses, and manage context. This makes it an ideal choice for teams already using Spring Boot who want to experiment with or deploy AI-driven features quickly.

Introduction to OpenAI

OpenAI is a leading organization in the field of artificial intelligence, best known for its large language models such as GPT-4. These models can process and generate human-like text, answer questions, write code, and assist in natural conversations. Integrating OpenAI’s models into backend systems opens new possibilities, including:

Smart chatbots and conversational agents
Personalized recommendations
Context-aware assistants and feedback systems

By combining OpenAI with Spring AI, developers can bring intelligent behavior directly into their applications with minimal setup.

About the Project

This project provides the initial backend setup for a chat system built using Spring Boot and Spring AI. It focuses on creating a clean, modular, and easily extendable structure for building AI-driven chat systems.

Key Features:

REST APIs for sending user messages and receiving AI-generated responses
Integration with OpenAI through Spring AI
Real-time response generation using HTTP endpoints
Scalable architecture for adding future chat-related features

How It Works

The application workflow is straightforward:
A user sends a message to the backend via an API endpoint.
The backend receives the message and passes it to Spring AI.
Spring AI communicates with the OpenAI model to generate a response.
The AI-generated response is instantly returned to the client.

This foundation makes it possible to extend the system with advanced features such as:

Conversation history and context management
Authentication and user session handling
Frontend chat integration for real-time interactions
Streaming responses for a smoother experience

Repository

The complete source code and setup guide are available here:
GitHub Repository – ChatApp Backend

Final Thoughts

This project represents an initial step toward exploring how AI can enhance chat-based systems using Spring Boot. It demonstrates how developers can integrate Spring AI to create intelligent, responsive, and context-aware applications.

If you are interested in learning or experimenting with Spring AI and OpenAI, you can explore the repository, run the project locally, and build upon it to create your own intelligent systems.

Spring Boot + Redis + Docker: Ultimate Guide to Caching in Java

Ayush Shrivastava — Tue, 20 May 2025 09:32:05 +0000

With Redis, your Spring Boot app can become faster and handle more traffic without breaking a sweat. This article will show you how to set it up step by step. However, before diving deep into Redis, we need to understand the concept of caching.

Cache

Cache is a fast, small, temporary storage frequently used by the computer or application to store and access important data.

It stores data in a key-value format. By leveraging cache memory, we can minimize database calls, improving application performance since database queries are typically resource-intensive.

The main objective of a cache is to speed up the retrieval of data by making a copy of the data in a location that can be accessed faster than the source or database.

A cache is a small and fast, efficient memory space that an application frequently uses to store or access important data.

Why Caching?

The main objective of a cache is to speed up the retrieval of data by making a copy of the data in a location that can be accessed faster than the source or database.

In our application, whenever multiple requests access static data (data that is not changed frequently), we fetch the data from the database every time. Therefore, the number of database calls increases, which affects the performance of our application because database calls are always costly.

However, the static data can be stored in a cache, and whenever a request is made to access the data, it is fetched from the cache. As a result, the number of database calls is reduced, and the application's performance is improved.

How does a Cache work?

In the diagram above, multiple requests made to access the data in the application will first check the cache to determine whether the data is present. If the data is found, it is returned from the cache, a concept known as a Cache Hit. If the data is not found, it is retrieved from the database, which is referred to as a Cache Miss.

Cache Hit

Data is found in the cache, so it has to be fetched from a faster source.

We can understand the cache hit like this: imagine you have a notebook where you write down answers to questions you frequently ask. You ask a question, and the answer is already written in your notebook. you quickly find it without searching elsewhere.

Cache Miss

Data is not found in the cache, so it has to be fetched from a slower source.

Similarly, you asked a question, but it’s not in your notebook. You have to search in a big textbook (which takes more time) and then write the answer in your notebook for future use.

Redis

Redis (Remote Dictionary Server) is an open-source, in-memory key-value data store that supports various data structures, including strings, lists, sets, and hashes. Its in-memory architecture ensures high performance, making it an ideal choice for caching and session management in modern applications.

The spring-boot-starter-redis is a Spring Boot starter that simplifies integrating Redis into Spring applications. It includes all the necessary dependencies to connect, configure, and operate with Redis.

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Spring Boot provides the spring-boot-starter-redis starter, enabling seamless communication with the Redis server. It includes various components that facilitate efficient interaction with Redis.

JedisConnectionFactory: Manages and establishes the connection between the Spring Boot application and the Redis server.
RedisTemplate: It provides methods to perform operations like saving, retrieving, and deleting data in Redis.
StringRedisTemplate: A specialized version of RedisTemplate that simplifies operations for String-based keys and values.
OpsForValue: Supports operations on simple key-value pairs in Redis.
OpsForHash: It is providing methods to peform operations based on Hash Data structure.
OpsForList: Provides methods to interact with Redis Lists.
OpsForSet: Facilitates operations on Redis Sets.

Spring Boot with Redis Integration

Spring Boot provides seamless integration with Redis, an in-memory data store, through the spring-boot-starter-redis starter. It simplifies configuration and enables developers to use Redis for caching, messaging, and data persistence.

Prerequisites for Running the Spring Boot Redis Integration Project

Redis Server (Local or Cloud-based; here we use docker)
Java Development Kit (JDK 17 or above)
Maven (Build tool)
IDE (e.g., IntelliJ IDEA, Eclipse, or Spring Tool Suite)
Postman (Optional, for testing REST APIs)
Project Build Using Maven

Docker Redis Setup

In this article, we install Redis using Docker. We can also manually download it from the Redis website, but here, we download the latest Redis image from Docker Hub (ensure Docker is already installed on your machine).

We have a sample spring-boot application that you clone from Github for initial setup. The initial code is available in the main branch, so please checkout to the main or redis integration branch. I also added the postman collection on the root directory of the project so you can test all the API before integration.

Steps to Integrate Redis with Spring Boot

Add the Maven dependency in the pom.xml file. Since we are using Docker, we also include the Docker Compose dependency.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-redis</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-docker-compose</artifactId>
    <scope>runtime</scope>
</dependency>

Configure Redis Connection or database connection (we’re using H2 as database). Add the Redis server configuration to application.properties or application.yml

spring.application.name=spring-boot-redis-cache

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

spring.cache.type=redis
spring.data.redis.host=localhost
spring.data.redis.port=6379

# if we are using local redis or cloud but here we use docker so there is no need of username or password
spring.data.redis.username=
spring.data.redis.password=

Create the docker-compose.yml file on the root folder with the same naming convention we follow for docker-redis configurations.

services:
  redis:
    image: redis:7.4.2
    ports:
      - 6379:6379

Mark the spring-boot application class as @EnableCaching to enable caching in our Spring Boot application. To enable caching in our Spring Boot application, add the @EnableCaching annotation to one of our configuration classes. This annotation triggers a post-processor that inspects each Spring bean for caching annotations.

package com.ayshriv.springbootrediscache;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class SpringBootRedisCacheApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootRedisCacheApplication.class, args);
    }

}

Create the class RedisConfig.class inside the config package

package com.ayshriv.springbootrediscache.config;

import com.techie.springbootrediscache.dto.ProductDto;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

import java.time.Duration;

@Configuration  // Marks this class as a Spring configuration class
public class RedisConfig {

    @Bean  // Defines a Spring bean for RedisCacheManager
    public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        // Define cache configuration
        RedisCacheConfiguration cacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10)) // Set time-to-live (TTL) for cache entries to 10 minutes
                .disableCachingNullValues() // Prevent caching of null values
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new Jackson2JsonRedisSerializer<>(ProductDto.class))); // Serialize values using Jackson JSON serializer

        // Create and return a RedisCacheManager with the specified configuration
        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(cacheConfig) // Apply default cache configuration
                .build();
    }
}

This class configures Redis caching in a Spring Boot application. The @Configuration annotation marks it as a configuration class, and the @Bean annotation defines a RedisCacheManager bean.

The cache configuration includes a time-to-live (TTL) of 10 minutes (Duration.ofMinutes(10)), which ensures that cached data expires automatically after this period. It also disables the caching of null values (disableCachingNullValues()) to optimize memory usage.

For serialization, the Jackson2JsonRedisSerializer is used, which converts Java objects (ProductDto) to JSON before storing them in Redis. This ensures that cached data remains structured and readable.

The RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(cacheConfig).build() method initializes the cache manager with the given configuration and connects it to the Redis database using RedisConnectionFactory.

After doing all the configurations, we implement the caching on the business class (service class).

package com.ayshriv.springbootrediscache.service;

import com.techie.springbootrediscache.dto.ProductDto;
import com.techie.springbootrediscache.entity.Product;
import com.techie.springbootrediscache.repository.ProductRepository;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    @CachePut(value="PRODUCT_CACHE", key="#result.id")
    public ProductDto createProduct(ProductDto productDto) {
        var product = new Product();
        product.setName(productDto.name());
        product.setPrice(productDto.price());

        Product savedProduct = productRepository.save(product);
        return new ProductDto(savedProduct.getId(), savedProduct.getName(),
                savedProduct.getPrice());
    }

    @Cacheable(value="PRODUCT_CACHE", key="#productId")
    public ProductDto getProduct(Long productId) {
        Product product = productRepository.findById(productId)
                .orElseThrow(() -> new IllegalArgumentException("Cannot find product with id " + productId));
        return new ProductDto(product.getId(), product.getName(),
                product.getPrice());
    }

    @CachePut(value="PRODUCT_CACHE", key="#result.id")
    public ProductDto updateProduct(ProductDto productDto) {
        Long productId = productDto.id();
        Product product = productRepository.findById(productId)
                .orElseThrow(() -> new IllegalArgumentException("Cannot find product with id " + productId));

        product.setName(productDto.name());
        product.setPrice(productDto.price());

        Product updatedProduct = productRepository.save(product);
        return new ProductDto(updatedProduct.getId(), updatedProduct.getName(),
                updatedProduct.getPrice());
    }

    @CacheEvict(value="PRODUCT_CACHE", key="#productId")
    public void deleteProduct(Long productId) {
        productRepository.deleteById(productId);
    }
}

When we mark the createProduct() method with this @CachePut(value = "PRODUCT_CACHE", key = "#[result.id](http://result.id/)") annotation, this ensures that the object returned by this method is stored or updated in the cache name PRODUCT_CACHE, and the key part specifies that the cache key should be the ID of the returned ProductDto object.

This is useful in scenarios where a new product is created or an existing product is updated, as it ensures that the latest product details are stored in the cache. By using this annotation, subsequent requests for the same product can be served quickly from the cache, reducing database queries and improving application performance while keeping the cache up to date.

Next, when we mark the getProductById() method with this @Cacheable(value = "PRODUCT_CACHE", key = "#productId") annotation, this ensures that the returned object by this method is stored in the cache named "PRODUCT_CACHE", and the key part specifies that the cache key should be the productId parameter passed to the method.

If the requested productId is already present in the cache, the method skips execution and directly returns the cached value, avoiding a database call. However, if the productId is not found in the cache, the method executes, retrieves the product from the database, stores the result in the cache, and then returns it.

When we mark the deleteProduct() method with this @CacheEvict(value = "PRODUCT_CACHE", key = "#productId") annotation, this ensures that the cache entry associated with the given productId is removed from the cache named "PRODUCT_CACHE". The key part specifies that the cache key to be evicted is the productId parameter passed to the method.

This means that after deleting a product from the database, its cached entry will also be removed, ensuring that stale data is not served from the cache in future requests. If the deleted product is requested again, it will be fetched from the database and re-cached if applicable.

Here, we do all the things with the help of the annotation-based approach but we can also do the same things with the help of CacheManager.

The CacheManager is a Spring framework interface responsible for managing different cache implementations. It acts as a central mechanism to store, retrieve, and manage cached data efficiently.

private final CacheManager cacheManager;

public ProductDto createProduct(ProductDto productDto) {
        var product = new Product();
        product.setName(productDto.name());
        product.setPrice(productDto.price());

        Product savedProduct = productRepository.save(product);
        Cache productCache = cacheManager.getCache("PRODUCT_CACHE");
        productCache.put(savedProduct.getId(), savedProduct);

        return new ProductDto(savedProduct.getId(), savedProduct.getName(),
                savedProduct.getPrice());
    }

Test the application

ADD-PRODUCT: http://localhost:8080/api/product
GET-PRODUCT: http://localhost:8080/api/product/3
UPDATE PRODUCT: http://localhost:8080/api/product
DELETE PRODUCT: http://localhost:8080/api/product/2

Conclusion

Redis with Spring Boot makes apps faster by caching data and reducing database calls. Using @Cacheable, @CachePut, and @CacheEvict, we can easily store, update, and delete cached data. This improves speed, reduces server load, and helps the app handle more users smoothly.

When we are performing the create operation, then the response of this operation is stored in the cache so whenever we perform operations like the getProduct() it checks the product in the cache first, if the product is present inside the cache, it returns that if not then it will return from the database.

Similarly, when we perform the delete operation, first it deletes the data from the database and then deletes it from the cache as well. All these types of operations reduce the number of DB calls so the performance of the application is increased.

OOPs in Java: Principles, Concepts, and Real-World Examples

Ayush Shrivastava — Tue, 20 May 2025 09:29:49 +0000

Object-Oriented Programming

OOP stands for object-oriented programming. It is a programming paradigm that revolves around the object rather than function and procedure. In other words, it is an approach for developing applications that emphasize on objects. An object is a real
word entity that contains data and code. It allows binding data and code together. here objects means real world entity like car, bike, atm etc.

Procedural Programming	OOPS
programs are divided into parts called functions	Programs are divided into objects
Overloading is not possible	Overloading is possible
Inheritance is not possible	Inheritance is possible
Data hiding is not present	Data hiding is present
It follows a top-down approach	It follows a bottom-up approach
It focuses on the process.	It focuses on data.
Ex:- C, Pascal etc.	Ex:- Java, C++, Python etc.

OOP Concepts in Java

Java follows Object-Oriented Programming (OOP), which is based on the following nine key concepts:

Class – A blueprint for creating objects.
Object – An instance of a class with state and behavior.
Encapsulation – Hiding internal details and exposing only the necessary parts.
Polymorphism – The ability to take multiple forms (method overloading & overriding).
Inheritance – Acquiring properties and behaviors from a parent class.
Abstraction – Hiding implementation details and showing only essential features.
Association – A relationship between two classes without ownership.
Composition – A strong association where one class owns another.

The Four Pillars of OOP

These are the core principles of OOP in Java:

Encapsulation
Inheritance
Polymorphism
Abstraction

Note: Concepts and pillars are different. Java has 8 main concepts, but only 4 pillars of OOP.

Benefits of OOP in Java

Reusability – Write once, use multiple times to reduce redundancy.
Data Redundancy – Avoids duplication by using shared class definitions.
Code Maintenance – Easier to update and manage code efficiently.
Security – Encapsulation and abstraction restrict unnecessary data access.
Easy Troubleshooting – Objects simplify debugging and modification.
Better Design – Stable base classes reduce errors in derived classes.

1. Class

A class in java a blueprint or template of an object from where an object is created. it doesn’t take space in the memory. It is a user-defined data type. Inside a class, we define variables, constants, functions. It is example of data binding. it is a logical entity.

Syntax

class ClassName {
    // Fields (variables)

    // Constructors

    // Methods
}

2. Object

An Object is a real world entity that has attributes, behavior, and properties. It is referred to as an instance of the class. It contains member functions, variables that we have defined in the class. It occupies space in the memory. Different objects have
different states or attributes, and behaviors.

Object is a real world entity, every object have state and behavior state tell us how the object looks like and behavior tell us what the object does.

Syntax

ClassName objectName = new ClassName();

Class	Object
It is a logical entity	It is a real-world entity
It is a based on concepts.	It is based on real world
It uses the keyword class when declared.	It uses the new keyword to create an object.
It does not occupy space in the memory.	It occupies space in the memory.
It is a data type that represents the blueprint of an
object.	It is an instance of the class.

here car is a object is class and the Audi, BMW is a instance of that class. so all the properties and behavior of the class is also present in its instance.

class Car {

        // state
    private String color;
    private String type;
    private String brand;
    private int speed;

    // Constructor
    public Car(String color, String type, String brand) {
        this.color = color;
        this.type = type;
        this.brand = brand;
        this.speed = 0; // Initial speed
    }

    //behavior

    // Method to increase speed
    public void increaseSpeed(int increment) {
        speed += increment;
        System.out.println(brand + " speed increased to " + speed + " km/h");
    }

    // Method to apply brake
    public void applyBrake(int decrement) {
        speed -= decrement;
        if (speed < 0) speed = 0;
        System.out.println(brand + " speed reduced to " + speed + " km/h");
    }

    // Method to drive
    public void drive() {
        System.out.println(brand + " is driving at " + speed + " km/h");
    }

    // Method to display car details
    public void displayDetails() {
        System.out.println("Brand: " + brand + ", Type: " + type + ", Color: " + color);
    }

    public static void main(String[] args) {
        Car audi = new Car("Red", "Sedan", "Audi");
        Car bmw = new Car("Blue", "SUV", "BMW");

        audi.displayDetails();
        audi.increaseSpeed(50);
        audi.drive();
        audi.applyBrake(20);

        System.out.println();

        bmw.displayDetails();
        bmw.increaseSpeed(60);
        bmw.drive();
        bmw.applyBrake(30);
    }
}

Output

Brand: Audi, Type: Sedan, Color: Red
Audi speed increased to 50 km/h
Audi is driving at 50 km/h
Audi speed reduced to 30 km/h

Brand: BMW, Type: SUV, Color: Blue
BMW speed increased to 60 km/h
BMW is driving at 60 km/h
BMW speed reduced to 30 km/h

3. Encapsulation

The process of wrapping the data and code which is acting on the data together into a single unit is called as Encapsulation. we can achieve the encapsulation by creating the variables of class as private and create the getter and setter method as public to view and modify the variables. it is also known as data hiding.

Advantages

loosely coupled code.
Better access control & security.

package oops;

public class Encapsulation {
    public static void main(String[] args) {
        // creating the object
        Student student=new Student();

        // setting the value of the variables
        student.setAge(10);
        student.setName("Ayush");

        // Accessing the value of the variables
        System.out.println(student.getName());
        System.out.println(student.getAge());
    }
}

class Student{
    // variables as private
    private String name;
    private int age;

    // getter and setter
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

output-

Ayush
10

here in this example we are creating the variables of the class as private so other classes can’t access theme this concept is called the encapsulation. and we provide the getter and method to modify and view the value of the variables. It provides you the control over the data. Suppose you want to set the value of age which should be greater than 18 only, you can write the logic inside the setter method. You can write the logic not to store the negative numbers in the setter methods.

4. Abstraction

The Process of hiding the internal implementation and shows only essential functionality to the user is known as abstraction. it is also known as the detail hiding. in java it is achieved through interface and abstract classes.

Advantages-

It increases security and confidentiality.

Example-

When we are driving a car if we want to stop the car than we just apply the break and the car speed will reduce, we don’t know how the car speed is reduce. and also there is no need to know as a driver how the things works in car. so we can say that break and other functionality of the car is abstract from us.

Similar in the cellphone how the call is made that is abstracted to us.

package oops;

public interface Car {
    void applyBreak();
    void start();
}

class BMW implements Car{
    public void applyBreak(){
        System.out.println("Applying break");
    }
    public void start(){
        System.out.println("Starting the car");
    }
}

here in this example car is an interface applyBreak() and start() is a method of the Car interface and the class BMW implement the car interface so user only knows about the abstartion method that are applyBreak() and start() but don’t know about the internal implementations. here what we do we just hides the internal details of the class.

What are the interface and abstract class we learn in next article.

5. Polymorphism

Polymorphism is a combination of two words ploy means “Many” and morphism means “Form”. means same entity (method) having different behavior is called as a polymorphism.

Example-

A person can be father, boy, teacher or can be a dancer, writer, programmer as well.
water is liquid, solid or gas.

There are a tow types of polymorphism.

Compile Time / static polymorphism
Run Time/ Dynamic polymorphism

Compile Time polymorphism

A polymorphism which is achieved at compile time known as the compile time polymorphism.

Example- Method Overloading

Run Time polymorphism

A polymorphism which is achieved at run time known as the run time polymorphism.

Example- Method Overriding

Method Overloading

Two method is said to be overloaded if both the method having same name but variation in parameters. variation in parameters means. In method Overriding method signature is different.

Number of parameters
Position of parameters
Data type of the parameters

class Calculator {
    // Method to add two integers
    int add(int a, int b) {
        return a + b;
    }

    // Method to add three integers (overloaded)
    int add(int a, int b, int c) {
        return a + b + c;
    }

    // Method to add two double numbers (overloaded)
    double add(double a, double b) {
        return a + b;
    }
}

public class MethodOverloadingExample {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();

        int sum1 = calculator.add(5, 10);                 // Calls the first method
        int sum2 = calculator.add(5, 10, 15);             // Calls the second method
        double sum3 = calculator.add(2.5, 3.5);           // Calls the third method

        System.out.println("Sum1: " + sum1);
        System.out.println("Sum2: " + sum2);
        System.out.println("Sum3: " + sum3);
    }
}

Here in this example, we have a Calculator class with overloaded add methods. The methods have the same name but different parameter lists (number and type of parameters). Depending on the number and types of arguments passed, the appropriate overloaded method is called.

Method Overriding

If child class method is not satisfied with its parent class method implementation than it override that implementation this concept is called as a overriding. It is only possible with Inheritance. In the runtime polymorphism it is decided which method is to be called parent class method or child class method. In method Overriding method signature is same.

class Vehicle {
    void start() {
        System.out.println("The vehicle starts");
    }
}

class Car extends Vehicle {
    @Override
    void start() {
        System.out.println("The car starts with a key ignition");
    }
}

class Bike extends Vehicle {
    @Override
    void start() {
        System.out.println("The bike starts with a kick");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle myVehicle = new Vehicle();
        myVehicle.start();  // Calls the start method in Vehicle

        Vehicle myCar = new Car();
        myCar.start();  // Calls the overridden start method in Car

        Vehicle myBike = new Bike();
        myBike.start();  // Calls the overridden start method in Bike
    }
}

Here in this example Vehicle is a class having methods as start and bike and car is the subclass of that class where we override the start() method according to use case. The specific implementation is executed depending on the type of object at runtime.

6. Inheritance

Inheritance in Java is a mechanism in which one object acquires all the properties and behaviors of a parent object. The idea behind inheritance in Java is that you can create new classes that are built upon existing classes. When you inherit from an existing class, you can reuse methods and fields of the parent class. Moreover, you can add new methods and fields in your current class also.

Inheritance represents the IS-A relationship which is also known as a parent-child relationship.

Parent / super class - A class that properties and behaviors are acquired by the child class.

Child / sub class - A class that properties and behaviors are acquiring from the super class.

Advantages-

Method overriding
Code reuse

Types of Inheritance

Multiple Inheritance (In java through class is not possible)
Multilevel Inheritance
Single level Inheritance
hierarchical Inheritance
Hybrid Inheritance (In java through class is not possible)
Multiple Inheritance→ Single child class Acquiring the properties and behaviors of the super class.
Multilevel Inheritance → Acquiring the properties and behaviors from another derived class.
Hierarchical Inheritance → Two child classes are inheriting the properties and behavior from single super/ parent class.

Multiple Inheritance → When one class Inherit multiple classes than this is known as the multiple inheritance. In java this is not possible through the class because of ambiguity or diamond problem but with help of interface we can achieve.
Hybrid Inheritance → It is a combination of two and more than two inheritance. In java this is not possible through the class but with help of interface we can achieve.

Conclusion

Object-Oriented Programming (OOP) is a powerful approach to designing and organizing code that makes applications easier to build, manage, and scale. Through OOP concepts, developers create efficient, reusable, and maintainable code structures.

OOP is built on four fundamental pillars that govern how objects interact and function in a program:

Encapsulation – Protects data by keeping it private within a class and exposing only what's necessary.
Abstraction – Simplifies complex implementations by providing a clean interface for users.
Inheritance – Enables classes to inherit properties and behaviors from other classes, promoting code reuse.
Polymorphism – Allows a single action to behave differently in various contexts, enhancing code flexibility.

These concepts are essential for writing clean, structured code. For a deeper understanding, explore our dedicated articles on each pillar. Mastering OOP principles will improve your programming skills and help you tackle real-world problems more effectively .

Containerizing Spring Boot Applications with Docker: A Complete Guide

Ayush Shrivastava — Sun, 18 May 2025 15:46:50 +0000

Containerizing Spring Boot Applications with Docker

In today's world of cloud computing and microservices, deploying applications efficiently is a big challenge. This is where Docker comes in. Docker helps in packaging applications along with all their dependencies, making them easy to deploy anywhere.

In this blog, we will see how to containerize a Spring Boot application using Docker, step by step. By the end, you’ll be able to run your Spring Boot app inside a Docker container and deploy it seamlessly.

Docker has changed the way we build, run, and scale applications. It lets you package your app with everything it needs, so it runs the same everywhere—on your computer, on someone else’s, or on a server. Docker is one of the most popular tools for this. It helps keep things consistent and avoids the “it works on my machine” problem.

What is Docker ?

Docker is a word that is driven from dock-worker, dock worker is a job of person who loads and un loads the containers in a ship from where it has been names as ‘Docker’.
Using docker we can implement the containerization technologies.
Containerization is concept through which we can package software applications and the corresponding libraries/binaries which are required for running the application. and that package is called image.
Docker is tool/platform that makes it easy to create, manage or run the containers.

Why Docker ?

suppose that we are building a spring boot application on our local machine. it runs perfectly because our system has the right version of java, maven and other tools installed. In order to deploy our application in a another machine we need to setup all the Software which are required to our application. In a real time project should be deployed into multiple environments for testing purpose such as DEV, UAT, PROD, SIT etc. To deploy application to these many environments we need to take of all the software required to run our application in all environments. It is very difficult task. Maybe another machine has different java version, or it is missing some dependencies. then it throws errors.

Now, let’s we use Docker, we create a Dockerfile that includes our application, the exact java version, and all the requires settings. once it is packaged into a docker image, it can run on any system with Docker installed- without worrying about what’s installed on that machine. now we can run the same container in every environments as we run in our local system. so we can say that docker help us to save the time and simplifies both development and deployment.

Prerequisites

Basic knowledge of Java, Spring Boot and Maven.
Installed Java, Maven, Docker and Docker CLI and IDE (IntelliJ, VS Code).

Simple Spring Boot Application

I created a basic Spring Boot project with just one REST API that returns "Hello, World!" when we hit the /hello endpoint. and I push the code of spring boot application on GitHub. so you just clone it and switch to master branch.

You can check out the full code here :

ayushstwt/docker-spring-boot

Test Spring Boot Application on localhost

http://localhost:8080/hello

Docker Terminology

Docker file- It contains set of instructions to build docker image.

Docker Image- It is a package which contains application code + dependencies.

Docker Hub- It is a registry to store docker images. (AWS ECR)

Docker Container- It is a runtime instance of our application Run time instance of an image. If you run docker image container will be created that's where our application is running.

To Generate docker image from our spring-boot application there are three different commonly used approaches. we can choose one of theme.

Dockerfile
Buildpacks
Google Jib

Approach 1

Running a Spring Boot application as a container using Dockerfile

Step 1 - Run the maven command, “mvn clean install”. to generate a fat jar inside the target folder.

Step 2- Create the file name as Dockerfile inside the root directory to generate a Docker image.

FROM openjdk:17-jdk-slim
COPY target/docker-spring-boot-0.0.1-SNAPSHOT.jar docker-spring-boot-0.0.1-SNAPSHOT.jar
ENTRYPOINT ["java","-jar","/docker-spring-boot-0.0.1-SNAPSHOT.jar"]

here in the above file

FROM openjdk:17-jdk-slim – Uses a lightweight OpenJDK 17 base image to run the Spring Boot application. COPY target/docker-spring-boot-0.0.1-SNAPSHOT.jar docker-spring-boot-0.0.1-SNAPSHOT.jar – Copies the built JAR file from the target directory into the Docker image. ENTRYPOINT ["java","-jar","/docker-spring-boot-0.0.1-SNAPSHOT.jar"] – Defines the command to run the Spring Boot JAR when the container starts.

To use Docker, first download Docker Desktop from docker.com/products/docker-desktop. Pick the version for your OS (Windows or macOS). If you're on Linux, follow the guide at docs.docker.com/engine/install. Install it like any app and launch Docker Desktop.

Next, open your terminal and run docker login. Enter your Docker Hub username and password. If you don’t have an account, create one at hub.docker.com/signup.

Once logged in, you’re ready to build images, run containers, and manage apps easily.

Step 3 - Execute the docker command to generate the docker image based on the tag name. make sure that your docker desktop is running.


// syntax
docker build -t your-image-name:tag .

// command
docker build -t ayshriv/**docker-spring-boot:latest .**

after executing this command you get this output that means our image is successfully generated. here the docker build command is used to create a Docker image from a Dockerfile. The -t flag allows you to give your image a name and optionally add a version tag. For example, docker-spring-boot is the name and : latest is version of the image you're creating. The . (dot) at the end tells Docker to look in the current directory for the Dockerfile and all the necessary files to build the image.

now check that image is generated or not we use the command docker images to see all the images.

step 4 - after this execute the command that creates the docker container based on the image.

docker run -p 8080:8080 ayshriv/**docker-spring-boot:latest**

here the command docker run -p 8080:8080 ayshriv/docker-spring-boot:latest is used to start a Docker container from our image. The -p 8080:8080 part maps your computer’s port 8080 to the container’s port 8080, so you can access the app in your browser at http://localhost:8080. The ayshriv/docker-spring-boot:latest is the name of the image you're running from Docker Hub. This command makes your Spring Boot app run inside a container. here in 8080:8080 where first value represents the external port and the second value represents the container port. after executing this command we get the out like this and now our container is running successfully.

to check that our container is running or not we used the command that is docker ps that show all the running containers.

the Docker image name ayshriv/docker-spring-boot:latest, ayshriv is your Docker Hub username, which helps identify you as the owner of the image. docker-spring-boot is the name of your application, and it's good practice to keep this name short, clear, and related to what your app does. The part after the colon, latest, is the tag, which usually refers to the current or most recent version of the image. You can also use tags like v1.0, prod, or dev to manage different versions.

While this approach of creating a Docker image using a Dockerfile is effective and widely used, one of the main disadvantages is that the resulting image can be quite large, especially when using a base image like OpenJDK. A larger image takes more time to build, transfer, and start, which can slow down development and deployment. Additionally, maintaining the Dockerfile requires extra effort, as you need to keep it updated whenever the application structure or dependencies change. here we show that the image size is 428MB that is very large now next approach helps to reduce the size and minimal efforts as well.

Approach 2

Running a Spring Boot application as a container using Buildpacks

Cloud Native Buildpacks transform your application source code into images that can run on any cloud. it is an alternative approach to dockerfiles. with the help of Buildpacks we can automatically generate production ready images form our application source code without writing the Dockerfile.

https://buildpacks.io/

Step 1- we need to add the given configuration inside the pom.xml for the image name.

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <image>
                            <name>ayshriv/${project.artifactId}:latest</name>
                    </image>
                </configuration>
            </plugin>
        </plugins>
  </build>

here also we follows the same naming convention for image name.

Step 2- now we run the given maven command to generate the docker image with out the need of Dockerfile. (make sure that docker desktop is running).

mvn spring-boot:build-image

Step 3- after this executing the given command that creates the docker container based on the image and also port mapping provided.

docker run -p 8080:8080 ayshriv/docker-spring-boot:latest

now in this approach no need of Dockerfile and also the image size is also reducing. but there is one more problem here in our local system we need a Docker desktop is installed. to remove this problem we use Google JIB this is only used for java application to generate the imagef of our springboot application without need of Dockerfile and also the size is reduced.

Approach 3

Running a Spring Boot application as a container using Google JIB

GitHub - GoogleContainerTools/jib: 🏗 Build container images for your Java applications.

Google JIB is used to Build container images for your Java applications. without need of Dockerfile and Docker Desktop. it is an alternative approach to dockerfiles. with the help of Google JIB we can automatically generate production ready images form our application source code without writing the Dockerfile.

Step 1- we need to add the given configuration inside the pom.xml for the image name.

<build>
  <plugins>
    <plugin>
      <groupId>com.google.cloud.tools</groupId>
      <artifactId>jib-maven-plugin</artifactId>
      <version>3.4.0</version> 
      <configuration>
        <to>
          <image>ayshriv/${project.artifactId}:latest</image>
        </to>
      </configuration>
    </plugin>
  </plugins>
</build>

Step 2- Run the given maven command to generate the docker image (for Google JIB there is no need of Docker Desktop to be installed on your local system).

mvn compile jib:dockerBuild

Step 3- after this executing the given command that creates the docker container based on the image and also port mapping provided.

docker run -p 8080:8080 ayshriv/docker-spring-boot:latest

In this approach, we eliminate the need for a Dockerfile, and the resulting image size is significantly reduced. However, one limitation is that Docker Desktop must be installed on the local system to build and run Docker images. To overcome this dependency, we can use Google JIB — a powerful tool specifically designed for Java applications.

Google JIB allows us to containerize our Spring Boot application without writing a Dockerfile or having Docker installed locally. It integrates directly with Maven or Gradle, enabling seamless image creation and pushing to container registries. Additionally, JIB optimizes image layering, which helps in reducing image size and speeding up rebuild times during development.

Some Common used Docker Commands for Java Developers

# 1. Build Docker image from Dockerfile (usually for Spring Boot app)
docker build -t my-java-app .

# 2. List all images
docker images

# 3. Run the Docker container from the built image
docker run -d -p 8080:8080 --name java-app-container my-java-app

# 4. View running containers
docker ps

# 5. View all containers (including stopped ones)
docker ps -a

# 6. Stop a running container
docker stop java-app-container

# 7. Start a stopped container
docker start java-app-container

# 8. Restart a container
docker restart java-app-container

# 9. Remove a container
docker rm java-app-container

# 10. Remove an image
docker rmi my-java-app

# 11. View logs of a container (helpful for debugging)
docker logs java-app-container

# 12. Execute a command inside a running container (like inspecting files, checking logs)
docker exec -it java-app-container bash

# 13. Tag an image (e.g., for pushing to Docker Hub)
docker tag my-java-app ayushshrivastaav/my-java-app:latest

# 14. Login to Docker Hub
docker login

# 15. Push image to Docker Hub
docker push ayushshrivastaav/my-java-app:latest

# 16. Pull image from Docker Hub
docker pull ayushshrivastaav/my-java-app:latest

# 17. Remove all stopped containers
docker container prune -f

# 18. Remove all unused images
docker image prune -a -f

# 19. Check Docker version
docker version

# 20. View system-wide Docker resource usage
docker system df

# 21. Compose up (if using docker-compose.yml for multi-container apps)
docker-compose up -d

# 22. Compose down
docker-compose down

Conclusion

Using Docker with Spring Boot makes application deployment faster, more reliable, and scalable. With just a few steps, you can package your application and run it anywhere—on your local machine, cloud, or any server that supports Docker. This approach is widely used in DevOps and Microservices Architecture to ensure smooth deployment.

Start containerizing your Spring Boot apps today and experience the power of Docker!

Mastering the Singleton Design Pattern in Java – A Complete Guide

Ayush Shrivastava — Fri, 28 Feb 2025 17:27:14 +0000

Learn how the Singleton Design Pattern ensures a single instance of a class, improving efficiency and resource management in Java applications. Explore real-world use cases and implementation techniques!

What is a Design Pattern?

In software development, a design pattern is a proven solution to a commonly occurring problem in software design. It provides best practices that help developers write clean, reusable, and maintainable code.

Design patterns are broadly categorized into three types:

Creational Patterns – Focus on object creation (e.g., Singleton, Factory, Builder).
Structural Patterns – Deal with object composition (e.g., Adapter, Decorator, Composite).
Behavioral Patterns – Define how objects interact (e.g., Observer, Strategy, Command).

Among these, the Singleton Pattern is a widely used Creational Design Pattern, ensuring that only one instance of a class exists throughout the application.

Singleton Design Pattern

When a class ensures that only one instance is created and used throughout the application, it is called the Singleton Design Pattern. or we can say that for a particular class a single object is maintained or created, it is known as singleton design pattern.

How to Achieve Singleton Design Pattern ?

if we want to achieve the singleton design pattern we follow the three steps.

1) we should prevent the object creation from outside of the class. for that we need to create the private constructor, so we can create the object only inside of the class not outside of the class.

private static Singleton singleton = new Singleton();

2) creating the single object of the class inside the class and creating that object as static so the only single copy of that object is created.

private static Singleton singleton = new Singleton();

3) create the getter method for accessing the object. and that method we create as static so with the help of the class name we can accessing that object. outside of the class.

public static Singleton getInstance() {
        return singleton;
    }

Example

public class Singleton {
    private static Singleton singleton = new Singleton();

    private Singleton() {
        System.out.println("Singleton created");
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

Advantages of Singleton Design Pattern

Controlled Access – Ensures only one instance of the class exists, preventing accidental multiple object creation.
Saves Memory – Reduces memory usage by reusing the same object instead of creating multiple instances.
Global Access Point – Provides a single, shared instance accessible from anywhere in the application.
Prevents Conflicts – Useful in scenarios like database connections, logging, and caching where multiple instances could cause issues.
Thread-Safety (if implemented correctly) – Helps manage shared resources in a multi-threaded environment.
Improves Performance – Avoids unnecessary object creation, leading to better efficiency.

Fixing "No Serializer Found" Error in Hibernate

Ayush Shrivastava — Fri, 28 Feb 2025 16:40:58 +0000

Fixing "No Serializer Found" Error in Hibernate

If you're working with Hibernate in a Spring Boot application and see an error like this:

No serializer found for class org.hibernate.proxy.pojo.bytebuddy.ByteBuddyInterceptor

It means that your application is trying to convert a Hibernate entity into JSON, but Jackson (the JSON library) doesn’t know how to handle Hibernate’s proxy objects.

Don't worry! This blog will help you understand why this happens and how to fix it.

Why Does This Error Happen?

Hibernate uses lazy loading by default for related entities. This means that when you fetch data from the database, Hibernate doesn’t load everything immediately. Instead, it creates a proxy (a placeholder) until the data is actually needed.

But when Jackson tries to convert this proxy into JSON, it fails because it doesn’t know how to serialize it. That’s when you see this error.

How to Fix It

1. Ignore Hibernate Proxy Fields

Add this annotation to your entity class to tell Jackson to ignore Hibernate’s internal properties:

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties({"hibernateLazyInitializer", "handler"})
@Entity
public class YourEntity {
    // Your fields and methods
}

This prevents Jackson from trying to serialize Hibernate’s internal proxy fields.

2. Change Fetch Type to EAGER (if necessary)

If the error happens because of a lazy-loaded field, you can change it to eager loading:

@ManyToOne(fetch = FetchType.EAGER)
private Location location;

Warning: Eager loading can affect performance if used on large datasets.

3. Use DTOs Instead of Entities (Best Practice!)

Instead of returning database entities directly, create Data Transfer Objects (DTOs) and map only the required fields.

Example DTO:

public class LocationDTO {
    private String city;
    private String state;
    // Constructors, getters, and setters
}

Convert Entity to DTO Before Returning:

LocationDTO locationDTO = new LocationDTO(entity.getCity(), entity.getState());
return locationDTO;

This avoids exposing unnecessary fields and proxy objects.

4. Force Hibernate to Load the Object Before Serialization

If you're dealing with lazy loading, initialize the object before returning it:

YourEntity entity = yourRepository.findById(id).orElseThrow();
Hibernate.initialize(entity.getLocation());

This ensures that the related entity is fully loaded before converting it to JSON.

5. Ignore Specific Fields in Serialization

If the issue is with a specific field, tell Jackson to ignore it:

@JsonIgnore
private Location location;

This will prevent Jackson from trying to serialize the location field.

6. Disable Serialization Error in `application.properties` (Temporary Fix)

If you just want to stop the error without fixing the root cause, you can add this to application.properties:

spring.jackson.serialization.fail-on-empty-beans=false

This is not a recommended solution because it hides the issue instead of fixing it.

7. Convert Entity to a Map Before Serializing

Instead of returning an entity directly, convert it into a Map:

ObjectMapper mapper = new ObjectMapper();
Map<String, Object> response = mapper.convertValue(entity, new TypeReference<Map<String, Object>>() {});

This helps avoid serialization issues.

Conclusion

If you get the "No serializer found" error in Hibernate, try these solutions:

Add @JsonIgnoreProperties
Change fetch type to EAGER (if needed)
Use DTOs (Best Practice!)
Initialize lazy-loaded fields
Ignore specific fields with @JsonIgnore
Disable the error (not recommended)
Convert entity to a Map

Following these methods will help you fix the error and improve your application's performance.

Introduction to Spring REST

Ayush Shrivastava — Tue, 25 Feb 2025 06:21:18 +0000

Introduction to Spring REST

In today's world, most applications need to communicate with each other. For example, a mobile app needs data from a backend server. This is where REST APIs come into play. In this blog, we will understand Spring REST in very simple words and see how we can create a REST API using Spring Boot.

What is REST?

REST stands for Representational State Transfer. It is a set of rules that helps applications communicate over the internet using HTTP methods like:

GET → Used to fetch data from the server.
POST → Used to send new data to the server.
PUT → Used to update existing data on the server.
DELETE → Used to remove data from the server.

REST APIs follow a stateless architecture, meaning each request from a client contains all the necessary information for the server to process it, without relying on previous requests.

A REST API follows these rules and allows different systems to exchange information easily using JSON or XML as data formats.

What is Spring REST?

Spring REST is a part of the Spring Framework that simplifies the creation of REST APIs. It provides built-in support for handling HTTP requests and responses, data conversion, and error handling. This allows developers to focus on writing business logic instead of managing low-level configurations.

Spring REST is mostly used with Spring Boot, which helps in developing APIs quickly with minimal setup and configuration.

Benefits of Spring REST

Easy to use: Reduces boilerplate code and simplifies development.
Scalable: Can handle multiple requests efficiently.
Flexible: Supports JSON, XML, and other formats.
Integration-friendly: Works well with databases, security tools, and third-party services.

Steps to Create a REST API in Spring Boot

Let's go step by step to create a simple REST API using Spring Boot.

Step 1: Create a Spring Boot Project

You can create a Spring Boot project using Spring Initializr. Select the following dependencies:

Spring Web (for REST API development)
Spring Boot DevTools (for automatic reloads during development)
Lombok (for reducing boilerplate code in Java classes)
Spring Data JPA (for database connectivity)
H2 Database (for an in-memory database during development)

Step 2: Create a Model Class

A model class represents the data structure used in the API. Here is an example:

public class User {
    private int id;
    private String name;
    private String email;

    public User(int id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

Step 3: Create a REST Controller

A REST Controller manages HTTP requests. We use @RestController to define it.

import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Arrays;

@RestController
@RequestMapping("/users")
public class UserController {

    private List<User> users = Arrays.asList(
        new User(1, "Alice", "alice@example.com"),
        new User(2, "Bob", "bob@example.com")
    );

    @GetMapping
    public List<User> getUsers() {
        return users;
    }
}

Step 4: Run the Application

Start your Spring Boot application.
Open a web browser or Postman and go to: http://localhost:8080/users
You will see the list of users in JSON format.

Additional Features

Once you have a basic REST API, you can add more features like:

1. Connecting to a Database

Instead of hardcoding data, you can connect the API to a database using Spring Data JPA. This allows you to store and retrieve data dynamically.

2. Error Handling

Using @ExceptionHandler, you can handle errors gracefully and return meaningful messages to the user instead of generic error codes.

Example:

@ExceptionHandler(Exception.class)
public ResponseEntity<String> handleException(Exception e) {
    return new ResponseEntity<>("Something went wrong: " + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
}

3. Securing the API

Use Spring Security to protect your API endpoints from unauthorized access. You can implement JWT authentication to ensure only authenticated users can access the API.

4. API Documentation with Swagger

Swagger helps in documenting and testing APIs easily. You can add Swagger using the springdoc-openapi-starter-webmvc-ui dependency and access it at http://localhost:8080/swagger-ui.html.

5. Deploying the API

Once your API is ready, you can deploy it to cloud platforms like AWS, Google Cloud, or Heroku to make it accessible to users worldwide.

Conclusion

Spring REST is a powerful way to build REST APIs in Java using Spring Boot. It allows you to create APIs quickly by defining a REST Controller, handling HTTP requests, and returning data in JSON format.

By following these steps, you can build APIs that can be used in web and mobile applications. You can also enhance your API by adding database connectivity, security, and documentation.

Spring REST makes API development simple, scalable, and efficient, making it an essential tool for modern application development.

Spring Boot REST API - Returning Response in JSON Format

Ayush Shrivastava — Sun, 23 Feb 2025 07:02:36 +0000

Spring Boot REST API - Returning Response in JSON Format

Introduction

In this guide, we will learn how to return a response in JSON format from a Spring Boot REST API. By default, Spring Boot returns responses in JSON, making it the standard format for most RESTful services. JSON is widely used due to its lightweight nature, easy readability, and compatibility with various programming languages.

Why Use JSON in REST APIs?

Lightweight & Fast: JSON data is compact, making it faster to parse compared to XML.
Human & Machine Readable: JSON has a simple and structured format that is easy to read and manipulate.
Widely Supported: JSON is supported across multiple programming languages and frameworks.
Ideal for Web & Mobile Applications: JSON works well with JavaScript and is natively supported in web and mobile development.

Steps to Implement JSON Response in Spring Boot

1️⃣ Add Required Dependencies

Spring Boot uses Jackson for JSON serialization and deserialization. Jackson is included by default in Spring Boot starters, so no extra dependency is needed. However, ensure that your pom.xml contains the necessary dependency:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

This ensures that Jackson can automatically convert Java objects to JSON and vice versa.

2️⃣ Create a Model Class (DTO) for JSON Response

We need a model class (DTO) that represents the response data. Jackson automatically serializes objects into JSON.

package com.example.demo.dto;

public class UserResponse {
    private String name;
    private int age;
    private String email;

    // Default Constructor
    public UserResponse() {}

    // Parameterized Constructor
    public UserResponse(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

3️⃣ Create a REST Controller

Next, we create a Spring Boot REST Controller that returns the response in JSON format. We use produces = MediaType.APPLICATION_JSON_VALUE to specify JSON response type.

package com.example.demo.controller;

import com.example.demo.dto.UserResponse;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping(value = "/user", produces = MediaType.APPLICATION_JSON_VALUE)
    public UserResponse getUser() {
        return new UserResponse("Ayush", 25, "ayush@example.com");
    }
}

4️⃣ Create Main Spring Boot Application Class

The main class is needed to start the Spring Boot application.

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

5️⃣ Run the Application and Test the API

Start the Spring Boot application, then send a GET request using Postman, Browser, or Curl:

GET http://localhost:8080/api/user

6️⃣ Expected JSON Response Output

When the API is called, it returns the response in JSON format as shown below:

{
    "name": "Ayush",
    "age": 25,
    "email": "ayush@example.com"
}

Troubleshooting Common Issues

✅ Error: JSON Response Not Showing?

Ensure that the jackson-databind dependency is added.
Check if produces = MediaType.APPLICATION_JSON_VALUE is correctly set in the controller.
Use Postman and check the Accept header; set it to application/json.

✅ JSON Response Showing as XML?

If you have jackson-dataformat-xml dependency, Spring Boot might return XML.
Remove any @XmlRootElement annotations from the model class.
Explicitly request JSON by setting the Accept header to application/json.

Summary

✅ Used Jackson for JSON serialization (default in Spring Boot).

✅ Created a DTO class for structured JSON responses.

✅ Developed a REST API that returns JSON using produces = MediaType.APPLICATION_JSON_VALUE.

✅ Ran and tested the API to verify JSON response output.

Conclusion

Spring Boot provides an easy way to return JSON responses with minimal configuration. With proper setup, JSON-based REST APIs are efficient, fast, and easy to integrate with modern web and mobile applications.

Spring Boot REST API - Returning Response in XML Format

Ayush Shrivastava — Sun, 23 Feb 2025 06:57:11 +0000

Spring Boot REST API - Returning Response in XML Format

Introduction

In this guide, we will learn how to return a response in XML format from a Spring Boot REST API. By default, Spring Boot returns responses in JSON, but we can configure it to return XML by following a few simple steps. This is particularly useful when integrating with systems that require XML responses, such as legacy applications or third-party services.

Why Use XML in REST APIs?

Interoperability: Many older systems and enterprise applications still rely on XML for data exchange.
Structured Data: XML provides a well-structured format that is widely used in web services (SOAP-based services).
Customization: XML allows for defining custom schemas and DTDs, making data validation more flexible.

Steps to Implement XML Response in Spring Boot

1️⃣ Add Required Dependency

Spring Boot uses Jackson for JSON serialization and deserialization. To enable XML support, we need to include jackson-dataformat-xml dependency in pom.xml:

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
</dependency>

This dependency enables Jackson to convert Java objects into XML format automatically.

2️⃣ Create a Model Class (DTO) for XML Response

We need a model class (DTO) that represents the response data. Annotate it with @XmlRootElement and @XmlAccessorType to enable XML conversion.

package com.example.demo.dto;

import jakarta.xml.bind.annotation.XmlElement;
import jakarta.xml.bind.annotation.XmlRootElement;
import jakarta.xml.bind.annotation.XmlAccessorType;
import jakarta.xml.bind.annotation.XmlAccessType;

@XmlRootElement(name = "User")
@XmlAccessorType(XmlAccessType.FIELD)
public class UserResponse {

    @XmlElement
    private String name;

    @XmlElement
    private int age;

    @XmlElement
    private String email;

    // Default Constructor
    public UserResponse() {}

    // Parameterized Constructor
    public UserResponse(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

3️⃣ Create a REST Controller

Next, we create a Spring Boot REST Controller that returns the response in XML format. We use produces = MediaType.APPLICATION_XML_VALUE to specify XML response type.

package com.example.demo.controller;

import com.example.demo.dto.UserResponse;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping(value = "/user", produces = MediaType.APPLICATION_XML_VALUE)
    public UserResponse getUser() {
        return new UserResponse("Ayush", 25, "ayush@example.com");
    }
}

4️⃣ Create Main Spring Boot Application Class

The main class is needed to start the Spring Boot application.

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

5️⃣ Run the Application and Test the API

Start the Spring Boot application, then send a GET request using Postman, Browser, or Curl:

GET http://localhost:8080/api/user

6️⃣ Expected XML Response Output

When the API is called, it returns the response in XML format as shown below:

<User>
    <name>Ayush</name>
    <age>25</age>
    <email>ayush@example.com</email>
</User>

Troubleshooting Common Issues

✅ Error: XML Response Not Showing?

Ensure that the jackson-dataformat-xml dependency is added.
Check if produces = MediaType.APPLICATION_XML_VALUE is correctly set in the controller.
Use Postman and check the Accept header; set it to application/xml.

✅ XML Response Showing as JSON?

Spring Boot defaults to JSON; explicitly request XML by setting the Accept header to application/xml.
Make sure the model class is correctly annotated with @XmlRootElement and @XmlAccessorType.

Summary

✅ Added Jackson XML dependency to support XML serialization.

✅ Created a DTO class with @XmlRootElement to define the XML structure.

✅ Developed a REST API that returns XML response using produces = MediaType.APPLICATION_XML_VALUE.

✅ Ran and tested the API to verify XML response output.

Conclusion

Using XML in Spring Boot REST APIs is straightforward and useful when working with applications that require XML data exchange. With proper configuration, we can seamlessly switch between JSON and XML responses depending on the client’s request.

Setting Up a Development Environment for Java: A Beginner's Guide

Ayush Shrivastava — Thu, 23 Jan 2025 18:22:56 +0000

Java is one of the most popular programming languages in the world. Whether you're a student, a professional, or someone stepping into the world of programming, setting up the right development environment is the first step. Here’s a step-by-step guide to help you get started with Java development.

Step 1: Install the Java Development Kit (JDK)

The Java Development Kit (JDK) contains everything you need to write, compile, and run Java programs.

Steps to Install JDK:

Download the JDK
- Go to the official Oracle Java Downloads page. Alternatively, you can use OpenJDK (an open-source version of JDK).
- Choose the latest version of JDK for your operating system (Windows, macOS, or Linux).
Install the JDK
- Run the downloaded installer.
- Follow the instructions on the screen to complete the installation.
Set the Environment Variable
- On Windows:
  - Search for Environment Variables in the Start menu.
  - Under “System Variables,” find Path and add the bin folder of the JDK installation (e.g., C:\Program Files\Java\jdk-XX\bin).
- On macOS/Linux:
  - Open the terminal and edit the .bashrc, .zshrc, or .bash_profile file, adding the following:
```
export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH
```

- Restart your terminal or system to apply the changes.

Verify Installation
- Open your terminal or command prompt and type:
```
java -version
```

If Java is installed correctly, you’ll see the version number displayed.

Step 2: Install an Integrated Development Environment (IDE)

An IDE makes writing, debugging, and managing Java projects much easier.

Popular IDEs for Java:

Eclipse: Free, beginner-friendly, and highly customizable.
IntelliJ IDEA: A powerful IDE with a free Community edition and a paid Ultimate edition.
NetBeans: Another free IDE, good for developing Java applications.

Installing an IDE:

Download the IDE from its official website. For example:
Run the installer and follow the setup instructions.
Launch the IDE and configure it for Java development (most IDEs will automatically detect the JDK installed on your system).

Step 3: Write and Run Your First Java Program

Let’s create a simple Java program to test your setup.

Using an IDE:

Open your IDE and create a new Java Project.
Create a new Java Class file (e.g., HelloAyush).

Write the following code:

public class HelloAyush {
    public static void main(String[] args) {
        System.out.println("Hello, Ayush!");
    }
}

Click Run or Execute in the IDE toolbar. You should see Hello, Ayush! printed on the console.

How to Install IntelliJ IDEA

IntelliJ IDEA is a powerful and user-friendly IDE widely used for Java development. It offers a free Community edition and a paid Ultimate edition.

Steps to Install IntelliJ IDEA:

Download IntelliJ IDEA
- Visit the official website: IntelliJ IDEA Downloads.
- Choose the Community edition (free) or the Ultimate edition (paid).
Install IntelliJ IDEA
- Run the downloaded installer.
- Follow the on-screen instructions to complete the installation.
Configure IntelliJ IDEA
- Launch IntelliJ IDEA and choose the default settings during the initial setup.
- Ensure that the IDE detects the JDK installed on your system. If not, manually add the JDK path under File > Project Structure > SDKs.
Install Plugins (Optional)
- IntelliJ IDEA supports various plugins to enhance your productivity. You can install them via File > Settings > Plugins.

Write and Run Your First Java Program Using IntelliJ IDEA

Let’s create a simple Java program to test your setup.

Using IntelliJ IDEA:

Open IntelliJ IDEA and create a new Java Project.
- Select File > New > Project.
- Choose Java and set the JDK.
Create a new Java Class file (e.g., HelloWorld).
- Right-click on the src folder, select New > Java Class, and name it HelloWorld.

Write the following code:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Run the program:
- Click the green Run button in the toolbar or right-click the file and select Run HelloWorld.main().
- You should see Hello, World! printed on the console.

Conclusion

You have successfully set up your Java development environment with IntelliJ IDEA. With the JDK, IntelliJ IDEA, , you are ready to start building Java applications. Practice regularly to improve your skills and create amazing projects!

What are the key differences between an Interface and an Abstract class?

Ayush Shrivastava — Mon, 06 Jan 2025 18:26:29 +0000

Interface vs Abstract Class

Interface

100% abstraction (prior to Java 8).
Can have default/static methods (Java 8+).
No constructors.
Multiple inheritance allowed.

Abstract Class

Partial abstraction.
Can have constructors and fields.
Single inheritance only.

Examples

Interface

interface Animal {
    void makeSound(); // Method declaration
}
class Dog implements Animal {
    public void makeSound() {
        System.out.println("Bark");
    }
}

Abstract Class

abstract class Vehicle {
    abstract void start(); // Abstract method
    void stop() {
        System.out.println("Vehicle stopped"); // Concrete method
    }
}
class Car extends Vehicle {
    void start() {
        System.out.println("Car started");
    }
}

When to Use What?

Use Interface When:

You need to define a contract for unrelated classes.
Multiple inheritance of type is required.
You want to provide default or static methods without affecting the implementing classes.

Use Abstract Class When:

Classes share a common base and need to share code.
You want to provide some implemented methods and enforce others to be overridden.
You need constructors or non-constant fields.

Conclusion

Both interfaces and abstract classes are powerful tools in Java, and choosing between them depends on your application's needs. Use interfaces to define behaviors across unrelated classes and abstract classes for shared code in a class hierarchy.

By understanding their differences and strengths, you can write cleaner and more maintainable code. Happy coding! 🚀