From an empty folder to a running endpoint

Shared core#

The chapter below remains the canonical explanation for both goals. Keep its model, examples, and trade-offs shared; only the deliberate practice changes with the route.

Learn deeply: build evidence#

Use this chapter’s TaskFlow work to make one small, observable change. Run the stated acceptance checks before recording practice.

Prepare for interviews: explain the trade-off#

Without notes, explain the boundary this chapter protects, one concrete implementation decision, and the cost of a tempting shortcut. Then answer one follow-up using the chapter’s own example.

Section 1Generate the project with Spring Initializr#

start.spring.io↗ is a web form that hands you a ready-made project skeleton as a .zip. Every choice below maps to something you now understand from Chapter 1.

1. Open start.spring.io and set the top-left options

   Project: Maven. Language: Java. Spring Boot: pick the current stable release without SNAPSHOT next to it (a snapshot is a preview build). These notes work with modern Boot 4.x; if you follow an older Boot 3.x tutorial, the core annotations here are the same.

2. Fill in Project Metadata

   Group: com.example. Artifact: taskflow. This becomes your base package com.example.taskflow — the root of the folder map from Chapter 1. Packaging: Jar. Java: 17 (or your installed version).

3. Add exactly one dependency: Spring Web

   Click Add Dependencies → search Spring Web → add it. That single starter pulls in Spring MVC and an embedded Tomcat server, which is why your app can serve HTTP without you installing a server. We add more starters in later chapters — one per new capability.

4. Generate, then unzip

   Click Generate. A taskflow.zip downloads. Unzip it somewhere sensible and open the taskflow folder in your IDE. IntelliJ will say "Maven project detected" — let it import; it downloads dependencies once (give it a minute).

Section 2Meet every file the generator made#

Open the project. It looks like this. Nothing here is optional decoration — let's name each piece.

The two files that matter today#

package com.example.taskflow;

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

@SpringBootApplication
public class TaskflowApplication {

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

The pom.xml is the build file. You rarely edit it by hand except to add dependencies — here's the one line that came from choosing Spring Web:

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

Section 3Run it once — before writing anything#

Run the app now, empty. This proves the setup works and teaches you what a healthy startup looks like, so a broken one is obvious later.

In the IDE: open TaskflowApplication.java and click the green ▶ next to main(). Or from the project root in a terminal:

Now visit http://localhost:8080 in a browser. You'll get a Whitelabel Error Page saying 404. That is success. The server is running; you simply haven't told it about any URL yet. Stop the app (red ■, or Ctrl-C) and let's give it one.

Section 4Write your first controller#

Time for a real endpoint. Create a controller package and a class inside it. In IntelliJ: right-click the com.example.taskflow package → New → Package → name it controller, then add a class PingController.

package com.example.taskflow.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class PingController {

    @GetMapping("/ping")
    public String ping() {
        return "pong";
    }
}

Run the app again (▶) and visit http://localhost:8080/ping:

That round trip — browser → Tomcat → your @GetMapping method → back — is the top rung of Fig 1 from Chapter 1. Everything we add from here just extends the same trip downward.

Section 5Return JSON, and take a parameter#

Real APIs return JSON objects, not bare strings, and they read input from the URL. Add one more method to prove both — no new file, just extend PingController for now (we'll split things properly next chapter).

import org.springframework.web.bind.annotation.RequestParam;
import java.util.Map;

@GetMapping("/greet")
public Map<String, String> greet(@RequestParam(defaultValue = "world") String name) {
    return Map.of("message", "hello, " + name);
}

Section 6Worked micro-exercise — done with you, end to end#

This is the format the practice chapters use, shown here fully solved so you know exactly what "end to end" means. Read it as a demonstration, then do it on your own machine.

@GetMapping("/health")
public Map<String, String> health() {
    return Map.of("status", "UP", "service", "taskflow");
}