Project: Build a Task API with a Database

What you will build

You will build a Task API — the back-end for a to-do app. By the end it will store tasks in a database and let any front-end create, list, update, complete and delete them through clean REST endpoints. This is exactly the kind of API a junior Java developer builds on the job.

You have learned every piece already. Now you assemble them.

The whole build, in order

Here is the complete plan as numbered steps. We build it in exactly this order below — get each step working before moving to the next:

1. Create the project on start.spring.io with four dependencies (Spring Web, Spring Data JPA, H2, Validation) and confirm it starts.
2. Write the Task entity so JPA can store each task as a row, with a @NotBlank rule on the title.
3. Write the repository interface to get save, findAll, findById, deleteById (plus a custom finder) for free.
4. Write the CRUD controller that wires the five endpoints to the repository, with @Valid for validation and orElseThrow for a 404.
5. Add central error handling (NotFoundException + @RestControllerAdvice) so a missing task returns a tidy 404 JSON.
6. Test every endpoint with Postman or curl: create, read all, read one, update, validate, 404, and delete.

Step 1 — Create the project

On start.spring.io, make a Maven + Java project with these dependencies: Spring Web, Spring Data JPA, the H2 Database, and Validation. Run it once to confirm Tomcat starts on port 8080.

Step 2 — The Task entity

Model a task as a JPA entity, with a validation rule on the title:

@Entity
public class Task {

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

    @NotBlank(message = "Title is required")
    private String title;

    private boolean done = false;

    protected Task() { }              // JPA needs this
    public Task(String title) { this.title = title; }
    // getters and setters for id, title, done ...
}

Step 3 — The repository

One empty interface gives you all the database methods, plus a bonus custom finder:

public interface TaskRepository
        extends JpaRepository<Task, Long> {
    List<Task> findByDone(boolean done);   // bonus custom finder
}

Step 4 — The CRUD controller

Wire up all the endpoints, with validation and a clean 404:

@RestController
@RequestMapping("/tasks")
public class TaskController {
    private final TaskRepository repo;

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

    @GetMapping
    public List<Task> all() { return repo.findAll(); }

    @GetMapping("/{id}")
    public Task one(@PathVariable Long id) {
        return repo.findById(id)
            .orElseThrow(() -> new NotFoundException("No task " + id));
    }

    @PostMapping
    public Task create(@Valid @RequestBody Task task) {
        return repo.save(task);
    }

    @PutMapping("/{id}")
    public Task update(@PathVariable Long id, @Valid @RequestBody Task task) {
        task.setId(id);
        return repo.save(task);
    }

    @DeleteMapping("/{id}")
    public String delete(@PathVariable Long id) {
        repo.deleteById(id);
        return "Deleted task " + id;
    }
}

Step 5 — Central error handling

Add the NotFoundException and a @RestControllerAdvice from the error-handling lesson so missing tasks return a tidy 404 JSON. Your API now behaves professionally for every case.

Your tasks

• Get the project running with the four dependencies.
• Build the Task entity, repository and CRUD controller.
• Add validation (@Valid) so empty titles are rejected with a 400.
• Add error handling so a missing task returns a clean 404.
• Test every endpoint with Postman or curl.

Stretch goals

• Add an endpoint GET /tasks/done that uses findByDone(true).
• Add Spring Security so changes require a login (reading stays open).
• Package it as a jar and run it with java -jar.