Java, Spring Framework & Spring Boot

Java is not legacy. It is a fast, stable runtime with the deepest backend ecosystem around.

JDK 21, a build tool and sensible defaults — the starting point for every service in this series.

Records replace hundreds of lines of getters, equals and hashCode with one declaration.

var, text blocks and switch expressions make everyday Java shorter and clearer.

The right collection makes code faster and intent obvious.

map, filter and collect — the stream recipes that replace most loops.

Grouping, counting and summing in one line — the most useful collector.

Optional is a return type for maybe-missing values, not a replacement for null everywhere.

Model closed sets of types and let the compiler check you handled every case.

When to force callers to handle errors, and when to let them bubble.

Break it and HashMaps silently lose your objects.

Immutable objects are thread-safe, cache-friendly and easier to reason about.

Producer extends, consumer super — the rule that makes generic APIs flexible.

Thread-per-request without the thread cost — blocking code that scales.

Run independent calls in parallel and combine the results.

Know where your objects live before you tune anything.

The default is good. Know when to switch.

When a service hangs, a thread dump tells you exactly why.

Classic questions that still show up — with answers that show depth.

Skip the trivia. These features change how you write backend code.

Spring is the framework. Spring Boot is the opinionated way to run it.

A clean CRUD endpoint with the patterns you will use for every feature.

Package by feature, not by layer, and your codebase stays navigable.

Constructor injection, beans and why field injection makes tests painful.

Singleton is the default — and usually what you want.

application.yml, profiles and environment variables — without secrets in git.

Stop sprinkling @Value strings across your code.

Reject bad input at the edge with clear error messages.

One consistent error format for every endpoint using ProblemDetail.

Return the status your clients expect.

Never return entities from your API.

Compile-time mapping that is fast, type-safe and boring in the best way.

Good logs answer questions during incidents.

Production readiness in one dependency.

Restart in a second instead of rebuilding.

Generate accurate API docs from your code.

Version only when you must, and pick one strategy.

Never return unbounded lists.

Typed HTTP clients with timeouts, errors and retries.

Remote calls fail. Plan for it.

Repositories give you CRUD with almost no code.

Map relationships so queries stay predictable.

One query for the list, one per row for its children — the most common JPA performance bug.

Default to lazy. Fetch what each use case needs.

Choose the simplest query style that stays readable.

The annotation that looks simple and bites everyone once.

Prevent lost updates without database locks.

Your schema deserves version control.

Bigger pools are not faster pools.

Build search endpoints without string-concatenated queries.