Ultimate Guide to Spring, Spring Boot, MVC & Hibernate

Learn inversion of control by outsourcing object creation to an object factory and using the Spring container to supply objects by configuration, via Java annotations or Java source code.

Explore Spring dependency injection and the Spring container, learning constructor and setter injections, auto wiring, and how dependencies are assembled and injected into controllers.

Learn constructor-based dependency injection in spring by defining an instructor interface and java instructor, injecting into a course controller, and exposing the /programming-exercise endpoint that returns a sum exercise.

Understand constructor injection and how Spring creates an instructor instance and injects it into the course controller, revealing dependency handling and Spring’s broader capabilities like database access and rest APIs.

Open start.spring.io, configure a maven java project, choose a non-snapshot spring version, add dev tools and spring web, generate, unzip, move to the desktop, and open in IntelliJ Reef.

Define a dependency interface and a Spring bean, use constructor injection in a rest controller, and expose an endpoint that returns the programming exercises result.

Learn how Spring Boot enables component scanning to automatically register beans in the application context, including configuring base packages to scan and understanding default and explicit scanning behavior.

Learn to configure Spring Boot component scanning by explicitly listing base packages with scanBasePackages, verify injection and endpoints, then revert to default scanning for simpler setup.

Master setter injection in Spring by wiring dependencies with @Autowired, creating setter methods, and injecting an instructor into a course controller.

Create the setter method in the course controller and annotate it with @Autowired; Spring will inject the dependency, and the method name can be anything, then test by refreshing.

Explore field injection with @Autowired, illustrating direct private field injection and how Spring bypasses constructors or setters, while highlighting why this older approach complicates unit testing and is not recommended.

Learn how Spring uses annotation-based qualifiers to resolve multiple bean implementations during auto wiring, and apply a qualifier to select Java instructor for constructor or setter injection.

Learn to use constructor injection in Spring, create multiple implementations of an instructor interface (Java, PHP, Python), and control bean selection with @Component, @Qualifier, and primary in the Spring container.

Discover how the primary annotation designates the main bean among multiple instructor implementations in Spring. Compare it with the qualifier annotation for precise injection.

Make one bean the primary to resolve multiple spring implementations, eliminating the qualifier, ensuring the application starts and outputs the chosen instructor.

Learn how lazy initialization defers bean creation in Spring Boot, using @Lazy and spring.main.lazy initialization, and explore how dependency injection and rest endpoints affect startup time and memory.

Discover how lazy initialization works in spring, enable it globally, and observe bean creation order and dependency resolution using @Lazy, qualifiers, and constructor logs.

Explore bean scopes in spring, including singleton, prototype, session, request, and global session, and how lifecycle and scope annotations control instance creation, sharing, and injection.

Learn to configure bean scopes in Spring by removing lazy initialization, injecting another instructor with a qualifier, and verifying the default singleton scope in a core Spring setup.

Create a /check endpoint to compare bean instances and verify singleton versus prototype scopes. Test shows singleton beans share the same instance (true) while prototype creates separate instances.

Explore how the Spring container initializes beans, injects dependencies, and runs lifecycle stages, then uses post construct and pre destroy to run custom init and cleanup code.

Explore Spring bean lifecycle methods by adding post construct and pre destroy annotations with init and clean up methods, and observe prototype scope disables destroy and is lazy by default.

Configure Spring beans with Java code by building a configuration class, declaring an @Bean method, and injecting the bean into a controller, including default bean IDs and third-party uses.

Configure Spring beans by defining a configuration class with a @Bean method returning a C instructor, assigning a custom bean id converter for injection into the controller.

Learn how Hibernate provides object-relational mapping and data persistence in Java, use JPA as a standard API, and perform create, read, and query operations via the entity manager.

Explore how hibernate and JPA relate to JDBC, acting as a layer on top of JDBC to save and retrieve objects via the JPA API, with JDBC handling connections.

Install MySQL and MySQL Workbench to set up your development environment, then use the MySQL server and Workbench GUI to create schemas and tables and perform CRUD operations.

Set up the database by downloading and applying user and employee SQL scripts to create a MySQL user and an employee table with id, first name, last name, and email.

Set up the Spring project by extracting scripts, configure a MySQL Workbench connection, create the Spring tutorial user, and create the employee schema and table for Java data insertion.

Set up a Spring Boot project with Hibernate JPA and an auto-configured data source using Spring Initializer and MySQL driver; configure application.properties for the employee schema and EntityManager usage.

Create a spring boot project on Spring Initializr with maven and java, using spring boot version, add MySQL driver and Spring Data JPA, then generate and rename to crud app-employee.

Define a command line runner bean in Spring Boot that runs after beans load. Configure jdbc url, username, and password in application.properties to test database connection and disable the banner.

Map a Java class to a database table using jpa annotations such as @entity, @table, @column, and @id with generated values, enabling object-relational mapping, with hibernate as default jpa provider.

Explore creating a JPA entity in IntelliJ by annotating with @Entity and @Table, mapping fields to columns, configuring id with identity strategy, and generating constructors, getters, setters, and toString.

Learn to build a crud app using a DAO pattern with a JPA entity manager, Spring Boot configuration, and a transactional save method to create, read, update, and delete employees.

Create a dao interface and implementation to persist employees with a repository and an injected entity manager, then save a new employee in the main app and verify with MySQL.

Learn how primary keys auto increment in MySQL with a generated value strategy by adding multiple employees in a Java CRUD app, and perform read, update, and delete operations.

Learn how to adjust MySQL auto increment values with alter table to start from a chosen number, reset with truncate to restart at one, and begin reading objects with JPA.

Read an object from the database using entity manager.find for the employee’s primary key, returning null if not found, then implement a find by id in the Dao.

Add a find by id method to the employee dao, implemented with the entity manager, to retrieve an employee by its primary key.

Explore querying multiple objects with JPA using JPQL, including constructing queries with where, like, and predicates, and using the entity manager to fetch lists of employees.

Implement a JPA query in the DAO to fetch all employees using a typed JPQL query with an entity manager, then display and sort results by last name.

Create a find by last name method using a typed JPA query with named parameters prefixed by colon, implemented via entity manager and tested in the crud app against MySQL.

Learn how to update entities with JPA using the entity manager, including single and bulk updates, merge, transactional annotation, and updating via a DAO implementation.

Learn how to update an employee via JPA by adding an update method, implementing it with transactional annotation and using EntityManager.merge, finding by ID, changing fields, and verifying the update.

Learn to delete objects with JPA using the entity manager to remove by id or via create query, and implement transactional deletes in the DAO for the main app.

Implement a JPA delete method in the employee Dao using EntityManager find and remove within a transactional context, then add delete all with a delete query, returning rows deleted.

Hibernate generates database tables from Java code and JPA annotations, using spring.jpa.hibernate.ddl-auto options to create, drop, or update schemas. Use for development and testing, but prefer SQL scripts for production.

Configure application properties to display sql and enable hibernate sql and jdbc bind logging as the app creates four employees. Learn ddl-auto controls table creation and update preserves data.

Explore how to build rest APIs and web services with spring, using json and http messaging, tested with postman to create a rest controller and crud interface.

Understand JSON as the JavaScript object notation, a language-independent plain text data format, defining objects with curly braces and double-quoted names, including numbers, strings, booleans, null, nested objects, and arrays.

explains rest over http, mapping post, get, put, and delete to crud on entities, with request and response messages and status codes, and introduces a rest controller built with postman.

Learn the basics of postman by sending get requests to fake APIs, inspecting HTTP responses, and exploring nested JSON objects, with future coverage of put, post, and delete.

Develop a simple Spring rest controller with the @RestController annotation, map /test and /greeting, and return hello; test endpoints in browser or Postman, and add the spring-boot-starter-web dependency in pom.xml.

Develop a Spring Boot rest controller by creating a project in start.spring.io, configuring Maven and Java, adding the web dependency, and implementing a simple /test/greeting endpoint that returns hello.

Define a Spring Boot rest controller with @RestController and @RequestMapping for /test/greeting that returns hello. Verify a 200 GET response using Postman.

Discover how json data binds to Java objects with Jackson in Spring, using getters and setters to drive json and Java conversions.

Create a Spring Boot rest service that exposes a GET /api/employees endpoint to return a hard-coded list of employees as JSON, with Jackson converting between Java objects and JSON.

Define controller and entity packages, create an employee object with constructors and getters, and build a Spring Boot REST controller that returns a JSON list of employees at /api/employees.

Create a get mapping endpoint to fetch a single employee by id via a path variable, bind the path variable to the method parameter, and return the employee as json.

Refactor a rest controller by adding a shared employee list initialized with @PostConstruct, and expose endpoints to fetch all employees and a single employee via path variables.

Handle exceptions in Spring rest by creating a custom employee exceptions response, a not found exception, and an exception handler that returns a 404 json error with a timestamp.

Create a custom error response and a custom employee not found exception, throw it for invalid IDs, and handle it to return a JSON 404 with status, message, timestamp.

Implement Spring Boot exception handling with a global @ExceptionHandler returning a JSON error; use 404 for missing employee IDs and 400 for invalid input, with custom messages.

Implement global exception handling by moving exception logic from a single rest controller to a controller advice, enabling reusable handlers across all controllers with Spring Boot.

Learn to implement global exception handling in Spring Boot by creating a dedicated controller advice class, moving exception handlers from the rest controller, and testing custom 404 and 400 messages.

Design a Spring rest API by identifying the requirements and the main entity, using HTTP methods to perform full CRUD on /api/teachers, and avoiding action verbs in endpoints.

Develop a spring boot rest api for a teacher directory, implementing crud operations to manage teachers in a mysql database, using spring initializer and jpa with hibernate.

Develop a teacher dao with the standard jpa api in spring boot, enabling create, read, update, and delete via an entity manager and jpql queries, plus a rest controller.

Configure IntelliJ to auto-load Spring Boot dev tools, update application.properties with the MySQL data source, and implement a teacher entity and dao interface mapped to the teacher row.

Implement a teacher dao with an entity manager. Annotate it as a repository, inject the manager via constructor, and expose all teachers at /api/teachers with a jpql query.

Create a teacher service as the facade between the rest controller and the teacher, courses, and skills daos, using the add service annotation and constructor injection to enable find all.

Define a teacher service interface and implementation that delegates findAll to the dao, use constructor injection with @Autowired, and wire the controller to the service, then test via localhost:8080/api/teachers.

Explore Spring Boot DAO operations using the entity manager to find by id, save via merge (insert or update), and delete by id, with service layer transactions.

Explore implementing full CRUD operations for a teacher DAO in spring boot, including find by id, create, update with merge, and delete by id using the entity manager.

Define and implement teacher service methods for find by id, update, and delete by id; annotate update and delete as transactional and delegate to the teacher dao.

Retrieve a single teacher by ID and create a new teacher through a Spring Boot REST controller, using Postman and content-type application/json.

Create a post endpoint to add a teacher at /api/teachers, bind the json body, set id to zero to force insert, and persist via the teacher service.

Implement a put method to update a teacher in a spring boot rest controller using a json body with the id, and return the updated teacher tested via Postman.

Implement a delete endpoint for teachers via a path variable, locate by id, throw an error if not found, delete by id, and return the deleted teacher id.

Explore how Spring Data JPA replaces repetitive DAO code by extending the JPA repository to auto-generate CRUD methods for entities, with no implementation class required.

Create a Spring Data JPA repository to replace the DAO, integrate it across the service and controller layers, and validate CRUD operations via Postman and MySQL.

Discover how Spring Data REST automatically exposes REST endpoints from your JPA repositories with no coding, by adding a pom dependency and scanning repositories for entities.

Refresh the MySQL data and set up a fresh spring data rest project, then test endpoints like /api/teachers and update the base path in application.properties.

Learn how spring data rest exposes crud endpoints, perform put and delete by id in the url, and replace controllers with a jpa repository.

Learn spring data rest pagination and sorting, including endpoint customization with repository rest resource. Explore default page size, zero-based pages, and base path configuration.

Configure spring data rest pagination and sorting by exposing /instructors, adjust default page size, and sort by last name in ascending and descending orders.

Explore Spring Boot rest api security by securing endpoints with Spring Security, using servlet filters, and defining users and roles with declarative or programmatic configurations.

Refresh the database and enable spring security to secure all rest api endpoints. Override the default username and password in application.properties to Maya and Smith, then test login.

Configure spring security by building an in-memory user store with three users Bob, Alice, and Emma and assign roles of teacher, manager, and admin, using no-op and bcrypt encodings.

Configure a security configuration class and in-memory user manager to define Bob, Alice, and Emma with roles teacher, manager, and admin. Verify REST access via basic authentication in postman.

Restrict content by role using Spring Security, granting read access on teachers to teachers, create/update to managers, and delete to admins, implemented via request matchers and HTTP basic authentication.

apply role-based access control in Spring Security by building a filter chain that restricts endpoints by teacher, manager, and admin roles, using http basic authentication and disabling csrf for APIs.

Test role-based access control for a rest api using postman, showing that Bob can read teachers but cannot create, update, or delete, with 200 and 401 responses.

Explore role-based access in a rest api, showing a manager can read and update teachers while delete remains for admins, demonstrated with Alice and Emma.

Move from hard-coded users to Spring Security JDBC authentication by using predefined users and authorities tables, wiring a data source, and updating the configuration to read usernames, passwords, and roles.

Create users and authorities tables in MySQL, insert sample users Bob, Alice, and Emma, apply bcrypt encoding, and assign roles like teacher, manager, admin with spring security role prefix.

Update Spring Security to use JDBC authentication with a data source and JDBC user details manager, replacing hard coded users and enforcing admin and teacher roles from the database.

Explains using spring security with bcrypt to encrypt passwords as a one-way 60-character hash stored in the database, and how JDBC authentication compares plaintext input to encrypted passwords.

Encrypt passwords with bcrypt in Spring Security, create a users table with a 68-character password field, and verify updates via Postman against encrypted credentials.

Configure Spring Security to work with custom users and roles tables by writing queries for users by username and roles by username, and update the Spring Security configuration.

Configure spring security with custom tables by using a jdbc user details manager and bcrypt passwords, and define username-based queries for users and roles.

Thymeleaf is a Java templating engine for generating HTML in web apps. Beyond web apps, it supports general use and collaborates with Spring.

Create a spring boot app from start.spring.io using maven and java, add thymeleaf and dev tools, and build an mvc controller with a /time endpoint that adds date to model.

Create a thymeleaf hello world template under resources/templates and auto configure spring boot to use thymeleaf, rendering a model date at /time with th:text, then run and verify.

Discover how to style thymeleaf templates with css in spring boot. Create a css file under source main resources static/css, reference it with th:href, and apply styles including bootstrap options.

Create a css file in a spring boot project, define a blue bold style, and apply it to a Thymeleaf template via a class reference using the context path.

Learn the core components of Spring MVC, including the dispatcher servlet front controller, model, view templates (Time Leaf), and controllers, with configurable XML, annotations, or Java-based setups.

Learners build a user form, read form data with Spring MVC, and display the entered name on a confirmation page via two request mappings in a user controller.

Create a Spring MVC controller and a Thymeleaf form, map /user info to display the form, and submit data to /process info via a get request with a username input.

Build and test a Spring MVC form workflow from /user-info to /process-info, capture the username with a Thymeleaf param, and display a hello world response.

Learn to use the Spring model as a data container, read form data, convert it to uppercase, and add a message to the model for display in the view.

Demonstrates Spring MVC model usage by processing a form in the user controller: read username, convert to uppercase, and add a message to the model for the hello world page.

Read form data in Spring MVC using the @RequestParam annotation to bind the username to a method variable, replacing manual HttpServletRequest handling and displaying a hello message.

Learn get mapping and post mapping in Spring MVC, compare data in the URL versus the body, and use add get mapping or add post mapping for processing info.

Explore get mapping and post mapping in Spring by switching a controller from request mapping to specific methods, testing in browser, and observing data flow in URL vs request body.

Learn to implement data binding in spring mvc forms using thymeleaf, a model attribute, and a user bean to capture full name and gender, then display a confirmation page.

Learn data binding in Spring 6 by building a user form. Create a user model, a controller with get and post mappings, and thymeleaf templates for text fields.

Learn to implement drop down lists in Spring MVC forms by using the HTML select tag and th:value in Thymeleaf to submit a movie type like comedy or thriller.

Explore how to implement radio button input in a Spring MVC form, binding to a user object's movie age property, and display the selected value on the confirmation page.

Define ages in application.properties, inject them into the users controller, add them to the model, and render as radio buttons in the html form bound to the user’s movie age.

Learn to implement Spring MVC forms using checkboxes to let users select movie quality (SD, HD, UHD); submit to the controller and show on a confirmation page.

Bind check boxes to a user's movie quality list, display chosen qualities on the confirmation page, and test the form in the browser with hard coded values.

Add a qualities list in application.properties and bind it to the model, then iterate over qualities with th:each to render movie quality checkboxes in the user form.

Learn to set up Spring MVC validation projects and enforce required fields, range checks, regex patterns, and custom validations via Bean Validation and Thymeleaf.

Learn to implement form validation in Spring MVC by enforcing a required address field with not null and min size, wiring model attributes, and handling success or error flows.

Learn to implement Spring MVC validations by building a subscriber model with Jakarta NotNull and Size constraints, and wiring a controller to display a subscriber form with model binding.

Develop a Thymeleaf-based subscriber form with validation in Spring MVC, posting to /process, displaying field errors, and wiring a post mapping with @Valid and BindingResult to show a confirmation page.

Create a confirmation page displaying the subscriber's full name and address, validate required fields, and trim whitespace using the init binder and string trimmer editor in Spring MVC validations.

Enforce Spring MVC number-range validations for enrolled courses (0–20) using min and max annotations in the subscribers class, display error messages on the HTML form, and update the confirmation page.

Implement range validations for enrolled courses with min and max constraints (0 to 20). Generate getters and setters, display form errors, and confirm the entered value on the confirmation page.

Apply regular expressions to validate a six-character or digit ID in Spring MVC using a pattern annotation, and display errors while preserving user input on the confirmation page.

Add a six characters or digits validation rule in the subscriber class using pattern annotation, wire it into the HTML form, and display the entered ID on the confirmation page.

Master custom validations in Spring MVC by creating a coupon code annotation and constraint validator. Enforce a rule that the coupon code starts with free in a three-field form.

Learn how to create a Spring MVC custom validation annotation for coupon codes, define constraint validator, set target and retention, and implement runtime validation logic.

Implement Spring MVC custom validations by adding a coupon code field, using a custom annotation, and displaying tailored error messages on the HTML form and the confirmation page.

Build a Time Leaf based Spring Boot CRUD web app for a teacher directory, enabling list, add, update, and delete via the teacher controller, service, repository, and entity.

Download and set up the starter code, unzip and move it into your project, run the sql script in mysql workbench to seed data, and verify the rest api at localhost:8080/api/teachers.

Create a Spring MVC controller for /teachers, inject the teacher service via constructor, fetch all teachers with the service, add them to the model, and return the get-dash-teachers-row.html Thymeleaf view.

Build a get-teachers thymeleaf page and verify the Spring MVC flow from browser request to controller, service, repository, and database, rendering raw data in the template.

Enhance a Thymeleaf table with Bootstrap styling to display a dark, bordered, striped, hoverable teachers list that loops through teachers to show first name, last name, and email.

Learn to add a teacher using Thymeleaf by building a form, binding data with a model attribute, and saving via a controller service repository, then redirecting to the teachers list.

Refactor templates into a teachers folder, route to add-teacher, and build a thymeleaf bootstrap form to capture a teacher’s first name, last name, and email via /teachers/save-teacher.

Learn to build a crud add-teacher workflow with form layout tweaks, a back-to-teachers-list link, and save action with redirect; enable sorting by last name via Spring Data JPA.

Learn how to use thymeleaf to update teachers by adding an update button, pre-populating the form with the selected teacher's data, and saving updates via the teacher service.

Add an update button and a pre-populated update form for teachers, wiring the UI and controller with a teacher id, hidden field, and model binding to complete the CRUD update.

Add a per-row delete button with the teacher ID, confirm before deletion, then implement a controller endpoint to delete by id via the service and redirect to the teacher list.

Add a delete button for teachers with an id link and a JavaScript confirm calling /teachers/delete-teacher and deleteById. Redirect to /teachers/get to finish the CRUD and preview spring mvc security.

Enable authentication and authorization in Spring MVC security with login pages and role-based access. Learn about servlet filters, declarative versus programmatic security, and securing endpoints with Spring Boot Starter Security.

Set up a Spring MVC security project using Spring Initializer, add Maven dependencies for Spring Web, Time Leaf, and Spring Security, and build a home controller and home page.

Configure build settings and run the application to verify spring security on localhost 8080, log in with the default username and generated password, and confirm a secured home page.

Configure spring security with an in-memory user store for Bob, Alice, and David (HR, supervisor, admin), using no-op passwords now, with bcrypt and database later.

Create a spring security configuration class and an in-memory user details manager with Bob, Alice, and David occupying HR, supervisor, and admin roles; test login at localhost:8080.

Configure spring security to use a custom login form, create a login controller and HTML page, and post authentication data to /authenticate with username and password fields.

Learn to implement a custom login form in spring security by configuring the security filter chain, creating a login controller and thymeleaf login page, and wiring the authentication url /authenticate.

Add a login error message when credentials fail, using a conditional error parameter, and style it in red with a css class, and plan to incorporate bootstrap styles next.

Style and implement a Bootstrap login form for a Spring security project by updating the HTML, wiring the form to the /authenticate processing URL, and validating username and password fields.

Learn to implement spring security logout by adding logout support, a home page logout button, and a login page message that clears the session and redirects to login.

Learn to display user IDs and roles on the home page with spring security, using authentication and principal.username and principal.authorities to tailor content by role.

Define role-based access in a spring mvc app with spring security by mapping home to HR, supervisors to supervisor, and admin operations, using request matchers and has role checks.

Implement role-based URL restriction by wiring controllers and Thymeleaf view pages for home, supervisors, and operations; create a supervisors page with a supervisor-only access block and navigation.

Implement role-based access control by configuring request matchers for /, /supervisors/**, and /operations/**, requiring authentication and specific roles (air, supervisor, admin) to view each page.

Configure a custom access denied page in a Spring app by handling exceptions, mapping /unauthorized, and creating an unauthorized HTML page under resources/templates for a styled message.

Show content based on user roles by restricting links and pages to supervisors and admins, test with role-based access, and redirect unauthorized users to an unauthorized page.

Configure spring security to read users and roles from a database using the default jdbc schema, creating users and authorities tables and enabling jdbc authentication.

Download and run SQL scripts to create users and authorities tables, populate Bob, Alice, and David with roles, and configure JDBC in application.properties and pom.xml for a Spring Boot project.

Update security configurations to enable JDBC authentication with a data source using JdbcUserDetailsManager. Test reads from the database’s users and authorities tables to authenticate users and verify password changes.

Learn how to store passwords securely in Spring Security using bcrypt encryption, including salting and one-way hashes, and how JDBC authentication compares encrypted passwords during login.

Configure a spring security database with bcrypt encryption by creating users and authorities tables, storing bcrypt-hashed passwords, and validating login and password changes.

Drop default spring security tables and create custom tables team and roles with bcrypt passwords; configure JDBC user details manager to read usernames and authorities from these tables.