RizTech Academy logo
RizTech Academy

Java + Spring Web Development

Build production-grade REST APIs with Spring Boot — the stack most Indian enterprises actually hire for.

Spring Boot is what most enterprise Java teams in India build on. It is also the stack most likely to get a fresher hired.

It has a reputation for magic — annotations that do things you cannot see. This course explains what is happening underneath, so when something breaks you can reason about it instead of searching for the annotation that makes the error go away. It goes past the basics into what Spring is actually chosen for — the IoC container and the JPA/Hibernate data layer in real depth — plus the concurrency, transaction and locking behaviour that separates code that works in a demo from code that survives production.

You build one real REST API through the whole course: Dakiya, a courier and parcel-tracking service — shipments, parcels, hubs and riders — from entities and repositories to security, concurrency-safe status updates, tests, and a live deployment.

Who this is for

  • Developers with Java fundamentals who want backend roles
  • Students targeting product or service companies hiring on Java
  • Interns on the Full-Stack track

What you need first

  • Java Complete Foundation, or solid Java experience
  • Basic SQL
  • Familiarity with HTTP and REST concepts helps

Tools you will use

Spring Boot 3.xJava 21Spring Data JPASpring SecurityPostgreSQLFlywayMavenJUnit 5TestcontainersDocker

By the end you can

  • Explain dependency injection and the container, and what Spring is actually doing
  • Build REST APIs with DTOs, validation, proper status codes and consistent error responses
  • Map entities and relationships with JPA, and use the ORM in depth — queries, projections, the persistence context and performance
  • Handle concurrency correctly — transaction propagation and isolation, and optimistic/pessimistic locking against the lost-update race
  • Secure an API with Spring Security and JWT, and get authorisation right
  • Write unit, slice and integration tests, including with Testcontainers, and know which to write
  • Make sound architecture decisions — layering, where logic lives, and which patterns Spring already gives you
  • Configure an application per environment and deploy it with health checks and observability
Reference code

Stuck? Compare your work

Dakiya — the courier & parcel-tracking API built across the course: a Spring Boot 3.4 REST service with DTOs and validation, a JPA data layer, Spring Security, a concurrency-safe status lifecycle (@Version), and unit/@WebMvcTest/@DataJpaTest/@SpringBootTest coverage. Java 17; run it with ./mvnw spring-boot:run and ./mvnw test.

It is there for when you are stuck, not to start from. Type the code yourself first — copying it will teach you very little.

View on GitHub
Syllabus

11 modules, 56 lessons

Work through these in order. Each lesson is short enough to finish in one sitting and ends with something to build, not a quiz.

  1. 1

    Spring Fundamentals

    Dependency injection and the container, explained without hand-waving.

    1. Why Spring exists, and the problem it solves25 min
    2. Dependency injection and inversion of control35 min
    3. Beans, the application context and scopes30 min
    4. Spring Boot, starters and auto-configuration30 min
    5. Your first Spring Boot application30 min
  2. 2

    Building REST APIs

    Controllers, request handling and responses that clients can rely on.

    1. Controllers and request mapping30 min
    2. Request bodies, path variables and query parameters30 min
    3. DTOs, and why you should not expose entities30 min
    4. Validation with Bean Validation30 min
    5. Global error handling and consistent error responses35 min
    6. REST API design: status codes, versioning, pagination30 min
  3. 3

    Data Access with JPA

    Persistence, and understanding what Hibernate does on your behalf.

    1. JPA, Hibernate and entities35 min
    2. Spring Data repositories30 min
    3. Entity relationships and fetch types40 min
    4. The N+1 problem and how to see it30 min
    5. Transactions and @Transactional35 min
    6. Schema migrations with Flyway30 min
  4. 4

    JPA and Hibernate in Depth

    The data layer people are actually hired for — the persistence context, queries, projections and performance.

    1. The persistence context: the first-level cache and entity lifecycle35 min
    2. Queries: derived, JPQL, native and @Query35 min
    3. Projections: fetching only what you need30 min
    4. Dynamic queries with Specifications and Criteria30 min
    5. Performance: fetch strategies, batching and reading the SQL35 min
  5. 5

    Security

    Authentication and authorisation that will survive a review.

    1. Spring Security: the filter chain35 min
    2. Storing passwords correctly25 min
    3. JWT authentication end to end45 min
    4. Roles, authorities and method security30 min
    5. Security mistakes that reach production25 min
  6. 6

    Concurrency, Transactions and Async

    What separates code that works in a demo from code that survives production load.

    1. Transaction propagation and isolation, in depth35 min
    2. Optimistic and pessimistic locking, and the lost-update race40 min
    3. Async work with @Async and thread pools30 min
    4. Scheduled jobs with @Scheduled25 min
    5. Reactive Spring (WebFlux): what it is, and when not to use it30 min
  7. 7

    Testing

    Unit, slice and integration tests, and knowing which to write.

    1. What to test and what to skip20 min
    2. Unit testing services30 min
    3. Testing controllers with MockMvc30 min
    4. Testing the data layer with @DataJpaTest30 min
    5. Integration tests with Testcontainers40 min
  8. 8

    Writing Spring Worth Reading

    The habits that separate someone who can make it work from someone worth hiring.

    1. Layering: controller, service, repository — and where logic lives30 min
    2. Constructor injection, and why not field injection25 min
    3. Configuration and profiles, done right25 min
    4. Exceptions, logging and failing loudly25 min
    5. Reviewing Spring code25 min
  9. 9

    Patterns in Spring

    Spring already is a bundle of patterns. Which extra ones earn their place, and which do not.

    1. Spring already encodes the patterns (IoC, proxy, template)25 min
    2. AOP and cross-cutting concerns, without the magic35 min
    3. Service boundaries and when to add an abstraction30 min
    4. Do not fight the framework25 min
    5. The patterns you do not need25 min
  10. 10

    Configuration and Deployment

    Profiles, secrets, observability and shipping it.

    1. Configuration, profiles and environment variables30 min
    2. Actuator, health checks and useful logging30 min
    3. Containerising a Spring Boot application35 min
    4. Deploying and the production checklist35 min
  11. 11

    Capstone: Dakiya, end to end

    Assemble the courier and parcel-tracking API into a finished, secured, tested, deployed service.

    1. The brief: a courier and parcel-tracking API25 min
    2. Designing the domain and the API45 min
    3. Building the core: shipments, parcels and tracking45 min
    4. Securing and testing the API45 min
    5. Concurrency-safe status updates, and going live45 min
Previous coursePython Django Web DevelopmentNext courseDevOps Complete Foundation

Learning this with a mentor is faster

Going through a course like this one is how you qualify for our six-month internship, for selected students, mostly from Pune. Clear the interview and you build real-world projects with my mentorship.

About the internshipAll courses