Task Manager REST API

Build a full CRUD API for tasks, backed by Spring Data JPA.

REST ControllersSpring Data JPAValidation

Overview

A task manager API is the standard first project for seeing what Spring Boot and Spring Data JPA actually save you from writing. Without them, a CRUD endpoint means a servlet, a hand-wired JDBC connection, and a PreparedStatement for every query. With Spring Boot, @RestController turns a plain Java method into a routed HTTP endpoint, and Spring Data JPA generates an entire repository implementation — save, find, delete, everything — from a bare interface that declares no method bodies at all.

By the end of this tutorial you will have a small but complete REST API: a Task entity mapped to a database table, a TaskRepository interface that Spring Data JPA implements for you at startup, and a TaskController exposing GET, POST, PUT, and DELETE endpoints under /api/tasks. A TaskRequest DTO with Bean Validation annotations sits between the raw JSON body and the entity, so an incoming request with a blank title is rejected with a 400 Bad Request before a single line of your own code runs.

What You'll Build

A Task @Entity with id, title, and completed fields, mapped to a table by Spring Data JPA.
A TaskRepository extends JpaRepository<Task, Long> — no boilerplate DAO code, just an interface.
A TaskRequest DTO using @NotBlank so @Valid rejects an invalid body automatically.
A TaskController with GET /api/tasks and GET /api/tasks/{id} endpoints.
A POST /api/tasks endpoint returning 201 Created for a valid task.
PUT /api/tasks/{id} and DELETE /api/tasks/{id} endpoints completing full CRUD.

Prerequisites

Java fundamentals — classes, interfaces, and constructors.
HTTP basics — the meaning of GET, POST, PUT, DELETE, and status codes like 200, 201, 204, 400, and 404.
Spring Boot basics — @SpringBootApplication, @RestController, and how Spring's dependency injection wires a constructor parameter automatically.
JSON basics — how a Java object maps to a JSON request/response body via Jackson, which Spring Boot configures for you by default.
A Spring Boot 3.x project with the Spring Web, Spring Data JPA, Validation, and H2 Database starters (all selectable from Spring Initializr).

Project Structure

Generating a project from Spring Initializr with com.programinds.taskmanager as the group/package produces this layout: src/main/java/com/programinds/taskmanager/TaskManagerApplication.java holds main(); a model/ package holds Task; a repository/ package holds TaskRepository; a dto/ package holds TaskRequest; a controller/ package holds TaskController; and src/main/resources/application.properties holds configuration such as the datasource URL. This is the same package-per-layer shape you will see used again in the remaining three projects in this course.

This project uses the H2 in-memory database — nothing needs to be installed beyond the JDK, and the schema is created automatically from the Task entity every time the app starts. A real deployment would swap the datasource properties in application.properties for a PostgreSQL or MySQL connection string; every line of Task, TaskRepository, and TaskController below would stay exactly the same, because Spring Data JPA's generated queries are database-independent.

Step 1: Create the Task Entity

@Entity is what tells Spring Data JPA that this plain Java class maps to a database table — by convention, a table named task, one column per field. @Id marks the primary key, and @GeneratedValue(strategy = GenerationType.IDENTITY) delegates id generation to the database's own auto-increment column, so TaskController never has to invent an id itself. JPA also requires a no-argument constructor on every entity, since it builds objects via reflection when reading rows back from the database.

model/Task.java

package com.programinds.taskmanager.model;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

// @Entity tells Spring Data JPA to map this class to a table (named "task" by
// default). No hand-written SQL or mapping XML is needed for a class this simple.
@Entity
public class Task {

    @Id                                                  // Marks this field as the table's primary key
    @GeneratedValue(strategy = GenerationType.IDENTITY)   // Let the database auto-increment the id column
    private Long id;

    private String title;       // What the task is; validated as non-blank by TaskRequest in Step 3
    private boolean completed;  // Defaults to false, matching boolean's own default value

    // JPA requires a no-arg constructor so it can instantiate Task via reflection
    // when mapping a database row back into an object.
    public Task() {
    }

    // Convenience constructor used by TaskController when creating a new task
    // from a validated TaskRequest — id is left null since IDENTITY assigns it.
    public Task(String title, boolean completed) {
        this.title = title;
        this.completed = completed;
    }

    public Long getId() {
        return id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public boolean isCompleted() {
        return completed;
    }

    public void setCompleted(boolean completed) {
        this.completed = completed;
    }
}

Step 2: Create the TaskRepository

This is the step that shows why Spring Data JPA exists. TaskRepository declares no method bodies at all — it just extends JpaRepository<Task, Long>, naming the entity type and its id type. At application startup, Spring Data JPA generates a full implementation behind the scenes, giving you save(), findAll(), findById(), deleteById(), existsById(), and dozens more, without a single line of hand-written DAO code.

repository/TaskRepository.java

package com.programinds.taskmanager.repository;

import com.programinds.taskmanager.model.Task;
import org.springframework.data.jpa.repository.JpaRepository;

// Extending JpaRepository<Task, Long> is the entire implementation. Spring Data
// JPA generates save(), findAll(), findById(), deleteById(), existsById(), and
// more at startup — this is the "no boilerplate DAO code" Spring Data promises.
public interface TaskRepository extends JpaRepository<Task, Long> {
    // Empty on purpose. A derived query method could be added later, e.g.:
    //   List<Task> findByCompleted(boolean completed);
    // and Spring Data JPA would generate its SQL from the method name alone.
}

Step 3: Add a Validated Request DTO

The controller in the next three steps never accepts a raw Task entity as a request body — it accepts a TaskRequest DTO instead. Separating the two matters because Task has an id field that the client should never be allowed to set directly, and because Bean Validation annotations like @NotBlank belong on the boundary of the API, not baked permanently into the persistence entity. @Valid on the controller parameter (Step 5) is what actually triggers this validation.

dto/TaskRequest.java

package com.programinds.taskmanager.dto;

import jakarta.validation.constraints.NotBlank;

// A request DTO, deliberately separate from the Task entity. It has no id field
// (the client never chooses one) and carries validation annotations that only
// make sense at the API boundary, not on the persisted entity itself.
public class TaskRequest {

    @NotBlank(message = "Title must not be blank")   // Rejects null, empty, and whitespace-only titles
    private String title;

    private boolean completed;   // Optional on create; defaults to false via boolean's default value

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public boolean isCompleted() {
        return completed;
    }

    public void setCompleted(boolean completed) {
        this.completed = completed;
    }
}

Step 4: Build the GET Endpoints

@RestController combines @Controller and @ResponseBody, meaning every method's return value is serialized straight to JSON instead of resolved as a view name. @RequestMapping("/api/tasks") on the class sets a shared prefix for every method below it. The constructor taking a TaskRepository is Spring's dependency injection at work: Spring creates one TaskController and hands it the same TaskRepository bean it built for the whole application, with no new TaskRepositoryImpl() anywhere in this file.

controller/TaskController.java

package com.programinds.taskmanager.controller;

import com.programinds.taskmanager.model.Task;
import com.programinds.taskmanager.repository.TaskRepository;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController                    // Combines @Controller + @ResponseBody: every method's return value becomes JSON
@RequestMapping("/api/tasks")      // Shared URL prefix for every endpoint in this controller
public class TaskController {

    private final TaskRepository taskRepository;   // final: assigned once, in the constructor, never reassigned

    // Constructor injection: Spring passes in the single TaskRepository bean it
    // already built at startup. No field is ever null, and the class is trivially
    // testable by passing in a mock TaskRepository instead.
    public TaskController(TaskRepository taskRepository) {
        this.taskRepository = taskRepository;
    }

    @GetMapping                                     // GET /api/tasks
    public List<Task> getAll() {
        return taskRepository.findAll();   // Generated by Spring Data JPA in Step 2; no SQL written by hand
    }

    @GetMapping("/{id}")                            // GET /api/tasks/5
    public ResponseEntity<Task> getById(@PathVariable Long id) {
        return taskRepository.findById(id)          // Returns an Optional<Task>
            .map(ResponseEntity::ok)                  // Present: wrap it in 200 OK
            .orElse(ResponseEntity.notFound().build()); // Absent: 404, with no body
    }
}

Step 5: Build the POST Endpoint

@Valid is the annotation that actually triggers the @NotBlank check written on TaskRequest back in Step 3 — without it, Spring would bind the JSON body into a TaskRequest object but never run its validation constraints, and a blank title would sail straight through. When validation fails, Spring throws a MethodArgumentNotValidException before create() ever runs, and Spring Boot's default handler turns that into a 400 Bad Request automatically, with no try/catch needed in this method at all.

@PostMapping                                         // POST /api/tasks
public ResponseEntity<Task> create(@Valid @RequestBody TaskRequest request) {
    // @Valid triggers TaskRequest's @NotBlank check; an invalid body never
    // reaches this line — Spring responds with 400 Bad Request automatically.
    Task task = new Task(request.getTitle(), request.isCompleted());
    Task saved = taskRepository.save(task);            // INSERT; saved.getId() is now populated by the database
    return ResponseEntity.status(HttpStatus.CREATED).body(saved);   // 201 Created, echoing the persisted task back
}

Step 6: Build the PUT and DELETE Endpoints

update() loads the existing entity with findById() and mutates its fields directly rather than constructing a brand-new Task — this matters because Spring Data JPA's save() on an entity that already has an id issues an UPDATE, not an INSERT. delete() checks existsById() first so a DELETE on a nonexistent id returns 404 instead of silently succeeding, which is the more honest response for a client that got the id wrong.

@PutMapping("/{id}")                                 // PUT /api/tasks/5
public ResponseEntity<Task> update(@PathVariable Long id, @Valid @RequestBody TaskRequest request) {
    return taskRepository.findById(id)
        .map(task -> {
            task.setTitle(request.getTitle());          // Mutate the loaded entity's fields directly
            task.setCompleted(request.isCompleted());
            return ResponseEntity.ok(taskRepository.save(task));   // save() on an entity with an id issues an UPDATE
        })
        .orElse(ResponseEntity.notFound().build());     // No task with that id: 404
}

@DeleteMapping("/{id}")                              // DELETE /api/tasks/5
public ResponseEntity<Void> delete(@PathVariable Long id) {
    if (!taskRepository.existsById(id)) {                // Check first so a bad id gets 404, not a silent no-op
        return ResponseEntity.notFound().build();
    }
    taskRepository.deleteById(id);
    return ResponseEntity.noContent().build();           // 204: the delete succeeded, nothing meaningful to return
}

Complete Code

Here is the full project across its files, plus the application entry point and application.properties. Run it with ./mvnw spring-boot:run (or your IDE's run button) — the H2 in-memory database and schema are created automatically on startup.

TaskManagerApplication.java

package com.programinds.taskmanager;

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

@SpringBootApplication   // Enables auto-configuration, component scanning, and the embedded Tomcat server
public class TaskManagerApplication {
    public static void main(String[] args) {
        SpringApplication.run(TaskManagerApplication.class, args);
    }
}

application.properties

spring.application.name=task-manager

# H2 in-memory database: no install required, resets every restart. A real
# deployment would replace these three lines with a PostgreSQL/MySQL connection.
spring.datasource.url=jdbc:h2:mem:taskdb
spring.datasource.driver-class-name=org.h2.Driver
spring.jpa.hibernate.ddl-auto=update
spring.h2.console.enabled=true

model/Task.java

package com.programinds.taskmanager.model;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Task {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;
    private boolean completed;

    public Task() {
    }

    public Task(String title, boolean completed) {
        this.title = title;
        this.completed = completed;
    }

    public Long getId() {
        return id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public boolean isCompleted() {
        return completed;
    }

    public void setCompleted(boolean completed) {
        this.completed = completed;
    }
}

repository/TaskRepository.java

package com.programinds.taskmanager.repository;

import com.programinds.taskmanager.model.Task;
import org.springframework.data.jpa.repository.JpaRepository;

public interface TaskRepository extends JpaRepository<Task, Long> {
}

dto/TaskRequest.java

package com.programinds.taskmanager.dto;

import jakarta.validation.constraints.NotBlank;

public class TaskRequest {

    @NotBlank(message = "Title must not be blank")
    private String title;

    private boolean completed;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public boolean isCompleted() {
        return completed;
    }

    public void setCompleted(boolean completed) {
        this.completed = completed;
    }
}

controller/TaskController.java

package com.programinds.taskmanager.controller;

import com.programinds.taskmanager.dto.TaskRequest;
import com.programinds.taskmanager.model.Task;
import com.programinds.taskmanager.repository.TaskRepository;
import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/tasks")
public class TaskController {

    private final TaskRepository taskRepository;

    public TaskController(TaskRepository taskRepository) {
        this.taskRepository = taskRepository;
    }

    @GetMapping
    public List<Task> getAll() {
        return taskRepository.findAll();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Task> getById(@PathVariable Long id) {
        return taskRepository.findById(id)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }

    @PostMapping
    public ResponseEntity<Task> create(@Valid @RequestBody TaskRequest request) {
        Task task = new Task(request.getTitle(), request.isCompleted());
        Task saved = taskRepository.save(task);
        return ResponseEntity.status(HttpStatus.CREATED).body(saved);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Task> update(@PathVariable Long id, @Valid @RequestBody TaskRequest request) {
        return taskRepository.findById(id)
            .map(task -> {
                task.setTitle(request.getTitle());
                task.setCompleted(request.isCompleted());
                return ResponseEntity.ok(taskRepository.save(task));
            })
            .orElse(ResponseEntity.notFound().build());
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> delete(@PathVariable Long id) {
        if (!taskRepository.existsById(id)) {
            return ResponseEntity.notFound().build();
        }
        taskRepository.deleteById(id);
        return ResponseEntity.noContent().build();
    }
}

Sample Run

Click Run to see what this code prints.

Extend This Project

Add a derived query method, List<Task> findByCompleted(boolean completed), to TaskRepository and a GET /api/tasks?completed=true filter that calls it.
Add a @ControllerAdvice-annotated GlobalExceptionHandler that turns a failed @Valid check into a structured JSON error body instead of Spring Boot's default error page.
Add a dueDate field to Task with @Future validation, and a GET /api/tasks/overdue endpoint.
Swap the H2 in-memory datasource for PostgreSQL by changing only the three properties in application.properties.
Add pagination with Pageable and taskRepository.findAll(Pageable) so GET /api/tasks supports ?page=0&size=10.

Summary

You built a working REST API where TaskController routes HTTP requests to strongly typed methods, TaskRepository generates its entire implementation from a bare interface, and @Valid rejects a malformed request before it ever reaches your own code. The getAll/getById/create/update/delete shape you wrote here — a thin controller delegating straight to a Spring Data JPA repository — is the same shape almost every simple CRUD API in Spring Boot follows.