If you want a working backend that does CRUD without drama this guide walks through using Spring Boot with JPA and Hibernate. You will learn how to set up the project configure the datasource map entities handle transactions and expose a polite REST API that does not lie to you about HTTP status codes.

Setup and dependencies

Start a Maven or Gradle project from start.spring.io or from your favorite IDE wizard. Add these essentials

• spring-boot-starter-data-jpa for Spring Data JPA integration
• the JDBC driver for your chosen database like H2 Postgres or MySQL
• optional Flyway or Liquibase for schema migrations

Example application properties for a quick in memory test

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.hibernate.ddl-auto=update

Entity mapping basics

Use @Entity on your domain classes and mark the primary key with @Id and @GeneratedValue. Map columns with @Column when you need custom names or constraints. Relationships matter a lot so think before you type. A lazy @ManyToOne is the polite default. An eager collection is a trap that leads to N plus one horror stories.

Small example

@Entity
public class Book {
  @Id
  @GeneratedValue
  private Long id;

  private String title;

  @ManyToOne(fetch = FetchType.LAZY)
  private Author author;
}

Repositories and Spring Data JPA

Extend JpaRepository or CrudRepository so Spring Data JPA generates the boring query code for you. Want custom queries fine use @Query or a query method name. Keep repositories focused on persistence not revenge fantasies.

Service layer and transaction management

Put transactional business logic in @Service classes and annotate transactional boundaries with @Transactional. Read only transactions can help performance and make your intent clear. Do not call repository methods from controllers directly unless your controller enjoys inconsistency and despair.

• Use @Transactional on methods that modify data
• Mark read only operations with @Transactional(readOnly = true) when appropriate
• Avoid long running transactions that lock rows while you send emails

REST controllers for CRUD

Create controllers with mapping methods for create read update and delete. Return ResponseEntity to control HTTP status codes and payloads. Validate input and return 400 for user mistakes not 500 unless you enjoy debugging at 3 AM.

Devops friendly tips and SQL logging

Enable SQL logging during development with spring.jpa.show-sql true and format SQL for readability. Use Flyway or Liquibase for schema migrations so your database does not mutate like a gremlin after a deploy. Monitor logs to catch N plus one queries early and use fetch joins or entity graphs to fix them.

Final checklist

1. Project created with correct dependencies
2. Datasource and JPA properties configured
3. Entities mapped with attention to relationships
4. Repositories extend JpaRepository for CRUD
5. Service layer handles transactions
6. REST controllers expose endpoints with proper status codes
7. SQL logging and migrations enabled for stable development

Follow these steps and you will have a maintainable Spring Boot app using JPA and Hibernate that handles CRUD without melodrama. If something breaks the logs will tell the story and you will be the hero who reads them.