Master Hibernate and JPA with Spring Boot in 100 Steps

Explore why Spring Boot enables building web applications and REST APIs, compare it with Spring MVC, and learn auto configuration, developer tools, and actuator through a hands-on project.

Compare the pre-spring boot era, where teams manually managed dependencies and XML configurations, with Spring Boot that streamlines setup, logging, error handling, and monitoring.

Set up a new Spring Boot project with Spring Initializr, configure Maven and Java versions, add Spring Boot web dependencies, and run on Tomcat (port 8080).

Build a simple rest api with Spring Boot and expose the /courses endpoint to return a list of courses with id, name, and author.

Understand the goal of Spring Boot: quickly build production-ready applications using starter projects, auto-configuration, and dev tools, with environment-specific configurations and actuator for monitoring.

Spring Boot starter projects provide convenient dependency descriptors that bundle web, test, and data features (for example, spring-boot-starter-web-mvc and spring-boot-starter-data-jpa) for quick rest api development, with configuration next steps.

Explore how Spring Boot auto-configuration simplifies web applications by auto-configuring dispatcher servlet, embedded Tomcat, and JSON conversion via Jackson based on class path and existing settings.

Boost your development productivity with Spring Boot DevTools, enabling automatic restarts on code and property changes, and clarifying that pom.xml changes require manual restart.

Use spring profiles to create environment-specific configurations, with separate application-dev.properties and application-prod.properties merged into default properties, and set spring.profiles.active to switch dev and prod environments and logging levels.

Configure a currency service with configuration properties and a currency service prefix to map url, username, and key. Leverage profiles to switch configurations via application properties.

Learn how Spring Boot embedded servers simplify production deployment by running a single jar that includes Tomcat by default, with options for Jetty or Undertow.

Learn how spring boot actuator enables production monitoring by exposing health, metrics, beans, and mappings endpoints, and how to enable and configure them via application.properties for your app.

Explore Spring framework's dependency injection and component scanning, Spring MVC for web and REST APIs, and how Spring Boot wraps Spring MVC with starter projects and auto configuration.

Review a high-level overview of Springboard concepts, including startup projects, auto configuration, and actuator dev tools, and explore the production-ready advantages as you build more features.

Discover strategies to improve long-term memory through active learning and regular review. Learn to take notes when you learn and review them every few days or weeks to reinforce retention.

Explore the journey from spring jdbc to JPA, migrating a simple spring jdbc example to JPA, and learn JPA basics, entities, repositories, and CRUD operations.

Set up a Spring Boot project with JDBC, JPA, H2, and Web dependencies using start.spring.io, import as a Maven project, and run a basic app on Tomcat 8080.

Connect to an embedded H2 in-memory database and launch the H2 console via Spring Boot auto configuration; explore tables, create data, and learn how to switch databases by adjusting properties.

Create a person table in h2 via data.sql, leveraging Spring Boot auto configuration, defining id (primary key, not null), name, location, and birth_date (timestamp), then verify in the h2 console.

Populate the person table by executing an insert query and seed data with data.sql to insert 10001 Ranga Hyderabad, 10002 James New York, and 10003 Peter Amsterdam for JDBC practice.

Implement a Spring JDBC find all method in a Person JDBC DAO using JDBC template to query the person table and map results to a Person bean via BeanPropertyRowMapper.

Execute the findAll method at startup with a Spring Boot command line runner, autowire the person JDBC DAO, log results, and format output with a toString for clear, line-by-line display.

Compare jdbc with spring jdbc and see how spring jdbc simplifies code and prevents connection leaks using the jdbc template.

Explore how Spring Boot auto configuration wires JdbcTemplate and data source by detecting classpath items like H2 and web servlet, and view the auto configuration report in debug mode.

Implement a findById query using Spring JDBC's queryForObject to fetch a single person by id with a parameter array and a where id = ? clause.

Implement a delete by id operation using JdbcTemplate's update method, returning the number of rows affected and confirming deletion in the H2 database.

Implement insert and update operations in Spring JDBC, using a person object, parameterized queries, and birth date timestamp, then run and verify changes in the database.

Create a custom Spring JDBC RowMapper by implementing RowMapper for the Person class, mapping id, name, location, and birth date from a timestamp column, enabling reusable mapping across DAOs.

Map entities to tables with JPA, define relationships such as a person to addresses, and understand Hibernate as the popular JPA implementation enabling ORM.

Define a person entity using JPA and Hibernate, mapping the class to the person table, configuring id generation with @Id and @GeneratedValue, and providing a no-arg constructor for Hibernate.

In step 15, define a repository for the person entity, enable transactions, connect via an entity manager, and implement a findById method using JPA to fetch data from in-memory database.

Implement insert and update operations using entitymanager.merge in a JPA repository, letting Hibernate assign IDs via a sequence, and observe automatic insert and subsequent updates in the demo app.

Implement delete by id by first finding the person by id, then calling entityManager.remove to delete, and verify the deletion in the H2 console.

Implement a find all using a JPQL named query with the entity manager, defining the named query on the Person entity and returning a list of Person with getResultList.

Explore unit testing with JUnit in five steps and learn to write tests for JPA with Hibernate using the provided code examples and GitHub resources.

Learn why unit testing matters with JUnit, compare unit, system, and integration testing, and see how continuous integration helps catch bugs early through tests.

Create a Java project in Eclipse, implement a simple My Math sum method, and write a JUnit 5 test with assertions to confirm a green bar.

Expand and refine unit tests by duplicating tests for new inputs, validating that an empty array yields zero, and improving test naming and refactoring for clarity in continuous integration.

Explore the breadth of JUnit assertion methods, including assertEquals for booleans, numbers, and arrays, using messages for failures and understanding test outcomes.

Master key JUnit annotations like before each, after each, before all, and after all, and learn setup, cleanup, and test execution order concepts, including that test order may vary.

Explore entities and annotations, relationships, and inheritance in depth, and master the entity manager, persistence context, and diverse querying options with JPA, native queries, and Criteria API.

Create a Maven Java project with Spring Boot, include Web, JPA, and H2 dependencies, import the zip into Eclipse, and run a Spring Boot context to verify the application starts.

Create a simple JPA entity named course with a primary key id generated value, a name field, getters, a protected no-arg constructor, and prepare for repository access.

Learn to manage course data with a JPA repository and an entity manager, implement find by id, and run a Spring Boot app to fetch the course.

Enable the H2 console and Hibernate statistics, turn on show sql and parameter logging, and format queries to observe schema creation and data population with Spring Boot.

Create a unit test for the course repository findById method, verify the returned course name, and understand running a spring boot test with an in-memory H2 database.

Learn to implement a delete by id method for a course using an entity manager, with find by id and transactional safeguards to ensure safe removal.

Write a unit test for the delete by id method, deleting the row with id 10002 and verifying it no longer exists by asserting null on find by id. Use a dirty context annotation to reset data after the test so other tests remain unaffected.

Implement a save method in Spring Boot with Hibernate JPA that inserts when id is null and updates with merge when id is present, using entity manager persist and merge.

Learn to write unit tests for the save method in a Spring Boot JPA context, updating a course entity and validating changes via repository save and database queries.

Review the course's entity and repository, covering CRUD operations, find by id, save for insert/update, and delete by id, with unit tests and a dirty context annotation.

Explore how the entity manager tracks changes within a transaction, as it persists inserts and updates automatically when you modify a course, without explicit save calls.

Explore how the entity manager tracks changes within a transaction, using persist, merge, flush, detach, and clear to control when updates are written to the database.

Explore the entity manager refresh method, which reloads course one from the database, discarding in-memory changes after a flush, while updates to course two persist.

Review the entity manager as a gateway to the persistence context. Master how merge, persist, remove, flush, refresh, and detach manage entities during a transaction.

Master JPQL basics by writing queries against entities, using an entity manager and typed queries, with where conditions and like percent patterns.

Map a course entity to the course table using the @Table annotation, showing how to handle differing entity and table names and the impact on generated queries.

Use the @Column annotation to map a field to a column named full name, enforce non-null constraints, and control insertable and updatable behavior along with options like length and unique.

Learn how to automatically manage created and updated timestamps with Hibernate and JPA using @CreationTimestamp and @UpdateTimestamp on LocalDateTime for inserts and updates.

Learn to define and reuse queries with JPA and Hibernate annotations by using @NamedQuery for single queries and @NamedQueries for multiples, then apply in code and tests.

Master native queries in JPA with the entity manager, mapping results to entities and using positional or named parameters; apply for database specific features and mass updates.

Develop consistency by following a concrete two week learning plan, study a few hours daily, and keep the plan visible to boost memory over the long run.

Explore entities such as course, student, passport, and review, and learn how to map relationships, including many-to-many between courses and students, one-to-one between student and passport, and many-to-one for reviews.

Define student, passport, and review entities, set up sample data, adjust fields and naming conventions, and prep for relationship mappings in a Hibernate and JPA starter project.

Define a 1 to 1 relationship between student and passport using JPA. Choose which side owns the relationship (student or passport) and implement a foreign key to connect the tables.

Persist the passport first, then create and save the student to establish a one-to-one relationship where the student owns the passport, using the entity manager and a student repository.

Retrieve a student and their passport in a unit test using a one-to-one mapping, demonstrating eager fetch and the automatic join of passport details.

Explore a one-to-one mapping with lazy fetch in Hibernate, showing how to retrieve only the student while delaying passport data and managing session and transaction scope to avoid initialization exception.

Explore how transaction boundaries, the persistence context, and the entity manager coordinate multiple database operations, ensuring all succeed or none, and clarify the role of Hibernate sessions in JPA.

Learn bidirectional one-to-one mapping between student and passport in a Spring Boot JPA setup, and designate the owning side with mappedBy to enable reverse navigation.

Explore bidirectional one-to-one mappings between student and passport in Hibernate and JPA, highlighting the owning side and mapped by. Navigate from passport to student and back to validate the relationship.

Hibernate defers inserts and updates until the end of a transaction, tracking changes in the persistence context. Use flush to push changes early, and a failure triggers a rollback.

Discover when to apply @Transactional in unit tests to ensure database changes run within a transaction, especially when using the entity manager directly instead of repository methods.

Examine whether read-only methods require transactions, compare entity manager finds with relationship-driven lazy loading, and learn why @Transactional is needed for querying related data such as user and comments.

Explain why @DirtiesContext is essential in unit tests. Show how updating course data via data.sql can affect subsequent tests and how rollback restores the initial database state.

Explore many-to-one relationships by linking reviews to courses with a course_id foreign key, explaining one-to-many mappings and the early design decisions before mapping in entities.

Explain a one-to-many mapping from course to reviews and a many-to-one from review to course, using mapped by and add/remove review methods with a foreign key course_id.

retrieve a course by id 10,003, create and attach two reviews, set the course on each review, and persist them to demonstrate many-to-one relationship in spring boot in 100 steps.

Generalize the add reviews method to accept a course id and a list of reviews, replacing hardcoded data and enabling a many-to-one mapping for a specific course.

Wraps up many-to-one mapping by exploring lazy and eager fetching for course and review, showing default behavior and how transactional persistence context affects retrieval.

Explore the many-to-many relationship between courses and students, and design a join table with course_id and student_id as foreign keys to link records in both tables.

Implement a many-to-many relationship between court and student by annotating entities and adding student and course collections, revealing a join table court_students and guiding future fixes.

Learn how to fix the two-join-table problem in a many-to-many relationship by designating an owning side and using mapped by to create a single student_courses join table.

Customize the many-to-many mapping between student and course by using @JoinTable on the owning side, naming the join table student_course with student_id and course_id.

Insert data into the student_course join table and perform a three-table join to display which students belong to each course, preparing for JPA-based retrieval of relationships.

Retrieve a student and their courses using JPA many-to-many mappings, exploring lazy and eager fetch options, entity manager usage, and join queries in a Spring Boot Hibernate context.

Persist a new student and a new course, establish their many-to-many relationship in JPA using the owning side, and verify the inserts in the database.

Explore how JPA maps 1-to-1, 1-to-many, and many-to-many relationships, including owning sides, join tables, and fetch types, with practical guidance on designing and querying related entities.

Reframe failures as learning opportunities by analyzing what went wrong. Seek input from mentors or peers, keep a failure journal, and embrace hands-on learning as a path to success.

Explore inheritance hierarchies and mappings in Hibernate and JPA with Spring Boot, using employee types and strategies—single table, table per class, joined, mapped superclass—to assess insert and retrieval efficiency.

Define a JPA inheritance hierarchy by creating an abstract employee entity with id and name, extended by full-time and part-time employees with salary and hourly wage, then add a repository.

Create and use an employee repository to insert employees with entity manager persist and retrieve all employees via a query, setting up for JPA inheritance mappings.

Explore the single table inheritance strategy in JPA, mapping part-time and full-time employees to a single employee table with a discriminator column. Compare performance benefits with data integrity risks.

Explore the table per class inheritance strategy in JPA, where each concrete subclass has its own table, with common columns repeated and data retrieved by union.

Study the joined inheritance strategy, where the superclass and each subclass map to three tables joined to instantiate subclass details, with potential performance costs.

Explore mapped superclass as an inheritance option in JPA, noting that it is not an entity, requires separate tables for subclasses, and mandates individual queries for full-time and part-time employees.

Navigate JPA inheritance mappings by weighing single table, table per class, joined, and mapped superclass approaches, balancing data integrity and performance to choose the right option.

Write jpql queries that identify courses without students by leveraging the course and student relationship, using the data in data.sql and the h2 console to verify results.

Write jpql queries to find courses with at least two students. Order results by the number of students using size of C.students, in descending order.

Learn to write jpql queries using like to find students whose passport numbers match a pattern, and explore utility string functions and basic sql concepts like between and joins.

Explore JPQL joins in Hibernate: inner joins, left joins, and cross joins between course and student, with examples showing results, including courses without students and cross products.