Forem: Akash Pratap Singh

Creational Design Patterns in Java: Industry Stories That Make Them Stick

Akash Pratap Singh — Sun, 30 Nov 2025 13:23:12 +0000

In software engineering, creating objects isn't just a mechanical “new” keyword. In real systems—especially those that grow over years—object creation becomes a design problem. Senior engineers don’t just build objects; they orchestrate them. That’s where creational design patterns come in.

To keep things both accurate and enjoyable, each pattern below is explained through a real-world workplace story—situations developers actually joke about during standups.

1. Singleton — The Office Printer Story

Every company has that one shared printer. Nobody wants to buy five printers for five teams. Instead, everyone uses the same one. This is the Singleton pattern: only one instance of something should ever exist.

In industry, you’ll find Singleton used for things like:

app configuration
logging systems
driver managers
global caches
connection pools (conceptually)

But there are three forms of this pattern engineers run into.

1.1 Singleton Without Thread Safety — “The Startup Phase”

Imagine a tiny startup with three developers. Nobody prints at the same moment, so they don’t bother with strict rules. This is the simplest form of Singleton.

Works fine… until multiple threads show up.

public class Config {
    private static Config instance;

    private Config() {}

    public static Config getInstance() {
        if (instance == null) {
            instance = new Config();
        }
        return instance;
    }
}

Clear, easy… and dangerous in multi-threaded apps.

1.2 Singleton with Synchronized Method — “The Strict Security Guard”

As the team grows, people start hitting the printer at the same time.

Management hires a guard who blocks the room and lets in only one person at a time.

public class Config {
    private static Config instance;

    private Config() {}

    public static synchronized Config getInstance() {
        if (instance == null) {
            instance = new Config();
        }
        return instance;
    }
}

This is thread-safe but slow—every call waits in line, even if the instance is already created.

1.3 Double-Checked Locking — “The Smart Guard Who Checks First”

Now the company upgrades the system.

The guard only stops people if the printer room is empty.

If it's occupied, no need to lock anything.

public class Config {
    private static volatile Config instance;

    private Config() {}

    public static Config getInstance() {
        if (instance == null) {                 // First check
            synchronized (Config.class) {      // Lock only if needed
                if (instance == null) {        // Second check
                    instance = new Config();
                }
            }
        }
        return instance;
    }
}

This is the production-grade Singleton used in serious Java projects.

2. Factory Method — The HR Recruitment Desk

Think of a company’s HR team. HR doesn’t create employees manually. They just choose the right type of worker based on requirements:

Need someone who writes code → Developer
Need someone who designs UI → Designer

The method decides which object to create.

abstract class Employee {
    abstract void work();
}

class Developer extends Employee {
    void work() { System.out.println("Writing code"); }
}

class Designer extends Employee {
    void work() { System.out.println("Designing UI"); }
}

class EmployeeFactory {
    public static Employee hire(String role) {
        switch (role) {
            case "dev": return new Developer();
            case "design": return new Designer();
            default: throw new IllegalArgumentException("Unknown role");
        }
    }
}

This is used everywhere in industry—payment integrations, notification senders, cloud providers, database drivers.

3. Abstract Factory — Setting Up a Whole Office Floor

When a company opens a new office floor, they don’t randomly mix furniture.

They get a complete package:

Modern chairs
Modern tables
Modern lights

Or Classic everything.

Consistency matters.

That's Abstract Factory: create families of related objects together.

interface FurnitureFactory {
    Chair createChair();
    Table createTable();
}

class ModernFurnitureFactory implements FurnitureFactory {
    public Chair createChair() { return new ModernChair(); }
    public Table createTable() { return new ModernTable(); }
}

class ClassicFurnitureFactory implements FurnitureFactory {
    public Chair createChair() { return new ClassicChair(); }
    public Table createTable() { return new ClassicTable(); }
}

UI theme systems, cross-platform toolkits, cloud SDKs—all use this pattern.

4. Builder — Customizing a Burger

Walk into a burger shop. You don’t shout all ingredients in one breath.

You build your burger step-by-step:

add cheese
remove onions
extra sauce

That’s exactly how complex objects are built in clean Java code.

class Burger {
    private final boolean cheese;
    private final boolean onion;
    private final boolean sauce;

    private Burger(Builder b) {
        this.cheese = b.cheese;
        this.onion = b.onion;
        this.sauce = b.sauce;
    }

    static class Builder {
        boolean cheese;
        boolean onion = true;
        boolean sauce;

        Builder addCheese() { cheese = true; return this; }
        Builder noOnion() { onion = false; return this; }
        Builder addSauce() { sauce = true; return this; }

        Burger build() { return new Burger(this); }
    }
}

Used widely in:

HTTP clients
JSON builders
database query builders
document generators

5. Prototype — Copying Last Year’s Document

During budget season, teams don't start a fresh file every year.

They duplicate last year's document and just update the numbers.

Prototype works the same way: copy an existing object instead of building a fresh one.

class Report implements Cloneable {
    private String data;

    public Report(String data) { this.data = data; }

    public Report clone() {
        return new Report(this.data);
    }
}

Game engines, document editors, graphic tools—all love this pattern.

Why These Patterns Matter in Real Projects

These aren’t academic tricks.

They’re weapons developers use daily because they solve real-world problems:

keeping memory usage stable,
reducing duplicate code,
managing complex object setups,
improving testability,
making systems flexible instead of rigid.

When you work in a growing codebase, you start seeing why these patterns have survived decades.

Final Thoughts

Creational design patterns help developers control how objects come to life. Each one has a real industry story behind it:

Singleton is the shared office printer.
Factory Method is HR deciding the right hire.
Abstract Factory is choosing themed office furniture.
Builder is customizing a burger.
Prototype is duplicating last year's budget file.

Once these stories click, the patterns stop feeling abstract.

They feel like natural ways to organize software so it grows cleanly instead of chaotically.

Building a Chat REST API with Spring Boot and Google Generative AI

Akash Pratap Singh — Wed, 01 Oct 2025 06:04:22 +0000

Generative AI is transforming how applications interact with users—enabling natural conversations, intelligent responses, and dynamic content generation. With Spring Boot as a backend framework and Google Generative AI (Gemini models) as the intelligence layer, you can build a simple chat API that lets clients send messages and get AI-powered responses.

In this article, we’ll walk through how to set up a REST API in Spring Boot that connects to Google’s Gemini API for conversational AI.

Why Spring Boot + Google GenAI?

Spring Boot makes it easy to set up REST APIs quickly with minimal configuration.
Google Generative AI (Gemini) provides state-of-the-art models for natural conversations, text generation, and reasoning.
Together, they give you a lightweight but powerful way to integrate AI into your apps.

Prerequisites

Before starting, make sure you have:

Java 17+ installed
Spring Boot 3.x
A Google Cloud project with the Generative AI API enabled
A Gemini API Key (exported as an environment variable)

export GEMINI_API_KEY="your-google-genai-api-key"

Step 1: Create a Spring Boot Project

Generate a project using Spring Initializr:

Project: Maven
Dependencies: Spring Web and Lombok (optional for less boilerplate)

Step 2: Add Dependency for Google GenAI Client

In your pom.xml, include:

<dependency>
    <groupId>com.google.genai</groupId>
    <artifactId>genai</artifactId>
    <version>0.1.0</version> <!-- check latest available -->
</dependency>

This gives access to the Google Generative AI SDK.

Step 3: Application Properties

Configure your API key inside application.properties:

spring.application.name=chat-api
gemini.api.key=${GEMINI_API_KEY}

Step 4: Create a Chat Request DTO

package com.example.chatapi;

import lombok.Data;

@Data
public class ChatRequest {
    private String message;
}

Step 5: Implement the Chat Service

package com.example.chatapi;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import com.google.genai.Client;
import com.google.genai.types.GenerateContentResponse;

@Service
public class ChatService {

    private final Client client;

    public ChatService(@Value("${gemini.api.key}") String apiKey) {
        this.client = new Client(apiKey); // initialize with API key
    }

    public String askAI(String userMessage) {
        GenerateContentResponse response = client.models.generateContent(
                "gemini-2.5-flash", // choose Gemini model
                userMessage,
                null
        );
        return response.text();
    }
}

Step 6: Expose REST API Endpoint

package com.example.chatapi;

import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/chat")
@RequiredArgsConstructor
@CrossOrigin(origins = "*") // You can add your frontend url here
public class ChatController {

    private final ChatService chatService;

    @PostMapping("/ask")
    public ResponseEntity<String> ask(@RequestBody ChatRequest chatRequest) {
        String reply = chatService.askAI(chatRequest.getMessage());
        return ResponseEntity.ok(reply);
    }
}

Step 7: Test the Chat API

Start your application:

mvn spring-boot:run

Send a request with curl or Postman:

curl -X POST http://localhost:8080/api/chat/ask \
     -H "Content-Type: application/json" \
     -d '{"message": "Hello, can you explain what Spring Boot is?"}'

✅ You should receive a response generated by the Gemini model.

Conclusion

By combining Spring Boot with Google’s Generative AI, you can quickly build a REST API that powers intelligent chat experiences. This foundation can be expanded into customer support bots, productivity assistants, or interactive educational tools—all backed by Gemini’s state-of-the-art AI capabilities.