DEV Community: Marc Vincent Bentoy

Week 2: Spring Boot Essentials

Marc Vincent Bentoy — Tue, 22 Apr 2025 07:35:25 +0000

In the previous week, we explored the foundational ideas behind the Spring Framework—IoC, Dependency Injection, Beans, and the ApplicationContext. Now, let’s level up and move into the world of Spring Boot, a tool that supercharges the Spring experience with convention over configuration, faster development cycles, and production-ready features out of the box.

What is Spring Boot?

Spring Boot is not a replacement for the Spring Framework but a powerful extension that makes building and deploying Spring applications faster and easier. It removes the need for tedious configuration and lets you focus on writing business logic.

In short:

Spring is the foundation.

Spring Boot is the builder that lays everything down quickly for you.

Core Concepts We’ll Cover This Week

Spring Boot Starters
Auto-configuration
Devtools
Spring Initializr
A simple Hello World app

Spring Boot Starters

One of the coolest things about Spring Boot is its starter dependencies. Starters are pre-packaged sets of dependencies grouped together for common use cases.

Here are some common ones:

Starter	Purpose
`spring-boot-starter-web`	Build web, RESTful apps using Spring MVC
`spring-boot-starter-data-jpa`	Integrate JPA for database access
`spring-boot-starter-security`	Add security and authentication
`spring-boot-starter-test`	Setup for testing Spring applications

With one line in your pom.xml or build.gradle, you get all the essential libraries and configurations.

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

Auto-Configuration

One of Spring Boot’s magic features is auto-configuration. Based on the dependencies in your project, Spring Boot will try to automatically configure your application.

For example:

If you include spring-boot-starter-web, it configures a web server (Tomcat) for you.
If it sees an H2 dependency, it sets up an in-memory database automatically.

This is enabled by the annotation:

@SpringBootApplication

Which is actually a shortcut for:

@Configuration
@EnableAutoConfiguration
@ComponentScan

It tells Spring Boot to scan for beans and apply sensible default configurations.

Spring Devtools

Spring Boot Devtools is a developer-friendly tool that allows hot reload and better productivity. It automatically restarts your application when you make code changes, so you don’t need to restart the server manually.

Add this to your pom.xml:

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

Or in Gradle:

developmentOnly("org.springframework.boot:spring-boot-devtools")

It also supports:

Automatic browser refresh
Disabling cache for static resources (CSS/JS)
Enhanced logging for debugging

Spring Initializr: Your Starter Buddy

You don’t need to manually create a project structure—use Spring Initializr!

Just select your dependencies, set your project metadata (group, artifact, Java version), and download a ready-to-run Spring Boot project.

Example setup:

Project: Maven
Language: Java
Spring Boot: 3.x
Dependencies: Spring Web, Spring Boot Devtools

Boom—you’re good to go.

Let’s Build Your First Spring Boot App

Here’s a basic REST controller:

@RestController
public class HelloController {

    @GetMapping("/")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}

And your entry point:

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

Start it with:

./mvnw spring-boot:run

Visit http://localhost:8080/ and you should see your message.

Final Thoughts

Spring Boot allows you to go from zero to production-ready in minutes. Once you grasp the starters, auto-config, and use devtools for faster feedback loops, it becomes a joy to build web services.

But remember: Spring Boot does a lot of things for you under the hood. As we continue this series, we’ll start pulling back the curtain to see exactly what’s going on in that "magic."

Up Next: Week 3 - Configuration Management

Next week, we’ll dive into application properties, YAML, profiles, and the @Value annotation. You’ll learn how to create environment-specific configs and keep secrets out of your code.

Week 1: Spring Core

Marc Vincent Bentoy — Mon, 07 Apr 2025 07:59:19 +0000

Week 1: Demystifying the Spring Framework – Understanding the Core Concepts

Welcome to the first week of my journey into the Spring ecosystem! This article marks the beginning of my attempt to truly understand how Spring Framework works under the hood, particularly focusing on some of its most foundational concepts: IoC, Dependency Injection, Beans, and the ApplicationContext.

Week 1: Demystifying the Spring Framework – Understanding the Core Concepts
- 🌱 Spring Framework vs. Spring Boot
- 🎮 What is Inversion of Control (IoC)?
- 💉 Dependency Injection (DI)
  - Example Constructor Injection:
  - Example Setter Injection:
  - Example Field Injection:
- 🫘 What are Beans?
- ♻️ ApplicationContext: The Spring Container
- 💭 Final Thoughts
- ⏭️ Up Next: Week 2 - Spring Boot Basics

Before diving in, let’s first clarify a common confusion: Spring Framework vs.
Spring Boot.

🌱 Spring Framework vs. Spring Boot

Many newcomers (like myself) initially get confused between Spring Framework and Spring Boot, since they're often used together. Here's a simple breakdown:

Aspect	Spring Framework	Spring Boot
Purpose	A comprehensive, modular Java framework for building enterprise apps	A layer on top of Spring that simplifies setup and configuration
Configuraiton	Requires manual setup of beans, XML or Java-based config	Convention over configuration (sensible defaults, auto-config)
Starter Packs	None	Comes withe "starters" for web, JPA, security, etc.
Use Case	When you need full control over the setup and structure	When you want to get started quickly with minimal config
Built On	Core Spring modules	Core Spring modules (it's not a replacement!)

So in essence, Spring Boot helps you build apps faster, but it's still powered by Spring Framework underneath.

Here's an illustration of how the dependency works:

🎮 What is Inversion of Control (IoC)?

IoC is the design principle at the heart of Spring. Normally in programming, you control how and when objects are created. But with IoC, you delegate that control to the framework.

Instead of writing code like this:

Service myService = new Service();

Spring handles the object creation and injects it wherever it’s needed. This
inversion of control reduces tight coupling and increases flexibility. Thus, you
simply specify the dependency on your constructor and Spring will supply if for
you.

public Controller(Service service) {
    this.service = service;
}

💉 Dependency Injection (DI)

DI is a specific implementation of IoC where the framework injects the dependencies (i.e., other objects a class needs) automatically.

There are different types of DI:

Constructor Injection (recommended)
Setter Injection
Field Injection (less preferred)

Example Constructor Injection:

@Component
public class UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

Here, Spring automatically injects a UserRepository instance when creating UserService. However, this is no longer necessary if the target bean has only one constructor, full link here.

Example Setter Injection:

public class SimpleMovieLister {
    private MovieFinder movieFinder;

    @Autowired
    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }

    // ...
}

Example Field Injection:

public class MovieRecommender {

    private final CustomerPreferenceDao customerPreferenceDao;

    @Autowired
    private MovieCatalog movieCatalog;

    @Autowired
    public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {
        this.customerPreferenceDao = customerPreferenceDao;
    }

    // ...
}

🫘 What are Beans?

A Bean is simply an object that is managed by the Spring container. You define a bean by annotating a class with @Component, @Service,
@Repository, or by using @Bean in a configuration class.

@Component
public class EmailService {
    public void sendEmail(String to, String message) {
        // send email
    }
}

This class becomes a Spring-managed bean, meaning Spring takes care of its lifecycle and dependencies.

♻️ ApplicationContext: The Spring Container

The ApplicationContext is the core interface of the Spring container. It holds all the beans and manages their life cycles.

Think of it as a registry that:

Creates and wires beans
Manages their scopes
Provides internationalization
Handles event propagation

When you create a Spring Boot app, ApplicationContext is automatically initialized for you. In traditional Spring, you might initialize it manually like this:

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
MyService service = context.getBean(MyService.class);

💭 Final Thoughts

Understanding IoC, DI, Beans, and the ApplicationContext helps demystify a large part of Spring. These concepts might seem abstract at first, but they are the foundation that powers the rest of the framework—and every feature you’ll use in Spring Boot.

⏭️ Up Next: Week 2 - Spring Boot Basics

Next week, we’ll explore how Spring Boot simplifies setup using auto-configuration, starter dependencies, and devtools.

If you have any feedback, corrections, or ideas, feel free to share them. See you in the next one!

Demystifying Spring: A Beginner's Journey into Spring Framework and Spring Boot

Marc Vincent Bentoy — Sun, 06 Apr 2025 17:00:25 +0000

⛓️ What this series is for?

This series of articles is my personal way of documenting and sharing my understanding of the Spring Framework and Spring Boot. As a beginner with this framework, I believe that uncovering how things work behind the scenes will significantly boost my ability to develop faster, integrate different technologies properly, and write clean, efficient code. If you find any incorrect information or have suggestions, I’d be more than grateful to hear them!

🗺️ My journey

My journey into developing web services began with using web frameworks directly—specifically, Ruby on Rails for the backend as a REST API, paired with VueJS for the frontend. At the time, I was a part-time developer while studying at university and had little fundamental knowledge of how the web actually works behind the scenes. This piqued my interest in web technologies and led me to dive deeper into website development, shifting from a Computer Engineering path that typically focuses more on microprocessors and IoT.

As I continued relying on frameworks and libraries, I gradually started to demystify the wonders of data transmission and HTTP. This opened up a new perspective for me: understanding the fundamentals enables you to apply concepts across different technologies. Much like how grasping the purpose of programming languages makes it easier to pick up new ones, this understanding allowed me to quickly adapt to other web frameworks—such as Go with Fiber, Python with Flask/Django/FastAPI, JavaScript with Express, and most recently, Java with Spring Boot.

However, I find Java with Spring Boot—and the Spring Framework in general—to be quite unique. While it shares some characteristics with Python web frameworks, like the use of annotations, it has a lot of abstractions that I’m eager to uncover. What I particularly like is the vast ecosystem of libraries that are battle-tested and production-ready. So far, I’ve mostly been using the common annotations for CRUD operations and sticking to the familiar MVC pattern. In reality, my usage of Spring has only scratched the surface.

That’s why I’m writing this series: to go deeper, understand the “why” behind the magic, and hopefully help others along the way.

🗓️ Weekly Plan

Week	Focus Area	Key Topics	Outcome
1	Fundamentals	IoC, DI, Beans, ApplicationContext	Understand core Spring concepts
2	Spring Boot Basics	Spring Boot auto-configuration, starters, devtools	Build your first Spring Boot app
3	Configuration	Properties, Profiles, YAML, @Value	Manage environment configs
4	Data Layer	Spring JDBC Template, Spring Data JPA, Repositories, Entity Relationships	CRUD with databases
5	Web Layer	Spring MVC, REST Controllers, Request Mapping	Create RESTful services
6	Advanced Topics	AOP, Transactions, Error Handling	Write robust, scalable code
7	Spring Security	Auth, JWT, Method-level security	Secure your apps
8	Final Project	REST API project	Consolidate everything

💭 Final Thoughts

I hope you find this series insightful and helpful in your own Spring learning journey. Cheers! ☕