Master Java Full Stack Development with Spring Boot + React

Master java full stack development with spring boot and react: working with lombok demonstrates auto generating getters, setters, and both all-args and no-args constructors for clean pojos.

set up mvc structure by creating model, service, controller, and repository packages for the product domain. implement product service and controller, plus a product repository interface.

Explore how the controller handles client requests using a rest controller and request mapping, returning a list of products via a get mapping to the front end.

Define a Spring service bean and inject it into the controller to get products, returning the product list from the service.

Refine the MVC architecture by moving data access to the repository layer, demonstrating controller, service, and repository interactions, and enable bean-based constructor injection to prepare for database connectivity.

Learn to set up a Spring Data JPA repository by extending the JPA interface, making it a Spring bean, and using constructor injection for data access with a long ID.

Learn to use Spring Data JPA repositories to save and retrieve data, including find all and save all, with @PostConstruct seeding of initial products.

Learn to design a product service interface and implement it via a service class, defining get all products, get product by id, and add, update, delete operations with uniform naming.

implement CRUD operations for products using a repository in Spring Boot, including save, find by id, update, delete, and get by id, with post, put, and delete mappings.

Test a spring boot rest api with postman to verify get all products, find by id, delete by id, and update endpoints on port 9192. Learn how to fix endpoints by using the request body for updates, applying the correct request param for the id, and adding a new product via post to finish the spring boot crash course.

Set up your development environment for React by installing Node.js and a text editor like VSCode. Follow instructions step by step to install Node.js and VSCode on your operating system.

Install and verify node, set up vscode, and create a new react project via npm, then install dependencies and run the dev server at port 5137 to view the app.

Set up and explore a brand-new vite + react project in vscode, manage dependencies, scripts like npm run dev, and inspect the entry points and structure from index.html to src.

Add bootstrap to a React project in VSCode by installing bootstrap and React-Bootstrap, configuring bootstrap CSS, and using container and text primary classes, with code formatting automation.

discover how React components form the building blocks of a UI, encapsulating markup, styles, and behavior, and build your first component as a functional example.

Refactor the products display into modular components by creating a product data module and a reusable product list, then map external data to render lists with Bootstrap styling.

Learn to implement interactive event handlers in a React list, logging clicked products to the console and highlighting the active item with a dynamic Bootstrap 'active' class using useState.

Explore inspecting the react component tree, observe how useState tracks clicked item indices, update active states on click, and navigate the component hierarchy from app to product list and items.

Review core react concepts like setting up a react app, managing state, handling events, composing components, applying bootstrap, and connecting data services using jsx interpolation with curly braces.

Discover how Hibernate acts as an orm and jpa implementer, mapping annotated Java classes to tables and handling data access with minimal boilerplate.

Build a pet care marketplace that connects veterinarians and pet owners via account management and appointment workflows, with admins overseeing veterinarians and bookings.

Ensure your development environment is ready by validating IntelliJ and VS Code setup for Java and JavaScript development, then proceed to the final project.

Generate a spring boot project with start.spring.io, choose maven, java, and dependencies like jpa, mysql, and web, then open it in your editor for pet owners and veterinarians.

Create the user entities—admin, patient, and veterinarian—in the model package, with shared attributes (id, name, gender, phone, email, password, user type, enabled) and set up their controllers, repositories, and services.

Learn how to model three user roles—patient, admin, and veterinarian—by creating a common superclass user with shared attributes and adding a vet-specific specialization, while outlining admin and patient roles.

Explore core OOP concepts and inheritance, where a subclass extends a superclass to inherit properties, with examples like user, admin, and patient, plus JPA and Hibernate mapping relevance.

Explore hibernate inheritance mapping: mapped superclass, single table, table per class, and joined table. See how discriminator type identifies subclasses, and compare performance, normalization, and data duplication across strategies.

Apply inheritance mapping to user entities using hibernate and jpa annotations, enabling joined table strategy across admin, patient, and veterinarian with a shared primary key.

Configure the entity’s primary key generation with identity strategy in JPA/Hibernate, then run the project and resolve JDK and database URL issues by updating the property file.

Configure project properties—database url, credentials, mysql driver, and dialect; choose hibernate ddl auto options (create, update, create-drop) while mapping a four-table user inheritance (user, admin, patient, veterinarian).

Create the user, veterinarian, patient, and admin controllers, repositories, and services for all models. Implement these components in IntelliJ as the project evolves.

Test creating a user through the user controller and service, wiring with constructor injection, and persisting via a JPA repository, validated with postman in a single API flow.

Register users via a single form, where a gateway checks the user type and delegates to a domain factory to create a veterinarian, admin, or patient and save to database.

Create a factory package with a user factory interface and concrete implementations for simple user, admin, patient, and veterinarian, plus a registration request to enable user creation.

Orchestrate the user factory to create vets, patients, and admins via dedicated factories, map common attributes with a user attribute mapper, and keep specialization transient to honor inheritance.

Implement the user factory by mapping frontend attributes to the user entity, validating email uniqueness, and delegating to veterinarian, patient, or admin factories by user type.

Use constructor injection and bean annotations to simulate a user factory, not the full pattern, map registration data to a veterinarian's specialization, and save via a repository.

Complete the patient factory and the admin factory by applying the patterns shown in the veterinarian factory, then proceed to the next step and apply the example from prior work.

Wire patient and admin creation using a patient repository and user attribute mapper. Inject dependencies with Lombok's @RequiredArgsConstructor, extend JPA repositories, and persist via repository saves.

Complete the user factory implementation and switch to factory-driven user creation via registration request, handling uniqueness constraints, updating to return a user, and testing with veterinarians and patients with specialization.

Implement DTO to control what data is sent to the client after user creation. Avoid exposing the password and direct database models by selecting only the necessary user fields.

Learn how data transfer objects simplify web app data exchange by encapsulating data, reducing network traffic, and decoupling service and presentation layers for stable APIs.

Create a user dto, remove the password, use Lombok for getters, and return the dto via a ResponseEntity from the controller.

Explore Spring's ResponseEntity to customize http responses—set status codes, headers, and body—and return a generic api response object for client data.

Implement a generic entity converter with model mapper to map entities to DTOs and vice versa, handling polymorphic user subclasses like vet, owner, patient, and admin.

Introduce a Spring bean for model mapper in application config, enabling entity-to-dto conversions with an entity converter. Map user to user DTO and vice versa, and return API responses.

Fine-tune the user creation flow to return accurate http status with response entity, showing 409 conflict when email exists and centralizing messages and url mappings.

Understand versioned api naming patterns for resources like users and appointments, using endpoints such as /api/v1/users and /users/update, and avoid conflicts by prefixing actions per resource.

Implement the user update endpoint with an update request, specify updatable fields (excluding email, password, and user type), and introduce a user service interface to promote polymorphism and consistent naming.

Update a user by id using a dedicated find by id method, handle not found with a resource not found exception, and return a DTO confirming the user updated successfully.

Update a user through a path variable id and ensure the route matches the parameter. Fix id consumption, align code with api/users/register, and outline creating the delete method.

Test and update the user api using postman by creating a collection, sending register and update requests, and validating data for patients and veterinarians in a pet care project.

Develop the user API by adding get by id and delete endpoints, map the user to a DTO, implement try-catch for errors, and connect the controller to front end calls.

Delete a user by id after verifying the user exists with find by ID; if present, delete it and return a success message, otherwise throw a not found exception.

Implement a get all users endpoint by converting database entities to user DTOs in the service and exposing a get all users API in the controller for front-end access.

Test the user API with postman by performing create, read by id, read all, update to found, and delete operations, with clear feedback messages.

Model an appointment api where patients and veterinarians share a single user table and container; logins fetch appointments by user id, with sender patient and recipient veterinarian.

Implement the appointment API by creating an appointment model with id, start time, appointment time, appointment date, created at, reason, appointment number, status enum, and links to patient and recipient.

Map the relationship between user and appointment in Hibernate, defining many-to-one associations for patient and veterinarian, and override fetch type to lazy with custom join columns.

Create a Java appointment status enum to define a fixed state lifecycle, covering waiting for approval, approved, upcoming, ongoing, complete, not approved, canceled, declined, and pending.

Implement appointment creation and deletion in Spring Boot by validating users, setting status to waiting for approval, assigning appointment number, and using JPA find by id and appointment number.

Implement the appointment update method by locating the existing appointment, enforcing waiting-for-approval status, and applying date, time, and reason updates with robust existence checks.

Create the appointment controller in a spring boot app by configuring a rest controller with /appointments and a get all appointments endpoint, including robust response handling and error management.

Learn to build the appointment controller to book an appointment, get by id, update, and delete appointments in Spring Boot, handling API responses and resource not found errors.

Demonstrates testing the appointment API with Postman, booking an appointment via API/v1/appointments, validating request params, and diagnosing a circular dependency during save.

Learn to break circular loading between appointment and user entities with json ignore properties and json format, then test appointment CRUD in postman.

Clean up the appointment API by centralizing URL mappings and constants, resolving ambiguous mappings, and standardizing resource not found messages and created at timestamps for future front-end work with React.

Explore pet API, focusing on the pet and appointment entities, their relationship, and how pet types like cat, dog, and fish use properties such as color, breed, name, and age.

Create the pet entity class with id, name, type, color, breed, and age. Map a many-to-one to appointment and a one-to-many to pets, using cascade all and adjacent properties.

Create the pet service interface and implementation, a pet controller and repository, and integrate create, read, update, and delete operations for pets, including saving lists for appointment bookings.

Implement a pet controller in Spring Boot app, wiring repository and service with Lombok, exposing endpoints to save, get by id, delete by id, and update pets with api responses.

Refactor the appointment service to accept a book appointment request with a list of pets, associate each pet with the appointment, and persist changes transactionally.

Test and finalize the pet API with Postman by booking appointments, managing pets (create, read, update, delete), and validating data in MySQL, including pet attributes and appointment linkage.

Explore the user image API on the dashboard to upload, update, or remove a profile image, and follow step-by-step implementation in IntelliJ.

Create a photo entity with id, file type, and image blob; map a one-to-one relation to the user with eager fetch, cascade, and orphan removal for clean persistence.

Create and implement the photo service class by defining the image (photo) entity, its CRUD interface, and a concrete service to handle multipart uploads, ids, and image data.

Implement a photo service class in spring boot by wiring photo and user repositories, handling uploads, converting bytes to blob, saving, updating, and deleting photos.

Implement a photo controller with rest controller and mappings to save, update, delete, and get by id via the photo service, handling path variables, request params, and errors.

Test the photo API with Postman by uploading, updating, getting by id, and deleting photos linked to users, ensuring file name tracking and uniform endpoints.

Fixes the photo api by including the user id in delete requests, ensuring the user owns the photo, and removing the photo transactionally while the user remains.

Develop the review API with a star rating component and feedback box, letting patients rate doctors after completed appointments, with one patient per doctor and one patient rating many doctors.

Create a review entity with id, feedback, and stars, and map many-to-one relationships to patient and veterinarian using join columns and JPA annotations, preparing for service and controller development.

Implement a review service in Spring Boot by creating a review service interface and a concrete class, enabling save, update, and get average rating for veterinarians, with paginated user reviews.

Implement the ai review service interface in a Spring Boot app, enabling paginated fetch by user id, a custom reviewer or veterinarian query, and save, update, and average rating operations.

Implement the save method of the review service, enforcing three rules: no self-review, no duplicate reviews, and only reviewers with a completed appointment may submit a review, then persist.

Implement the review controller to save a review via post, return the saved review, and handle illegal, conflict, and not found errors for veterinarian or patient.

Gain hands-on experience implementing a Spring Boot review controller, including careful renaming of endpoints and messages, and building a paginated endpoint to fetch all reviews by user id.

Implement a Spring Boot review update endpoint using a review update request with stars and feedback, keyed by review id, returning a success response and handling not found errors.

Implement update and delete methods for reviews in the surface class and controller, break relationships with users before deletion, and throw appropriate errors with feedback strings.

Test and wrap up the review api by adding an endpoint to return a veterinarian's average rating, validate with postman, and handle dto mapping for clean responses.