Zero to Hero Java SpringBoot & JPA Mastery with Real Project

Implement a save new property post endpoint in a Spring Boot JPA app. Route data through the controller, to service, then repository, via post mapping and test with Postman.

Learn to build a Spring service layer with dependency injection, using singleton and prototype beans, interface implementations, and autowired controller service communication.

Explore layered architecture with controller, service, and repository layers, and understand why dev, test, acceptance, and production environments require separate databases, including local development databases.

Explore how the Hibernate ORM framework implements the JPA specification, mapping Java entities to database tables through annotations, and managing configuration, sessions, transactions, and caching.

Explore how Hibernate and Spring Data JPA map Java objects to database tables, configure embedded H2 databases, and manage updates with dialect, driver, and show SQL settings.

Learn how to create a Spring Data JPA repository for a Property entity, implement CRUD operations, and map between DTOs and entities to save properties in the database via PropertyRepository.

Explore the model–view–controller design pattern, showing how the controller maps incoming JSON to methods and determines which model data is written to which view, with JSON acting as the view.

Add a property converter layer to transform dtos to entities, annotate it as a component, and inject it into the service to centralize conversions and return the persisted entity.

Develop an end-to-end flow by converting the entity to a detail, saving via the service and repository, and returning a response entity with created status and the new id.

Create a get all properties API endpoint to fetch all properties and sponsor data, convert entities to a response, and return JSON via Spring Boot.

Learn to perform a full update of a property using put mapping, by fetching the existing property, overwriting all fields with new values, saving, and returning the updated entity.

Learn to perform a partial update with a patch operation using a batch method to update property description or property price via controller and service.

Delete a property by id using a void service method and a delete mapping, returning no content after removal, and verify the item is deleted via repository.

Explore how spring profiles enable environment-specific configuration in a springboard app, using separate config files for local, dev, test, and production so the same code runs everywhere.

Create environment-specific configuration files under resources named application-{profile}.properties (or YAML) for local, dev, test, acceptance, and production. Use spring.profiles to load the correct DB config for each environment.

Demonstrate configuring environment-specific database profiles to run the same application against dev, test, and acceptance databases by adjusting application properties, starting servers, and validating with Postman.

Access and inject custom properties from property files into any Spring bean or controller using @Value, enabling environment-specific values via active profiles and multiple property files.

Set up a GitHub repository for your local project, connect to a remote, and manage version control with Git commands such as init, add, commit, remote, and push.

Learn to connect a local project to github by configuring a token and user details, add and commit changes, set the remote origin, and push to the server.

Learn to connect IntelliJ editor with GitHub by generating and using a personal access token, configuring remote origin, and performing commits and pushes securely.

Master repository workflows, create and switch branches from master through dev and acceptance to production, and use commits, pushes, pulls, and pull requests to track changes and history.

Extend the application with a user entity, enabling registration and login, so authenticated users can create or update properties with the owner linked to the user.

Create a UserEntity class with id, name, email, phone, and password, apply Lombok annotations, and set up the initial UserRepository and service in a Spring Boot project.

Define the user service interface with two methods, specify user fields like password, name, and email, apply Lombok annotations, and prepare a public service for register and login operations.

Implement the user service as a singleton bean managed by Spring, injecting the user repository, and implement the user service interface. Convert between user data and user entity before persisting.

Develop a user converter layer that converts between user entity and detail, configure a string bean singleton, and map fields like name, password, phone number, and email.

Complete the user registration flow by converting to a user entity, saving via repository, and returning the saved user with an id, while wiring a controller and user service.

Test user registration functionality by posting json data and validating database storage; a converter fix prevents password from returning in the response for secure registration.

Use json include non_null to send only non-null fields and json ignore properties to ignore unknown fields, ensuring passwords are not returned in responses.

Commit your changes to GetUp using a meaningful message, run sonar analysis with SonarLint, fix issues, and push to the dev branch for code quality and collaboration.

Master login flow with Spring Data JPA findBy methods and JPQL queries. Derive queries from user entity fields like email and password, and compare direct and JPQL approaches.

Create a rest api endpoint and wire it to the service layer, using email and password to fetch a user, convert to a dto, and secure the post mapping.

Test user login functionality using Postman, verify handling of invalid credentials, ensure proper responses instead of empty results, and confirm successful login workflows.

Explore aspect oriented programming (AOP) to extract cross-cutting concerns such as error handling and logging into a centralized module, improving consistency across the application.

Create an error model in a new exception package, capturing type and message with Lombok-generated accessors to support editor handling and error reporting.

Create a custom business exception class that extends the default exception and holds a list of error models for multiple errors.

Create a Spring exception handler, annotated with controller advice, to handle business exceptions with a dedicated handler and return a response entity containing the exception details to the front end.

Create an error model list containing an invalid login message and throw a custom business exception. Use a one-time exception class for checked or time exceptions to streamline validation.

Investigate an invalid login attempt to verify the login flow and the response to an incorrect password. Observe a bad request and automatic exception handling via the exception handler.

Prevent duplicate registrations by checking the database for an existing email before saving, using a custom find by email and throwing an email already exists exception.

Test duplicate registration by validating email (and optionally phone), throw and catch exceptions in the registration service, and commit and push the updated code to GitHub.

Add a hibernate validator dependency and apply not null and size constraint annotations to enforce mandatory email, phone, and password fields.

Develop a custom field-level error handler in a Spring based app, collect binding errors, map them to field messages, and return a structured list before persisting data.

Learn validation with the @Valid annotation in spring boot, triggering validation for request models and returning error messages for invalid input. Implement an exception handler to manage these errors.

Master logging in a Java Spring Boot app by using logback, configuring levels (debug, info, warn, error, trace) per environment from dev to production to diagnose issues without harming performance.

Configure logback in a Spring Boot app by creating a logback.xml in resources, setting a rolling file-based and console logging pattern, and apply environment-specific log levels across Spring profiles.

Test logging across local profiles with logback, verify debug and info outputs in console and log files during server startup and field validation, then commit and push to GitHub.

Raising a pull request from your branch to master enables code review, reviewer feedback, and iterative fixes until approval, then merging to production.

Explore how Swagger API documentation auto generates up-to-date REST endpoint docs from your Java Spring Boot controllers, detailing endpoints, parameters, and responses for mobile and web teams.

Configure Swagger documentation for a Spring Boot project by adding the Springfox dependency, creating a Swagger config with a Docket bean, and selecting controllers to document APIs.

Examine swagger json from a consumer's perspective by reviewing auto-generated api docs at localhost:88/v2/api-docs, including endpoints, controllers, and property details that describe parameters and responses.

Use Swagger UI to explore and test API endpoints, view documentation, and simulate user registration, guided by a JSON file for client connections in a test environment.

Learn to enrich Swagger documentation by adding operation names, parameter details, data types, example values, and required fields for clearer API docs in Java Spring Boot projects.

Configure and test API endpoints to explicitly declare consumes and produces as application JSON. Preview and verify that requests and responses follow the declared formats for post operations.

Learn to enable Spring Boot actuator, access health and metrics endpoints, and configure which endpoints are exposed to monitor a running application in production.

Learn to enable web and jmx endpoints for monitoring in spring boot by exposing metrics, environment, beans, info, audit events, and health data via actuator endpoints with configurable exposure.