Java Spring Boot Full Stack: eCommerce Project Masterclass

Explore how the internet and the world wide web differ, and how a client–server model uses urls, domains, dns, ip addresses, https, and browser rendering of html, css, and javascript.

Understand the client–server model, where a client like a web browser, email app, or mobile app requests services from an always-on server, receives data, and displays web pages.

Learn how APIs enable software to communicate through rules and requests, using a restaurant analogy, and explore private, partner-based, and public APIs that automate data access.

Explore the four main API request types—get, post, put, and delete—and how and when to use them, with common status codes like 200, 201, 400, and 404.

Understand the REST API architecture and statelessness. Learn how HTTP methods like get, post, put, and delete power scalable, cacheable web services exchanging data as JSON or XML.

Explore http and https, compare security and data integrity, learn client-server requests (get, post, put, delete) and stateless sessions, and recognize certificates protecting web traffic.

Explore how http status codes indicate api request results between clients and servers, and classify them into 1xx informational, 2xx success, 3xx redirection, 4xx client error, and 5xx server error.

Learn the concepts of resource, URI, and subresource in web development, with examples like user profiles, posts, and comments, and understand their role in RESTful design and scalability.

Kick off the course by introducing yourself in the Q&A, sharing your professional and academic background and motivation, plus a few facts, including if you came from the YouTube channel.

Explore how web frameworks speed development by providing prebuilt components for pages, security, and databases, so you can focus on business logic using Spring Boot, Django, Flask, Express, and Rails.

Explore how Spring provides a lightweight alternative to Java EE, simplifying enterprise development with modularity, testability, dependency injection, and tools like Spring Boot, Spring Data, Spring Security, and Spring Cloud.

Explore tight and loose coupling in software design and how interfaces, abstractions, dependency injection, and event-driven architecture enable flexible, maintainable, and scalable Java applications.

Explains tight coupling and loose coupling with a Java example, using a user data provider interface and concrete providers to show passing implementations via a constructor.

Learn how loose coupling via interfaces enables modular data providers, and how inversion of control and dependency injection, with beans and configuration, are managed by the Spring Framework.

Explore how the Spring container manages object lifecycles and dependency injection, compare application context and bean factory, and define beans with configuration files.

Set up a Maven-based Spring project from a Maven base by declaring Spring core and Spring context in pom.xml, then refresh to download dependencies and populate external libraries.

Create your first spring bean and configure it with an xml bean definition, then load the context from classpath xml, inject a message via a setter, and print the bean.

Explore the life cycle of a bean defined by XML or annotations in the spring container, from instantiation and property population to initialization and destruction.

Explore dependency injection to achieve loose coupling by removing direct instantiation and providing dependencies at runtime through constructor injection or setter injection.

Learn constructor injection, a dependency injection approach that supplies dependencies through a constructor, ensuring they are available at object creation, demonstrated with a car-specification example in Spring XML.

Discover setter injection in Spring by replacing constructor injection with setters, wiring dependencies via the XML property tag and ref, and loading the application context.

Adopt inversion of control with Spring by wiring three user data provider implementations via constructor injection, using an application context to obtain user manager beans.

Explore auto wiring in Spring: learn how the framework auto resolves and injects bean dependencies via type, name, or constructor, reducing XML wiring while noting trade-offs.

Discover how autowiring by name in Spring resolves dependencies by matching bean names, using setters for initialization, as shown with car and specification and a by-name example.

Explore autowiring by type in spring, where the container injects a bean by type and requires a single matching bean to avoid type conflicts and run successfully.

Learn how autowiring by constructor works in Spring Boot, including defining a constructor, XML configuration, and resolving multiple matching beans.

Learn how annotations add metadata to Java code, enabling Spring and Spring Boot to configure beans, autowire dependencies, and define components, services, repositories, and request mappings in web controllers.

Explore how spring registers components as beans via the IoC container, using xml or the component annotation, and enable component scanning to auto register beans from a base package.

Create and register Spring components using component scan without annotations, demonstrating how base package settings identify beans like an Employee class and wire them into a running app.

The value annotation injects values into beans, from default strings to system properties and computed expressions. Use it to set hello, Java home, or other expressions producing a computed result.

Transition from xml to annotations by replacing xml configuration with a Java config class annotated with @Configuration and @ComponentScan, then load it using AnnotationConfigApplicationContext.

Explore how the @Autowired annotation enables automatic dependency injection in Spring, using constructor and field injection to inject an Employee into a Manager, and discuss best practices favoring constructor injection.

Use the qualifier annotation to resolve multiple beans of the same type in the spring container by selecting the bean name to inject.

Review progress on the basics of web development and Spring Framework, including dependency injection, inversion of control, and explicit bean configuration; discuss component scanning, boilerplate security, and Spring Boot simplification.

Spring Boot is an open source Java-based web framework for building standalone production-grade applications on top of Spring and Java, reducing boilerplate with pre-configured components, embedded server, and starters.

Learn Spring Boot architecture across presentation, service, and data access layers, where controllers process requests, pass them to services, and repositories access relational or NoSQL databases.

Explore spring initializer at start.spring.io to generate a spring boot project with maven and Java 17. Select spring boot 3.x, add web dependencies, and import the generated project into IntelliJ.

import a spring boot project into IntelliJ from Spring Initializr, trust the project, and explore the pom.xml, dependencies, and starter web configuration for a robust Spring Boot setup.

Explore how dependencies are managed with Maven or Gradle and a pom.xml, using Spring Boot starter web to reduce boilerplate and include third-party libraries.

Develop a simple hello world restful api with spring boot by creating a hello controller, mapping a get request to /hello, and running the app on tomcat port 8080.

Spring Boot starts Tomcat on port 8080 and loads the default profile. A browser get request hits the controller, processes the method, and returns the http response.

Explore Spring Boot auto configuration that sets up Tomcat, the dispatcher servlet, and rest controller beans. See how get mapping activates endpoints and how default error mapping works.

Explore how Spring Boot uses application.properties for configuring apps, with key-value pairs, server port customization, database connections, and command-line overrides, including YAML alternatives.

Create and handle a post request in spring boot by defining a post mapping and binding a request body name; compare it to get mapping and test with postman.

Learn how to install and use Postman to execute post requests, send request bodies, and view responses for a Spring Boot api, including get/post workflows and status 200.

Learn how to save and organize Postman requests by creating and using collections, signing in, and onboarding to manage history and environments.

Understand how spring boot converts java objects to json responses via rest controller and jackson, using getters and message converters enabled by spring boot starter web.

Explore how path variables in Spring Boot enable dynamic URLs by binding URI template variables with @PathVariable, producing SEO-friendly endpoints like /users/{id}.

Build and test a hello banking API with get and post endpoints in Spring Boot, practicing controllers, request bodies, and basic endpoint testing with browser and Postman.

Download and import the Postman collection from the course GitHub repo to access pre-configured APIs for the e-commerce project, Hello World, and social media apps.

Set up a Spring Boot e-commerce project using start.spring.io with Maven, Java 17 or 21, add web dependency for RESTful services and Spring MVC, generate, unzip, open in IntelliJ.

Structure your thoughts to build a hands-on category module in a Java Spring Boot app, routing requests from controller to service to repository with admin and public API endpoints.

Fetches all categories using a category controller and a category model in a Spring Boot e-commerce project, exposing a GET /public/categories endpoint to return the category list.

Add new categories to your Spring Boot API with a post mapping that accepts a category object in the request body and returns 'category added successfully'.

Move category logic from the controller into a service layer in a Spring Boot app by defining a category service interface and its implementation, enabling loose coupling and dependency injection.

Discover how to auto generate unique ids for categories in a Java Spring Boot ecommerce project, overriding user supplied ids in the service layer.

Implement a delete category api using a delete mapping with a path variable, locate the category via streams, remove it, and return a status message or category not found message.

Learn to control HTTP responses with the Spring ResponseEntity class, handling not found errors with 404 and ResponseStatusException to return meaningful status codes.

Learn to use response entity across all endpoints, including created, ok, and not found statuses, with body content for get all and delete category in Spring Boot e commerce project.

Update the category endpoint with a put mapping, accepting the category object and id, updating the existing category via the service, handling optional presence, and returning a saved category response.

Explore the request mapping annotation in Spring Boot, learn class-level prefixes, method-level endpoints, and how to specify HTTP methods to create clean, flexible API endpoints.

Explore how relational and NoSQL databases organize data with schemas, tables, and JSON key-value formats to power persistent, dynamic information behind apps.

Discover what a database management system (DBMS) is, acting as the interface between users and databases, covering relational and NoSQL types, with data abstraction, security, and backup and recovery.

Explore relational database concepts by examining tables, columns, and rows, and learn why a primary key uniquely identifies each record in an e-commerce context.

Learn how to access and retrieve data from relational databases using SQL queries, including select statements, and explore DQL, DML, DDL, DCL, and TCL for data management.

Explore how object-relational mapping (orm) automatically maps classes to tables and attributes to columns, converts objects into rows, and saves data with simple methods like save.

Understand what JPA is and how it maps Java objects to relational tables, enabling persistence, easy querying, and CRUD operations within Spring Boot.

Explore the H2 database, a fast open source relational database built in Java, ideal for development and testing with Spring Boot, offering embedded and server modes and a browser console.

Configure the project with JPA and the H2 database by adding dependencies and enabling the H2 console, then run the app to access the console and verify data persistence.

Map a category class to a database table with a jpa entity and an @id key, customize the table name with the name attribute, and view it in h2 console.

Explore how spring boot with hibernate and jpa manages an in-memory h2 database, showing sql for the category table, formatting, and ddl-auto options like create, update, and create-drop.

Map the category class to a JPA entity and configure the primary key with generated value. Compare auto, identity, sequence, and table generation types across databases like MySQL and PostgreSQL.

Define and configure a category repository by extending JpaRepository<Category, Long>, enabling Spring Data to auto-generate CRUD operations for the category table.

Learn to persist category data in a Spring Boot app by wiring a category repository, using find all, save, and delete methods via JPA.

Run the spring boot app and test changes using postman endpoints to create, update, and delete categories. Verify data persistence via the h2 console with jpa repositories.

Optimize category services by using find by id with Optional, throwing not found when missing, and streamline save and delete logic for improved database operations.

Explore how getters and setters influence API responses by experimenting with the category model, and observe how Hibernate and JPA generate CRUD queries through the category repository.

Build a bank customer CRUD API using Spring Boot, Spring Data JPA, and H2 in-memory database, exposing REST endpoints for create, read, update, and delete.

Lombok is a Java library you add to your project that automatically generates boilerplate code via annotations, such as getters, setters, constructors, toString, and equals/hashCode, boosting productivity.

Explore essential Lombok annotations for Java, including getters and setters with configurable access levels, various constructors, data and value, not null, builder, and cleanup for automatic boilerplate reduction.

Enable dark mode in IntelliJ to reduce eye strain, switch via settings or Mac preferences, and apply the dark theme to all future lectures for easier code viewing.

Install and enable the Lombok plugin in IntelliJ and restart the IDE. Then turn on annotation processing under compiler settings to ensure Lombok generates getters and setters.

Configure a Spring Boot project with Lombok by adding the Lombok dependency from Start.spring.io, enabling annotation processing, and using Lombok annotations like data and no-args and all-args constructors.

Discover how Spring Boot validations use Jakarta Bean Validation and Hibernate Validator with annotations like not null, not empty, size, and email to protect data quality.

Learn how hibernate validator enforces annotation based constraints, such as not blank category names, within a Spring Boot app and its integration with hibernate ORM for safe persistence.

Use @Valid to validate the request body against model constraints and trigger jakarta validation constraint violation exception, delivering a user friendly 400 error when category name is not blank.

Create a global exception handler with RestControllerAdvice to customize method argument not valid exception into a user friendly 400 bad request response by mapping each field to its message.

Add a minimum five-character size validation for the category name with a custom message, and observe how 400 bad requests return user-friendly JSON for front-end error displays.

Leverage custom exceptions in Spring Boot to separate business logic from web concerns, enabling reusable, consistent error handling with detailed information and handling via controller advice alongside response status exceptions.

Implement a resource not found exception in a Spring Boot API, create a custom runtime exception, and handle it globally with a response entity in controllers.

Replace the response status exception with a custom resource not found exception in the category service, leveraging the global exception handler and using resource name and field id parameters.

Create a custom API exception to enforce unique category names and report when a category already exists. Use Spring Data JPA to generate a find by category name query.

Implement a service validation to fetch all categories and throw an API exception with 'no category created till now' when the list is empty; otherwise return the list.

Clean up and streamline controllers by moving validations to the model and service, making controllers lightweight and delegating logic to the service implementation with global exception handling.