Learn Spring Boot - Prerequisite Skills & Environment Setup

#Introduction

Welcome to the Learn Spring Boot series! This series will take you to mastery of Spring Boot — the most popular Java framework for building web applications, REST APIs, and microservices — from the fundamentals to production readiness. There are 24 episodes in total, organized into six phases.

But before touching spring-boot-starter-web, there are some basic skills and software you must have. Why are these prerequisites important? Because Spring Boot isn't just a library — it's a framework that manages your entire application lifecycle: the bean container, the web server, configuration, security, and database access. If you haven't yet understood Java fundamentals and dependency injection, most of Spring Boot's magic will feel like a black box.

Episode 0 is your roadmap: we'll make sure your skills are solid, set up JDK, IDE, a local database, and then verify your first Spring Boot project. Once this episode is done, the entire series can be followed comfortably.

#Basic Skills You Must Master

#Java and Object-Oriented Programming

Spring Boot is a Java framework, so you must be comfortable with modern Java — at least Java 8, but ideally Java 17 or 21. Master the basic syntax such as classes, interfaces, generics, lambdas, and streams. Most importantly: understand the concepts of OOP — inheritance, polymorphism, encapsulation, and composition — because all of Spring's design revolves around classes and interfaces.

java -version
javac -version

The output must show version 17 or 21. Spring Boot 3.x requires a minimum of Java 17, so make sure your JDK version meets the requirement.

#Dependency Injection and Inversion of Control

These two concepts are the heart of Spring. Inversion of Control (IoC) means the flow of object creation is no longer your code's responsibility, but the framework's. Dependency Injection (DI) is how the framework provides dependencies to a class — usually through the constructor — so the class doesn't have to create its own dependencies. We'll break this concept down in depth in episode 4.

#Build Tool and Git

Spring Boot can be built with Maven or Gradle. You don't need to understand everything about them, but you must know how to read pom.xml or build.gradle and run build commands. Every Spring Boot project ships with a wrapper — mvnw for Maven and gradlew for Gradle — so you don't need to install those tools globally. For version control, get into the habit of using Git.

#Software You Need to Prepare

#JDK 21 LTS

Use Java 21 LTS — the stable version recommended for Spring Boot 3.x. You can use a distribution from Oracle, OpenJDK, or vendors such as Eclipse Temurin and Amazon Corretto. Choose an LTS version to get long-term support and routine security updates.

java --version
./mvnw --version

If the project folder doesn't exist yet, the ./mvnw command can't be run. Don't worry — we'll create the Spring Boot project in the verification section, and ./mvnw --version will show the Maven version along with the Java version in use.

#IDE: IntelliJ IDEA or VS Code

Pick the one IDE you're most comfortable with. IntelliJ IDEA Community is the most popular choice with outstanding built-in Spring Boot support. A lighter alternative: VS Code with the Spring Boot Extension Pack and Java Extension Pack. Both support auto-completion, run configurations, and debugging for Spring Boot applications.

#Local Database and Docker

For episode 6 and beyond, you'll need a local database. At minimum H2 — the in-memory database automatically provided by Spring Boot — or PostgreSQL and MySQL for more realistic practice. Also prepare Docker, because it's used for a production-like database, Testcontainers in episode 17, and container deployment in episode 20.

docker --version

Windows, macOS, and Linux are all supported. Spring Boot runs anywhere Java runs, and for a comfortable experience at least 8GB of RAM is recommended because the JVM, IDE, and Docker run together.

#Creating Your First Project with Spring Initializr

The standard way to create a Spring Boot project is through Spring Initializr at https://start.spring.io — via the web UI or the command line. The example command below creates a Maven project with Java 21 and initial dependencies for web, JPA, H2, validation, and devtools:

curl https://start.spring.io/starter.tgz \
  -d type=maven-project -d language=java \
  -d bootVersion=3.4.1 -d javaVersion=21 \
  -d groupId=com.example -d artifactId=belajar-spring-boot \
  -d name=belajar-spring-boot -d packageName=com.example \
  -d dependencies=web,data-jpa,h2,validation,devtools \
  | tar -xzvf -
cd belajar-spring-boot

The generated project contains pom.xml, the main class BelajarSpringBootApplication, the src/main/java, src/main/resources folders, and the mvnw file. We'll break this structure down in episode 3.

#Verifying the Environment

Before moving on to episode 1, run a quick verification to make sure everything is ready. First, make sure the dependencies are downloaded and the application can run:

./mvnw spring-boot:run

The ./mvnw spring-boot:run command downloads the dependencies, compiles, and runs the application on port 8080. When the log shows Started BelajarSpringBootApplication, the application is running with embedded Tomcat — no separate web server installation needed.

Open another terminal and test the endpoint: without writing any controller, Spring Boot provides a default error page, but the important thing is that the server responds:

curl -I http://localhost:8080

If the response shows HTTP/1.1 404 or 200, the server is alive. A 404 response is actually expected because there's no endpoint we've defined yet — we'll create one in episode 3. Stop the application by pressing Ctrl+C in the terminal running ./mvnw spring-boot:run.

#Closing

In episode 0 you've laid the foundation for the entire series: understood the basic Java, OOP, dependency injection, and build tool skills; installed JDK 21, IDE, Docker, and a local database; created your first project via Spring Initializr; and verified that a Spring Boot application can run with embedded Tomcat.

Key takeaways:

• Spring Boot 3.x requires a minimum of Java 17; use JDK 21 LTS for long-term comfort.
• Master OOP, dependency injection, and Inversion of Control before diving into the framework.
• Use Maven or Gradle through the ./mvnw or ./gradlew wrapper without a global install.
• Create projects with Spring Initializr, either via the web or curl.
• Prepare H2, PostgreSQL, and Docker for the database, testing, and deployment episodes.
• First verification: run ./mvnw spring-boot:run and make sure the server is active on port 8080.

In the next episode, episode 1, we'll discuss the history, background, and why you need Spring Boot — from the painful era of Spring Framework XML configuration, the birth of Spring Boot with auto-configuration and starter dependencies, to its position as the de facto standard for modern Java backend development. Make sure your environment is ready, because the Learn Spring Boot journey has only just begun!