DEV Community: Md. Rakibul Hasan

Spring vs Spring Boot

Md. Rakibul Hasan — Tue, 16 Jun 2026 17:12:20 +0000

Spring and Spring Boot are popular frameworks in the Java ecosystem that simplify the development of enterprise and microservices-based applications. They provide powerful features to reduce boilerplate code and improve productivity while building robust systems.

Enables development of scalable and production-ready applications
Reduces complexity through simplified configuration and auto-setup
Promotes modular design using reusable components

Spring
Spring is a comprehensive Java framework that provides support for building robust and scalable enterprise applications. It focuses on dependency injection, aspect-oriented programming, and modular architecture.

Dependency Injection (DI): Simplifies object creation and management, promoting loose coupling.
Modular Framework: Offers various modules like Spring MVC, Spring Security, Spring Data, allowing selective use.
Flexible Configuration: Supports XML, annotations, and Java-based configuration for application setup.

Example: Spring application manually configured with beans and controllers:

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }
}

@Controller
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public String getUsers(Model model) {
        model.addAttribute("users", userService.getAllUsers());
        return "userList"; // JSP or HTML view
    }
}

// Main class deployed as WAR on external server like Tomcat
public class Main {
    public static void main(String[] args){

        // Deploy this app manually to an external server
    }
}

Introduction to Spring Boot

Md. Rakibul Hasan — Tue, 16 Jun 2026 16:45:45 +0000

Spring is one of the most popular frameworks for building enterprise applications, but traditional Spring projects require heavy XML configuration, making them complex for beginners. Spring Boot solves this problem by providing a ready-to-use, production-grade framework on top of Spring, eliminating boilerplate configuration and enabling rapid development.

Reduces development time by simplifying project setup
Provides opinionated defaults for faster decision-making
Makes it easier to build and deploy standalone applications

Features:

Spring Boot provides all the features of Spring while being significantly easier to use. Here are its key features:

Auto-Configuration: Spring Boot automatically configures the application based on the dependencies present in the project
Embedded Server: Spring Boot includes embedded servers like Tomcat, Jetty, or Undertow, allowing applications to run without external server installation.
Easy Deployment: Spring Boot applications can be packaged as JAR or WAR files and deployed directly to servers or cloud environments. By 2025, it offers seamless integration with Docker and Kubernetes for easier cloud-native deployment and scaling.
Standalone Application: Applications can run as executable JAR files using a simple main() method.
Microservice-Based Architecture: Spring Boot supports building independent, modular services instead of a monolithic application, improving scalability, maintainability, and deployment flexibility.

Evolution of Spring Boot

Spring Boot was introduced in 2013 following a JIRA request by Mike Youngstrom to simplify Spring bootstrapping.

Major Spring Boot Versions:

Spring Boot 1.0 (April 2014)
Spring Boot 2.0 (March 2018)
Spring Boot 3.0 (November 2022) (Introduced Jakarta EE 9+, GraalVM support)
Latest Version (2025): Spring Boot 3.x (Enhancements in observability, native images and containerization)

Spring Boot Architecture

To understand the architecture of Spring Boot, let’s examine its different layers and components.

Let’s understand the layered architecture in application development, which helps organize code by separating responsibilities into different layers, improving maintainability and scalability.

Client Layer: The external user or system that sends HTTP/HTTPS requests to interact with the application.
Controller Layer (Presentation Layer): Handles client requests, processes them, and forwards them to the service layer while returning responses.
Service Layer (Business Logic Layer): Contains the business logic and coordinates operations between the controller and repository layers.
Repository Layer (Data Access Layer): Manages database operations such as create, read, update, and delete (CRUD).
Model Layer (Entity Layer): Represents the application's data structure and maps Java objects to database tables.
Database Layer: The storage system where application data is permanently stored and retrieved.

Request Flow in Spring Boot

Client ->Controller ->Service ->Repository ->Database ->Response

A Client makes an HTTPS request (GET/POST/PUT/DELETE).
The request is handled by the Controller, which is mapped to the corresponding route.
If business logic is required, the Controller calls the Service Layer.
The Service Layer processes the logic and interacts with the Repository Layer to retrieve or modify data in the Database.
The data is mapped using JPA with the corresponding Model/Entity class.
The response is sent back to the client. If using Spring MVC with JSP, a JSP page may be returned as the response if no errors occur.

Applications of Spring Boot

Spring Boot is widely used in modern software development because of its simplicity, scalability and production-ready features. Here are some of its major applications:

Enterprise Applications: Build complex applications such as Hospital Management Systems, Banking Systems or ERP solutions with minimal configuration.
Cloud-Native Applications: Seamless integration with Docker, Kubernetes and cloud platforms (AWS, Azure, GCP) for deployment and scaling.
Real-Time Applications: Supports Reactive Programming for chat applications, streaming platforms, IoT systems and event-driven systems.
Batch Processing Applications: With Spring Batch, Spring Boot is used for ETL (Extract, Transform, Load), report generation and large data processing.

How I Learned Unit Testing in Spring Boot by Building One Simple Project

Md. Rakibul Hasan — Sat, 06 Jun 2026 15:05:58 +0000

What Building a Simple Spring Boot CRUD API Taught Me About Unit Testing

When I first started learning Spring Boot, I constantly heard senior developers talking about Unit Testing, JUnit, Mockito, and Test-Driven Development (TDD).

The problem?

Most tutorials were either too simple or too complicated.

So instead of watching endless videos, I decided to build a small project and learn testing through actual code.

The Project

I created a simple Task Management API with the following features:

Create Task
Update Task
Delete Task
Get Task by ID
List All Tasks

Nothing fancy.

The goal wasn't to build another Todo application.

The goal was to learn testing.

What I Learned

1. Not Everything Needs a Spring Context

My first mistake was using @SpringBootTest everywhere.

As a result, tests became slower because the entire Spring application context was loading for every test.

For service-layer testing, plain JUnit 5 and Mockito were more than enough.

Lesson: Use the lightest testing approach that gets the job done.

2. Mock Dependencies, Not the Class Under Test

One of the biggest testing concepts I learned was that the class being tested should be real, while its dependencies should be mocked.

Example:

@Mock
private TaskRepository taskRepository;

@InjectMocks
private TaskService taskService;

This allowed me to verify business logic without connecting to a database.

Lesson: Test the service. Mock the repository.

3. Test Behavior, Not Implementation

Initially, I focused on internal method calls and implementation details.

Later, I realized that tests become more maintainable when they verify outcomes instead.

Instead of checking how many methods were called internally, I started verifying whether the correct result was produced.

Lesson: Users care about results, not implementation details.

4. Edge Cases Matter More Than Happy Paths

Most bugs don't happen during ideal scenarios.

They happen when unexpected input appears.

Some examples I tested:

Task not found
Null input
Empty task title
Duplicate task creation

Writing tests for these scenarios increased my confidence in the application significantly.

Lesson: Edge cases often reveal the most valuable bugs.

5. Testing Improves Design

This was the biggest surprise.

The more tests I wrote, the more obvious poor design decisions became.

Large service classes became difficult to test.

Complex methods became harder to mock and verify.

Those pain points naturally pushed me toward better architecture and cleaner code.

Testing didn't just improve code quality.

It improved the design itself.

Lesson: Good tests encourage good architecture.

My Recommended Learning Path

If you're new to Spring Boot testing, here's the path I would recommend:

Learn JUnit 5 basics
Learn Mockito fundamentals
Build a small CRUD project
Write service-layer tests
Add controller tests using MockMvc
Learn integration testing afterward

Don't start with advanced topics.

Start small.

Write tests consistently.

Improve gradually.

Final Thoughts

Unit testing felt intimidating when I started.

Today, I see it as one of the most valuable skills a backend developer can learn.

If you're struggling with testing, stop watching tutorials for a moment.

Build a small project.

Write one test.

Then write another.

You'll learn much faster by doing than by consuming content.

Happy coding! 🚀

Question for the community:
What was the biggest challenge you faced when learning unit testing in Spring Boot?

What to do if Java command is not recognized by terminal.

Md. Rakibul Hasan — Wed, 05 Aug 2020 10:13:44 +0000

Now a days we install java in our windows for our own work.But it's quite annoying while it's not recognized by the terminal.Sometimes we even run java file from terminal so it needs to be fixed.
So here is the thing that you can do.
Step 1:
First of all right click on this pc.

Step 2:
Go to properties and click advanced system settings.

Step 3:
Now click on environment variables.

Step 4:
Now look at user variables. Look if there is any path variable.
If there is path variable then look at Method 1..
If there is no path variable then look at Method 2..

Method 1:
in your case if there is path variable.You have to select path variable and click edit.

Now click on new . And paste the location of your java bin folder.

Click and copy the location.In my case it's location is:
C:\Program Files\Java\jdk-14.0.1\bin

Now click on ok .Then open the terminal.
write--> "Java -version".

it should show your java version.
If it's not then reinstall java by downloading java executable file from https://www.oracle.com/java/technologies/javase-downloads.html

Method 2
If there is no path variable then click on new.

write the variable name as "path" And paste the location of your java bin folder in variable value box.

Click and copy the location.In my case it's location is:
"C:\Program Files\Java\jdk-14.0.1\bin"

So i have wrote the variable name as "path" and pasted "C:\Program Files\Java\jdk-14.0.1\bin"

Hope it will help you. Thanks !