Spring Foundation

Start here: seven small Spring stages

Build one small idea at a time. Start with a fixed web page, then let Java handle a request, read numbers and finally render a calculated result. Each stage has a complete project ZIP; stages 1–5 use no template engine. Stage 6 introduces Model and Thymeleaf with a product catalog. Stage 7 applies them to the calculator.

server.port=8081

If 8081 is occupied, use another available value such as 8082. Save and restart. The browser address must use your chosen port. Stage 5 defaults to 8084, Stage 6 to 8085, and Stage 7 to 8082.

1. Stage 1: serve Home and About Us as static HTML
2. Stage 2: let a controller handle a request
3. Stage 3: read two query parameters and return their sum
4. Stage 4: read numbers from the URL path
5. Stage 5: submit a form and return the answer directly
6. Stage 6: product table and details
7. Stage 7: apply Model and Thymeleaf to the calculator

Download all seven beginner stages

GET / -> static/index.html -> Home page
GET /aboutus.html -> static/aboutus.html -> About Us page

<!doctype html>
<html lang="en">
<head><meta charset="UTF-8"><title>Home</title></head>
<body>
  <h1>Hello World</h1>
  <a href="/aboutus.html">About Us</a>
</body>
</html>

<!doctype html>
<html lang="en">
<head><meta charset="UTF-8"><title>About Us</title></head>
<body>
  <h1>About Us</h1>
  <p>This is our first Spring website.</p>
  <a href="/">Home</a>
</body>
</html>

GET /aboutus -> aboutUs() -> forward:/aboutus.html -> same HTML page

package com.edupoly.hello;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class PageController {
    @GetMapping("/aboutus")
    public String aboutUs() {
        System.out.println("Someone requested the About Us page");
        return "forward:/aboutus.html";
    }
}

GET /add?a=10&b=20 -> add(10, 20) -> return 30 -> browser displays 30

package com.edupoly.hello;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class CalculatorController {
    @GetMapping("/add")
    @ResponseBody
    public int add(@RequestParam("a") int first,
                   @RequestParam("b") int second) {
        return first + second;
    }
}

GET /add/10/20 -> addUsingPath(10, 20) -> return 30 -> browser displays 30

package com.edupoly.hello;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class CalculatorController {
    @GetMapping("/add")
    @ResponseBody
    public int add(@RequestParam("a") int first,
                   @RequestParam("b") int second) {
        return first + second;
    }
    @GetMapping("/add/{a}/{b}")
    @ResponseBody
    public int addUsingPath(@PathVariable("a") int first,
                            @PathVariable("b") int second) {
        return first + second;
    }
}

Form: enter 10 and 5, click Add
 -> GET /calculate?a=10&b=5&operation=add
 -> @RequestParam reads the three values
 -> Java calculates 15.0
 -> @ResponseBody sends "10.0 + 5.0 = 15.0"
 -> browser displays the answer as text on the next page

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Arithmetic Calculator — Stage 5</title>
    <link rel="stylesheet" href="/style.css">
</head>
<body>
<main>
    <h1>Arithmetic Calculator</h1>
    <p>Enter two numbers and choose an operation.</p>

    <form action="/calculate" method="get">
        <label for="a">First number</label>
        <input id="a" name="a" type="number" step="any" required>

        <label for="b">Second number</label>
        <input id="b" name="b" type="number" step="any" required>

        <div class="buttons">
            <button type="submit" name="operation" value="add">Add (+)</button>
            <button type="submit" name="operation" value="subtract">Subtract (-)</button>
            <button type="submit" name="operation" value="multiply">Multiply (×)</button>
            <button type="submit" name="operation" value="divide">Divide (÷)</button>
            <button type="submit" name="operation" value="remainder">Remainder (%)</button>
        </div>
    </form>
    <p>The answer opens as text on the next page. Use the browser Back button to calculate again.</p>
    <p class="note">Remainder means what is left after division: 20 % 6 = 2.</p>
</main>
</body>
</html>

package com.edupoly.calculator;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class CalculatorController {
    @GetMapping("/calculate")
    @ResponseBody
    public String calculate(
            @RequestParam("a") double first,
            @RequestParam("b") double second,
            @RequestParam("operation") String operation) {

        if (!Double.isFinite(first) || !Double.isFinite(second)) {
            return "Please enter two finite numbers.";
        }

        double answer;
        String symbol;

        switch (operation) {
            case "add":
                answer = first + second;
                symbol = "+";
                break;
            case "subtract":
                answer = first - second;
                symbol = "-";
                break;
            case "multiply":
                answer = first * second;
                symbol = "×";
                break;
            case "divide":
                if (second == 0) {
                    return "Cannot divide by zero.";
                }
                answer = first / second;
                symbol = "÷";
                break;
            case "remainder":
                if (second == 0) {
                    return "Cannot calculate a remainder with zero as the divisor.";
                }
                answer = first % second;
                symbol = "%";
                break;
            default:
                return "Please choose one of the five operations.";
        }

        if (!Double.isFinite(answer)) {
            return "The result is too large. Please use smaller numbers.";
        }

        return first + " " + symbol + " " + second + " = " + answer;
    }
}

GET /products
 -> listProducts(model)
 -> model.addAttribute("products", products)
 -> return "products"
 -> Thymeleaf repeats a table row for each product
 -> browser receives HTML containing 30 product rows

Click More details for product 1
 -> GET /products/1
 -> productDetails(1, model)
 -> find the matching Product object
 -> model.addAttribute("product", product)
 -> return "product-details"
 -> Thymeleaf renders product-details.html with all 8 fields

{
  "id": 1,
  "name": "Wireless Mouse",
  "category": "Electronics",
  "price": 699,
  "brand": "EduTech",
  "stock": 12,
  "description": "Wireless Mouse for everyday learning, study and work. Product 1 includes a simple user guide and protective packaging.",
  "warrantyMonths": 12
}

@GetMapping({"/", "/products"})
public String listProducts(Model model) {
    model.addAttribute("products", products);
    return "products";
}

<tr th:each="product : ${products}">
    <td th:text="${product.id}">1</td>
    <td th:text="${product.name}">Wireless Mouse</td>
    <td th:text="${product.category}">Electronics</td>
    <td th:text="${product.price}">699</td>
    <td><a th:href="@{/products/{id}(id=${product.id})}">More details</a></td>
</tr>

@GetMapping("/products/{id}")
public String productDetails(@PathVariable("id") int id, Model model) {
    for (Product product : products) {
        if (product.getId() == id) {
            model.addAttribute("product", product);
            return "product-details";
        }
    }
    throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Product not found");
}

<h2 th:text="${product.name}">Product name</h2>
<p th:text="${product.description}">Description</p>
<p th:text="${product.brand}">Brand</p>

package com.edupoly.products;

import java.io.IOException;
import org.springframework.core.io.ClassPathResource;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.server.ResponseStatusException;
import tools.jackson.databind.json.JsonMapper;

@Controller
public class ProductController {
    private final Product[] products;

    // Read the text file once when Spring creates this controller.
    public ProductController() throws IOException {
        var resource = new ClassPathResource("data/products.txt");
        try (var input = resource.getInputStream()) {
            JsonMapper mapper = JsonMapper.builder().build();
            products = mapper.readValue(input, Product[].class);
        }
    }

    @GetMapping({"/", "/products"})
    public String listProducts(Model model) {
        model.addAttribute("products", products);
        return "products";
    }

    @GetMapping("/products/{id}")
    public String productDetails(@PathVariable("id") int id, Model model) {
        for (Product product : products) {
            if (product.getId() == id) {
                model.addAttribute("product", product);
                return "product-details";
            }
        }
        throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Product not found");
    }
}

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Products</title>
    <link rel="stylesheet" th:href="@{/style.css}">
</head>
<body>
<main>
    <h1>Products</h1>
    <p>Basic details for 30 products. Select More details to see a product's complete information.</p>
    <div class="table-scroll">
    <table>
        <thead>
        <tr><th>ID</th><th>Name</th><th>Category</th><th>Price (INR)</th><th>Action</th></tr>
        </thead>
        <tbody>
        <tr th:each="product : ${products}">
            <td th:text="${product.id}">1</td>
            <td th:text="${product.name}">Wireless Mouse</td>
            <td th:text="${product.category}">Electronics</td>
            <td th:text="${product.price}">699</td>
            <td><a th:href="@{/products/{id}(id=${product.id})}">More details</a></td>
        </tr>
        </tbody>
    </table>
    </div>
</main>
</body>
</html>

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title th:text="${product.name}">Product details</title>
    <link rel="stylesheet" th:href="@{/style.css}">
</head>
<body>
<main class="detail">
    <h1>Product details</h1>
    <h2 th:text="${product.name}">Wireless Mouse</h2>
    <dl>
        <dt>ID</dt><dd th:text="${product.id}">1</dd>
        <dt>Name</dt><dd th:text="${product.name}">Wireless Mouse</dd>
        <dt>Category</dt><dd th:text="${product.category}">Electronics</dd>
        <dt>Price (INR)</dt><dd th:text="${product.price}">699</dd>
        <dt>Brand</dt><dd th:text="${product.brand}">EduTech</dd>
        <dt>Stock</dt><dd th:text="${product.stock}">12</dd>
        <dt>Description</dt><dd th:text="${product.description}">Product description</dd>
        <dt>Warranty (months)</dt><dd th:text="${product.warrantyMonths}">12</dd>
    </dl>
    <a th:href="@{/products}">Back to products</a>
</main>
</body>
</html>

Form -> GET /calculate?a=20&b=6&operation=remainder
 -> controller calculates 2.0
 -> Model carries values
 -> Thymeleaf renders result.html
 -> browser displays a separate result page

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Arithmetic Calculator</title>
    <link rel="stylesheet" href="/style.css">
</head>
<body>
<main>
    <h1>Arithmetic Calculator</h1>
    <p>Enter two numbers and choose an operation.</p>

    <form action="/calculate" method="get">
        <label for="a">First number</label>
        <input id="a" name="a" type="number" step="any" required>

        <label for="b">Second number</label>
        <input id="b" name="b" type="number" step="any" required>

        <div class="buttons">
            <button type="submit" name="operation" value="add">Add (+)</button>
            <button type="submit" name="operation" value="subtract">Subtract (-)</button>
            <button type="submit" name="operation" value="multiply">Multiply (×)</button>
            <button type="submit" name="operation" value="divide">Divide (÷)</button>
            <button type="submit" name="operation" value="remainder">Remainder (%)</button>
        </div>
    </form>
    <p class="note">Remainder means what is left after division: 20 % 6 = 2.</p>
</main>
</body>
</html>

package com.edupoly.calculator;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class CalculatorController {
    @GetMapping("/calculate")
    public String calculate(
            @RequestParam("a") double first,
            @RequestParam("b") double second,
            @RequestParam("operation") String operation,
            Model model) {

        if (!Double.isFinite(first) || !Double.isFinite(second)) {
            model.addAttribute("error", "Please enter two finite numbers.");
            return "result";
        }

        double answer;
        String symbol;

        switch (operation) {
            case "add":
                answer = first + second;
                symbol = "+";
                break;
            case "subtract":
                answer = first - second;
                symbol = "-";
                break;
            case "multiply":
                answer = first * second;
                symbol = "×";
                break;
            case "divide":
                if (second == 0) {
                    model.addAttribute("error", "Cannot divide by zero.");
                    return "result";
                }
                answer = first / second;
                symbol = "÷";
                break;
            case "remainder":
                if (second == 0) {
                    model.addAttribute("error", "Cannot calculate a remainder with zero as the divisor.");
                    return "result";
                }
                answer = first % second;
                symbol = "%";
                break;
            default:
                model.addAttribute("error", "Please choose one of the five operations.");
                return "result";
        }

        if (!Double.isFinite(answer)) {
            model.addAttribute("error", "The result is too large. Please use smaller numbers.");
            return "result";
        }

        model.addAttribute("first", first);
        model.addAttribute("second", second);
        model.addAttribute("symbol", symbol);
        model.addAttribute("answer", answer);
        return "result";
    }
}

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Calculation Result</title>
    <link rel="stylesheet" href="/style.css">
</head>
<body>
<main>
    <h1>Calculation Result</h1>

    <div th:if="${error == null}">
        <p class="equation">
            <span th:text="${first}">10</span>
            <span th:text="${symbol}">+</span>
            <span th:text="${second}">5</span>
            =
            <strong id="answer" th:text="${answer}">15</strong>
        </p>
    </div>

    <p id="error" class="error" th:if="${error != null}" th:text="${error}"></p>

    <a href="/">Calculate again</a>
</main>
</body>
</html>

Compare the three ways we passed numbers

Practice: explain what the browser sends, which Java method runs, and what the browser receives for each stage. Continue below when these examples feel clear.

1. Connect the new concepts to familiar ones

2. What Spring Framework does — step by step

Start with a small Java program: a TodoPrinter displays task titles, a TodoService decides what to return, and a TodoStore supplies the tasks. These are classes you write. Their methods need actual objects to work with. Spring can create and keep track of selected objects and supply them to other objects that need them.

Open the Spring Framework explanation in the third column. Follow the steps below before learning the annotation names.

2.1 A class defines a type; an object is one instance

A class describes fields, constructors and methods. Declaring a class does not automatically run its constructor. An expression such as new TodoStore() creates an instance and calls its constructor. The variable store holds a reference to that instance, rather than containing the whole object.

TodoStore store = new TodoStore();
TodoService service = new TodoService(store);
TodoPrinter printer = new TodoPrinter(service);

Read the second line as: create a service object and pass the existing store reference to its constructor. The service saves that reference in a field so its methods can call the store later. That required store is called a dependency.

2.2 Is the entire application one object? Does every class need an object?

2.3 First connect the objects yourself

This is normal Java and already uses constructor dependency injection: the caller supplies the dependency through a constructor. Spring is not required for this Java pattern. In a small program, writing these three construction statements is straightforward. In a larger application, many services need shared collaborators, configuration and lifecycle handling.

2.4 Tell Spring how to build the selected objects

The runnable example uses explicit @Bean factory methods so you can see the construction code. @Configuration marks the configuration class. Each @Bean method tells Spring how to obtain one managed object. Spring supplies a method's parameters from the objects in its context; our method then calls the Java constructor using those references.

@Bean
public TodoService todoService(TodoStore store) {
    return new TodoService(store);
}

The parameter store is supplied by Spring. The new expression still creates the Java object. Spring records the returned service as a bean and makes it available when the printer needs a service. In this example there is exactly one matching bean for each dependency type.

TodoStore store = new TodoStore();
TodoService service = new TodoService(store);

public TodoService createTodoService(TodoStore store) {
    return new TodoService(store);
}

TodoStore store = new TodoStore();
TodoService service = createTodoService(store);

@Configuration(proxyBeanMethods = false)
public class AppConfig {
    @Bean
    public TodoStore todoStore() {
        return new TodoStore();
    }

    @Bean
    public TodoService todoService(TodoStore store) {
        return new TodoService(store);
    }
}

Spring calls todoStore()
  -> receives and registers a TodoStore object
  -> supplies that store to todoService(store)
  -> the method constructs and returns a TodoService
  -> Spring manages the returned service

var context = new AnnotationConfigApplicationContext(AppConfig.class);
TodoService service = context.getBean(TodoService.class);
// Close the context when finished; the complete demo uses try-with-resources.

// Constructor declared inside TodoService
public TodoService(TodoStore store) {
    this.store = store;
}

2.5 What happens at startup, and what happens later?

1. Our main method starts an AnnotationConfigApplicationContext with AppConfig.class.
2. Spring reads the configuration and its bean definitions.
3. To create the printer, Spring needs the service; to create the service, it needs the store. Spring obtains the dependencies before completing each dependent object.
4. Spring calls the factory methods with the required references, registers their returned objects and completes their initialization. In this example the default singleton beans are created during context startup.
5. Our code asks the context for the printer and calls its print method. The printer calls the service, which calls the store. These are ordinary Java method calls.

The two diagrams show different things: construction supplies references; later method calls use those references. Spring does not invent the business logic inside these methods.

2.6 Run a complete small example

Download the Spring objects demo ZIP. Extract it and open a terminal in spring-objects-demo, where pom.xml is located. You need JDK 21+ and Maven 3.9+ on PATH, plus internet for dependencies on the first run. This console example needs no database or Tomcat installation.

spring-objects-demo/
  pom.xml
  src/main/java/com/edupoly/demo/Main.java

To create it manually, save these two complete files at those paths. All helper classes are nested inside Main to keep this first exercise small; real projects normally use separate files.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.edupoly</groupId>
  <artifactId>spring-objects-demo</artifactId>
  <version>1.0.0</version>
  <properties>
    <maven.compiler.release>21</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>7.0.9</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.14.1</version>
      </plugin>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>3.5.0</version>
        <configuration>
          <mainClass>com.edupoly.demo.Main</mainClass>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

package com.edupoly.demo;

import java.util.List;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

public class Main {
    // A data class: individual Todo instances are not registered as beans here.
    public record Todo(String title) {}

    public static class TodoStore {
        public List<Todo> findAll() {
            return List.of(new Todo("Learn Java"), new Todo("Learn Spring"));
        }
    }

    public static class TodoService {
        private final TodoStore store;

        public TodoService(TodoStore store) {
            this.store = store;
        }

        public List<String> titles() {
            return store.findAll().stream().map(Todo::title).toList();
        }
    }

    public static class TodoPrinter {
        private final TodoService service;

        public TodoPrinter(TodoService service) {
            this.service = service;
        }

        public void print(String label) {
            System.out.println(label + ": " + service.titles());
        }
    }

    @Configuration(proxyBeanMethods = false)
    public static class AppConfig {
        @Bean
        public TodoStore todoStore() {
            return new TodoStore();
        }

        @Bean
        public TodoService todoService(TodoStore store) {
            return new TodoService(store);
        }

        @Bean
        public TodoPrinter todoPrinter(TodoService service) {
            return new TodoPrinter(service);
        }
    }

    public static void main(String[] args) {
        // First: our code creates and connects all three objects.
        TodoStore store = new TodoStore();
        TodoService service = new TodoService(store);
        TodoPrinter printer = new TodoPrinter(service);
        printer.print("Manual Java");

        // Second: Spring calls the configured factory methods and supplies
        // each method's arguments from objects registered in the context.
        try (var context = new AnnotationConfigApplicationContext(AppConfig.class)) {
            TodoPrinter first = context.getBean(TodoPrinter.class);
            TodoPrinter second = context.getBean(TodoPrinter.class);
            first.print("Spring");
            System.out.println("Same printer bean: " + (first == second));
            System.out.println("Store passed to service: "
                + (context.getBean(TodoService.class).store
                   == context.getBean(TodoStore.class)));
        }
    }
}

mvn -q compile exec:java

Manual Java: [Learn Java, Learn Spring]
Spring: [Learn Java, Learn Spring]
Same printer bean: true
Store passed to service: true

Maven or the JDK may also print diagnostic messages. Both approaches produce the same titles because they call the same classes. The first true shows that two lookups return the same singleton printer. The second true confirms that Spring supplied the same store reference to the service. The manual objects and Spring-managed objects are separate sets.

2.7 Connect this example to the todo web application

TodoPrinter is a console helper, not a web controller. In the web project, a TodoController takes the entry-point role: Spring MVC receives an HTTP request and invokes a mapped method on the controller bean. The controller uses its injected service, which uses its repository. Your code still implements the task operations.

Later, @Service and @Controller, together with enabled component scanning, let Spring find classes without an explicit factory method for each one. With one constructor, Spring supplies its required arguments without needing @Autowired. Spring Data separately registers implementations for configured repository interfaces. A plain interface cannot be instantiated using new.

The default singleton scope means one bean instance per definition per application context, not one object for the entire program and not one new controller for each request. Do not store a current user's request data in shared controller or service fields. DTOs and Todo records are normally separate data objects.

2.8 What else does Spring Framework help with?

Spring Boot builds on these facilities and reduces startup and configuration work. Start with the objects and their relationships; the next section explains Boot.

2.9 Practice and check your understanding

1. Add a third Todo in findAll(), rerun the command and predict which output lines change.
2. Explain why both bean lookups return the same printer, while two new TodoPrinter(service) expressions would create separate printers.
3. Point to the exact parameter where Spring supplies the store. Then point to the line where Java constructs the service.
4. Explain why new Todo("Learn Java") creates a data object but does not register a Spring bean.

Further reading: Spring's container and beans.

3. What Spring Boot adds

Spring Boot builds on Spring Framework and simplifies application setup. It provides automatic configuration, starter dependencies, and tools for packaging your application as an executable JAR. For web applications, it can also configure an embedded server.

Automatic configuration examines the libraries included in your project, your application settings, and the Spring beans you have already configured. It uses this information to decide which components to set up.

For example:

• Adding the Spring MVC starter allows Spring Boot to configure components for handling web requests.
• Adding the Thymeleaf starter allows it to configure a template engine that generates HTML pages.
• Adding the MongoDB starter and providing a valid connection URI allows it to configure the components your application needs to access MongoDB.

A starter is a convenient dependency group. The parent POM manages compatible versions, so individual starter versions are omitted. The Maven plugin packages dependencies into an executable JAR. You can run it with java -jar rather than deploying a WAR manually.

@SpringBootApplication combines @Configuration, @EnableAutoConfiguration, and @ComponentScan. Put it above your application packages. It is not a substitute for understanding beans; it is the entry point that connects their discovery and configuration.

Boot is also useful for applications without web pages. A REST application still uses Spring MVC and Tomcat, but JSON serialization replaces template resolution. Spring Boot and Spring MVC are related parts of the stack, not two competing frameworks.

4. Trace one web request

For GET /todos, Tomcat accepts the HTTP request. Security filters apply their rules. DispatcherServlet locates the mapped controller method. The controller requests a list from the service, which uses the repository to read MongoDB documents. The controller places that list in Model and returns "list". Thymeleaf resolves templates/list.html and renders HTML. The response goes back to the browser.

For a JSON endpoint, the same route ends with the controller returning an object. A message converter serializes it to JSON. @RequestBody performs the reverse operation: JSON becomes the request DTO before your method executes.

Keep responsibilities clear: controllers handle HTTP and view/API contracts, services implement operations and authorization rules, repositories access documents, DTOs define accepted inputs, and templates/components present results.

5. HTTP and validation before coding

GET retrieves state and should not mutate it. POST creates a resource or submits a form. PUT replaces the editable state at a known resource URL. DELETE removes it. HTML forms natively use GET and POST; the Thymeleaf lab uses POST routes for update and delete. JSON clients can send PUT and DELETE directly.

Client validation improves usability, while server validation protects the contract. @NotBlank rejects empty titles, @Size caps length, @Email checks email shape, and @NotNull rejects missing required values. @Valid triggers validation. A validation annotation on a field alone does not make every method call validate automatically.

400 means invalid request, 401 means authentication is missing or invalid, 403 means the authenticated request lacks access, 404 means the resource is not available, and 409 means a conflict such as a duplicate email. The personal application deliberately uses 404 for foreign-owned todo ids.

6. MongoDB essentials

MongoDB stores BSON documents in collections. A database groups collections. A todo might contain _id, title, and completed. BSON supports more types than JSON; APIs expose JSON views of the stored data. A Java document is mapped by Spring Data rather than manually converted in each controller.

@Document names the collection. @Id selects the id field. MongoRepository<Todo,String> identifies the document and id types. Derived query names such as findByIdAndOwnerId instruct Spring Data to build an equality query. MongoDB is not accessed using @Entity, JpaRepository, or SQL joins in these projects.

Atlas is a managed MongoDB hosting service. Its website account manages projects and clusters; a separate database user authenticates application connections. Your app also needs a matching network IP rule. Each application uses its own database name to keep the labs independent.

A single document write is atomic. The read-then-save update shown in these labs can overwrite concurrent changes. That tradeoff keeps the first implementation teachable. A later exercise can add optimistic locking with @Version and return a conflict for a stale update.

7. Configuration and project layout

src/main/java contains compiled Java source. src/main/resources contains templates, static assets, and configuration that are copied into the JAR. src/test/java contains tests. target is generated output. pom.xml defines coordinates, dependencies, Java baseline, and plugins.

application.properties separates deployment choices from source. server.port selects the HTTP port. spring.mongodb.uri reads the driver URI; spring.mongodb.database selects the application database. ${MONGODB_URI} is a property placeholder resolved from the environment. Never substitute an actual password into the checked-in file.

When starting from an IDE, configure MONGODB_URI in its run configuration. Variables set in one terminal do not automatically appear inside an already-running IDE. Restarting or changing the IDE launch environment may be necessary.

8. Prepare your development tools

Install a JDK 21, Apache Maven 3.9+, and an IDE such as IntelliJ IDEA, Eclipse/STS, or VS Code with Java extensions. Maven must be on PATH and JAVA_HOME must point to the JDK directory, not its bin subdirectory. Use a terminal in the project folder. Internet access is needed on the first dependency download. Spring Boot projects include an embedded Tomcat server. The Servlets and JSPs tutorial explains how to install Tomcat separately.

For the React lab, also install Node.js 22.12+ and npm. For the REST labs, install Postman Desktop, or use the web client with its Desktop Agent for localhost requests.

java -version
javac -version
mvn -version
node --version
npm --version

Expect Java and javac to report version 21, Maven to report 3.9.x and its Java home, and Node to report a supported 22.x or newer version. If multiple JDKs are installed, Maven’s reported Java version determines compilation. The projects target Java 21; using an older JDK causes “release version 21 not supported.”

These examples deliberately pin Boot 4.1.1. Boot 4’s MVC starter is spring-boot-starter-webmvc; its MongoDB connection property is spring.mongodb.uri. When reading a Boot 3 tutorial, check its starter and configuration names before mixing it with this code.

Version references: Spring Boot requirements, Boot configuration properties, and Vite setup.

9. Check understanding

1. Explain why a controller should not create a repository with new.
2. Trace a GET request until Thymeleaf produces HTML.
3. Explain the difference between Spring Framework, Spring MVC, and Spring Boot.
4. Name the folder for templates and the folder for static CSS.
5. Explain why a validation rule must run on the server even if the browser uses required.

Next: set up MongoDB Atlas →