Spring and Spring Boot - Learn by building projects

Install the MySQL community server on Windows, configure a local instance, and connect with MySQL Workbench to manage schemas (databases) for local development in Spring projects.

Learn to generate a new Spring Boot project in Eclipse using Spring Tools, configure dependencies (Web, Dev Tools, Thymeleaf), and run with live reload for automatic refresh.

Learn to develop Java in Visual Studio Code by installing the Java extension pack, configuring the java home variable, creating a Java project, and running and debugging code.

Learn to install Maven on Windows by setting JAVA_HOME, adding MAVEN_HOME, updating the bin path, downloading the binary zip, extracting it, and verifying with mvn -version.

Learn to integrate Spring Boot into Visual Studio Code, generate a Maven-based project, and add dependencies like Spring Web Starter, Lombok, and DevTools, then run locally to verify setup.

Create a new Spring Boot project in Visual Studio Code with Maven, web, devtools, and Thymeleaf; run the cml shopping cart application via the springboard dashboard or debug mode.

Create your first Spring controller for the root path, annotate with @Controller and @GetMapping("/"), return the home view template, and run the app with live-reload via dev tools.

Implement a web config class to configure Spring MVC, overriding the view controller registry to map the root path to the home view, offering a simple alternative to controller methods.

Learn to add bootstrap via a cdn, create and reference a custom style.css in a static folder, and ensure assets load with live refresh and auto save during development.

Create a Thymeleaf fragments folder and split the template into head, nav, and footer fragments, then include them with th:fragment and th:replace from templates/fragments.

Create a new database schema for a shopping cart and build a pages table with id, title, slug, content, and sorting columns, all not null, to store and order pages.

Build a page entity mapped to the pages table using JPA annotations, implement with Lombok getters and setters, and configure a MySQL connection in application properties.

Create the ad page in the admin pages using a get route that renders a thymeleaf form bound to a page entity, and a post route for validation and errors.

Validate the page entity with javax validation, enforce minimum sizes for title and content, customize error messages, and apply the autowired annotation in the admin pages controller for cleaner injection.

Handle a post request to add a new page with form validation, slug generation, and slug uniqueness checks using spring data jpa, with flash messages and redirect.

Finish the post add page flow by handling post mapping, showing flash messages with dynamic classes, and preserving slug and inputs on validation errors.

Fetch a page by id in the admin area, pass it to the edit view, and render a form for title, slug, and content.

Learn how to implement a post edit page in Spring Boot: handle slug validation to avoid duplicates, fetch and preserve the current title, and redirect after saving.

Add delete page functionality with a javascript confirmation, integrate jquery for deletion confirmation, and implement a redirect with a flash message on the admin pages index.

Sort pages with jQuery UI sortable and post the new order to the backend. Spring Boot updates each page's sorting and retrieves pages ordered by sorting ascending.

Create a categories table with id, name, slug, and sorting; map it to a Category entity with validation; implement a CategoryRepository extending JpaRepository.

Explore building a get add category endpoint in the categories controller with a get mapping /ad, create the corresponding view, and experiment with model attributes and form handling.

Handle a post request to add a category in a Spring Boot app, including validation, slug generation, existence checks, saving the category, and redirecting with messages.

Handle the post edit category request by validating the category name and slug, checking for existing categories, and removing irrelevant TH values while updating to redirect to admin categories edit.

Add sorting to categories by implementing a reorder endpoint and a repository method that orders categories by the sorting column in ascending order.

Build the admin products index by creating a controller, wiring the product repository, and rendering a view that lists all products.

Process a POST request to add a product with image upload via multipart file, validate the file type (JPEG/PNG), generate a slug from the name, and save the product.

Finish the ad product post form by fixing binding errors, adding an image label and dynamic image preview, and wiring read URL for uploads to the static/media path.

Fix product creation in a Spring Boot app by correcting the category id field, configuring a media upload path with resource handlers, and validating image uploads (jpg/png).

Map category ids to names in the products index, display product images and prices, and render category names instead of ids to improve the listing.

Set up the get edit product flow in the admin controller. Copy logic from the pages controller and prepare the edit view with product name, price, category, and current image.

Learn how to implement a post edit for a product in a Spring app, including optional image handling, slug validation, current product retrieval, error handling, and save/redirect logic.

Add a foreign key constraint from products.category_id to categories.id with on delete cascade, and create an index; deleting a category cascades to its products.

Add twelve products for the course, including six shirts and six fruits, with images, descriptions, and prices assigned to the fruits and shirts categories.

Revisit the web config to set the resources location and explain why uploaded images may not display until the resources are copied to the class path for deployment.

Implement delete product functionality by copying the delete logic from the admin pages controller into the admin products controller, including deleting the product image and updating the products list.

Implement admin product pagination by using a pageable findAll query with six per page, optional page parameter, and exposing page count and total items to the admin view.

Learn to implement admin products pagination with a numbered navigation, previous/next links, an active page highlight, and query strings like ?page=X.

Learn to integrate ckeditor as a rich text editor for content and description text areas, configure it in app.js, and adjust height to 200px.

Build the front-end home page by creating a pages controller, mapping the root route, and rendering a shared page view with content from the page repository.

Create a dynamic shared navigation menu across all views using a controller advice, model attributes, and a page repository to fetch pages in order and render links.

Map dynamic pages with a Spring controller using /{slug}, fetch pages by slug, redirect to the homepage if missing, and render the page model for about and services.

Learn to display products on the front end by building a categories controller, wiring category and product repositories, and handling slug-based category routes.

Develop the front end view for displaying products, including category menu, product cards with image, name, description, price, and a nonfunctional add to cart placeholder.

Fix category id handling and title display to correctly list products by category, convert between string and integer, apply the Elvis operator, and test per page pagination.

Create a cart model class in the models package to hold products, with fields id, name, price, quantity, and image; annotate with data and generate a constructor using fields.

Build a cart controller in Spring Boot to add products to a session-based cart using a product repository, session attributes, and a hash map of cart items.

Builds and displays a cart partial fragment, showing the cart size and total when the cart is active. Wire session and model attributes, and provide view and clear cart links.

Implement add to cart with an ajax request to update cart contents, size, and totals, then render the cart view from templates and show a product added message.

Learn how to implement an ajax-based add-to-cart workflow that posts a product, updates the cart view, shows a loader, and displays a product added message with fade in/out.

Build a cart page in Spring Boot by validating the session and rendering a view that lists cart items with image, quantity, price, and total, plus add, remove, and update actions.

students implement cart page enhancements by adding clear cart and checkout links, preparing ajax-driven paypal submission, and using a cart page query parameter to control redirection and view rendering.

Teach subtracting items in the cart by updating the cart controller to remove a product when its quantity is one, or decrement otherwise, then redirect to the referer.

Implement removing a product and clearing the cart by adding remove and clear endpoints, updating the session, and redirecting back to the cart view.

Learn to add PayPal checkout to a shopping cart using two integration methods, including itemized forms with name, amount, and quantity, plus sandbox testing.

Add the Spring Security dependency to enable lockdown of all requests. Restart the app, then log in with the generated username user and its password to access the home page.

Learn to use application.yml as an alternative to application.properties and note that properties are read first. Add a spring security user and password in yaml, restart server, and verify login.

Configure Spring security with a security config class to redirect signed-out users to login, define root access, and illustrate role-based access for users and admins.

Compare security configurations in spring using standard access methods and spring expression language, showing precedence rules and crafting access like /category/** with has any role or permit all.

Create users and admins tables to support authentication, defining id as primary key and auto increment, and fields for user name, password, email, and phone number.

Define and configure user and admin entities that implement spring security’s user details, map to users and admin tables, include validation on username, password, email, and a transient confirm password.

Create a registration controller and define user and admin repositories within spring security, wiring a bcrypt password encoder as a bean for secure user registration.

Handle the get register request by adding a register method in the registration controller. Build a register page form with username, password, confirm password, email, and phone number.

Explore implementing a post register endpoint in Spring Boot, including password encoding, user persistence, password match validation, and redirecting to the login page with form validation.

Explore how the user details service retrieves user data for authentication within a Spring security setup, implementing a custom user details service and repository lookup.

Develop a custom login page integrated with Spring Security, using /login with username and password, enforce user and admin access, and redirect to protected pages like products.

Implement a dynamic main navigation that shows the logged-in user name and logout, or login and register links when not logged in, using the principal attribute in Spring.

Demonstrates implementing admin login, testing access control for admin sections, handling failed logins with invalid credentials alert, and redirecting unauthorized users to the home page in a Spring Boot application.

Explore how spring security's csrf protection affects ajax post requests and how to add csrf tokens and headers to enable correct category and page reordering.

Update the project by removing the store, adding a contact page, and fixing missing columns and categories with a slug and h1 headings.

Create a rest api project with Spring Boot by initializing a project, adding Spring Web, Lombok, DevTools, Jpa, and Jdbc dependencies, configuring properties, and launching to view in a browser.

Create a page entity and page repository in the rest api models, organize them under a data package, copy implementations from another project, and adapt packages for rest api exposure.

Define a REST controller for a Spring Boot RESTful API, expose /pages/all to return pages as JSON, and fetch them using a page repository ordered by sorting ascending.

Handle a get request for a page by slug, query the page via repository, and return a response entity with 200 ok when found or 404 not found when absent.

Create a new admin pages controller class, remove comments, and wire in the page repository. Map an index method to the admin/pages route and verify by visiting /admin/pages.

Learn how to implement a get edit page in a Spring Boot admin controller, fetching a page by id with Optional and returning a response entity.

Implement a restful edit flow by handling a put request to update a page from the request body and save the page to return a page report.

handle the delete page request with a delete mapping, delete by id, and return no content, while catching empty result data access exceptions to ensure no change if not found.

Create a page entity and repository, copy and customize template files from the admin templates, and organize static assets (css, js, images) and fragments for the new page.

Learn how to consume an API with RestTemplate in a Spring client, configure web config, build a pages controller, fetch home page from /pages/home, and bind it to model.

Implement a get page endpoint that retrieves a page by slug from the database, uses a model, and redirects to the homepage if the page does not exist.

Implement the main menu by creating a common class with controller advice, wiring a RestTemplate, and rendering a list of pages via a get request and a model attribute.

Implement get and post handlers for adding a page in a spring boot app, reusing controller methods, and save the page via a REST API at admin/pages/add.

Learn to implement get and put page operations in a Spring Boot app by using the admin pages edit URL and passing the page id to update content.

Implement the delete page feature by wiring the client to call the API's delete method at /admin/pages/delete/{id}, test the deletion, and confirm the page is removed.

You can buy any course for ten dollars and access great deals and the best prices through my website. Check it out today.