<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>
<!-- For Production -->
<!-- <dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
</dependency> -->

import jakarta.persistence.*;
import lombok.Data;

@Entity
@Table(name = "products") // Maps this class to the "products" table
@Data // Lombok generates getters, setters, toString, equals, hashCode
public class Product {

    @Id // Marks this field as the primary key
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    // IDENTITY = let the database auto-increment the ID.
    // Use SEQUENCE for PostgreSQL in production -- it allows batch inserts
    // (IDENTITY forces single-row inserts because it needs the DB-generated ID back).
    private Long id;

    @Column(nullable = false) // Adds NOT NULL constraint at the DDL level
    private String name;

    private Double price;

    private boolean inStock;
}

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;

public interface ProductRepository extends JpaRepository<Product, Long> {
    
    // Magic Method: Spring generates the SQL automatically!
    // SELECT * FROM products WHERE in_stock = ?
    List<Product> findByInStock(boolean inStock);

    // SELECT * FROM products WHERE price < ?
    List<Product> findByPriceLessThan(Double price);
}

@Service
@RequiredArgsConstructor // Lombok generates a constructor for all 'final' fields
public class ProductService {

    private final ProductRepository productRepository;

    @Transactional // Wraps this method in a database transaction (BEGIN...COMMIT/ROLLBACK)
    public Product updatePrice(Long id, Double newPrice) {
        Product product = productRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("Product not found"));
        
        product.setPrice(newPrice);
        // No need to call save()!
        // Hibernate's "Dirty Checking" mechanism tracks every field change on managed entities.
        // At transaction commit, it compares the current state to a snapshot taken at load time
        // and issues an UPDATE only for changed fields.
        // This is why @Transactional matters -- without it, there is no persistence context
        // to track changes, and your setter call quietly does nothing to the database.
        return product;
    }
}

spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
spring.datasource.url=jdbc:h2:mem:testdb

// Interface based projection
public interface ProductNameOnly {
    String getName();
}

// In Repository
List<ProductNameOnly> findByNameStartingWith(String prefix);

List<Author> authors = authorRepository.findAll(); // 1 Query: SELECT * FROM authors
for (Author a : authors) {
    // Each call triggers a LAZY load: SELECT * FROM books WHERE author_id = ?
    System.out.println(a.getBooks().size()); // N Queries (One per author!)
}

// Single query: SELECT a.*, b.* FROM authors a JOIN books b ON a.id = b.author_id
@Query("SELECT a FROM Author a JOIN FETCH a.books")
List<Author> findAllWithBooks();

@Version
private Long version; // Hibernate auto-increments this on every UPDATE

// PESSIMISTIC_WRITE = SELECT ... FOR UPDATE
// The row is locked until the transaction commits or rolls back.
@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("SELECT p FROM Product p WHERE p.id = :id")
Optional<Product> findByIdLocked(Long id);

@EntityListeners(AuditingEntityListener.class)
public class Product {
    
    @CreatedDate
    private LocalDateTime createdAt;
    
    @LastModifiedDate
    private LocalDateTime updatedAt;
    
    @CreatedBy
    private String createdBy; // Needs AuditorAware implementation
}

@DataJpaTest
class ProductRepositoryTest {

    @Autowired
    private ProductRepository repo;

    @Test
    void shouldFindInStockProducts() {
        Product p = new Product("Phone", 100.0, true);
        repo.save(p);

        List<Product> found = repo.findByInStock(true);
        assertThat(found).hasSize(1);
    }
}

@Transactional(rollbackFor = Exception.class) // Rollback for ALL exceptions, not just unchecked
public void dangerousMethod() throws IOException { ... }

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Transactional(rollbackFor = Exception.class)
public @interface BusinessTransaction {}

// Usage: cleaner and team-consistent
@BusinessTransaction
public void transferFunds(Long from, Long to, BigDecimal amount) throws InsufficientFundsException { ... }

@SpringBootApplication
@EnableCaching
public class DemoApplication {}

@Service
public class ProductService {

    @Cacheable("products") // Cache the result using key = id
    public Product getProduct(Long id) {
        // Expensive DB call
        return productRepository.findById(id).orElseThrow();
    }

    @CacheEvict(value = "products", key = "#id")
    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
    }

    @CachePut(value = "products", key = "#product.id")
    public Product updateProduct(Product product) {
        return productRepository.save(product);
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

spring:
  cache:
    type: redis
  data:
    redis:
      host: localhost
      port: 6379

@Configuration
public class CacheConfig {
    @Bean
    public RedisCacheConfiguration cacheConfiguration() {
        return RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10)); // Expire after 10 min
    }
}