Spring Data & JPA

public interface OrderRepository extends JpaRepository<Order, Long> {
  List<Order> findByCustomerIdAndStatus(String customerId, OrderStatus status);
  Optional<Order> findByExternalRef(String externalRef);
}

@Entity
@Table(name = "orders", indexes = @Index(name = "idx_orders_customer", columnList = "customer_id"))
public class Order {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @Column(name = "customer_id", nullable = false, length = 64)
  private String customerId;

  @Enumerated(EnumType.STRING)
  @Column(nullable = false, length = 32)
  private OrderStatus status;

  @Column(name = "created_at", nullable = false)
  private Instant createdAt;

  protected Order() {}  // JPA requirement

  public Order(String customerId, OrderStatus status) {
    this.customerId = customerId;
    this.status = status;
    this.createdAt = Instant.now();
  }
}

@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "order_seq")
@SequenceGenerator(name = "order_seq", sequenceName = "order_id_seq", allocationSize = 50)
private Long id;

@Converter
class JsonMapConverter implements AttributeConverter<Map<String, String>, String> {
  private static final ObjectMapper MAPPER = new ObjectMapper();

  @Override
  public String convertToDatabaseColumn(Map<String, String> attribute) {
    try { return MAPPER.writeValueAsString(attribute); }
    catch (JsonProcessingException e) { throw new IllegalArgumentException(e); }
  }

  @Override
  public Map<String, String> convertToEntityAttribute(String dbData) {
    try { return MAPPER.readValue(dbData, new TypeReference<>() {}); }
    catch (JsonProcessingException e) { throw new IllegalArgumentException(e); }
  }
}

@Entity
public class Order {
  @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @OneToMany(mappedBy = "order", cascade = CascadeType.PERSIST, orphanRemoval = true)
  private List<OrderLine> lines = new ArrayList<>();

  public void addLine(OrderLine line) {
    lines.add(line);
    line.setOrder(this);
  }
}

@Entity
public class OrderLine {
  @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @ManyToOne(fetch = FetchType.LAZY, optional = false)
  @JoinColumn(name = "order_id", nullable = false)
  private Order order;
}

@Entity
public class Student {
  @ManyToMany
  @JoinTable(
      name = "student_course",
      joinColumns = @JoinColumn(name = "student_id"),
      inverseJoinColumns = @JoinColumn(name = "course_id")
  )
  private Set<Course> courses = new HashSet<>();
}

@Embeddable
public record Address(
    @Column(name = "street") String street,
    @Column(name = "city") String city,
    @Column(name = "postal_code") String postalCode
) {}

@Entity
public class Customer {
  @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @Embedded
  @AttributeOverrides({
      @AttributeOverride(name = "street", column = @Column(name = "billing_street")),
      @AttributeOverride(name = "city", column = @Column(name = "billing_city"))
  })
  private Address billingAddress;
}

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "payment_type")
public abstract class Payment { @Id @GeneratedValue Long id; }

@Entity
@DiscriminatorValue("CARD")
public class CardPayment extends Payment { private String lastFour; }

@Entity
@DiscriminatorValue("BANK")
public class BankPayment extends Payment { private String iban; }

@Query("SELECT DISTINCT o FROM Order o JOIN FETCH o.lines WHERE o.status = :status")
List<Order> findWithLinesByStatus(@Param("status") OrderStatus status);

@Entity
@NamedEntityGraph(name = "Order.withLines", attributeNodes = @NamedAttributeNode("lines"))
public class Order { /* ... */ }

@EntityGraph("Order.withLines")
List<Order> findByStatus(OrderStatus status);

@Entity
public class Order {
  @OneToMany(mappedBy = "order")
  @BatchSize(size = 25)
  private List<OrderLine> lines;
}

// Hibernate: SELECT ... WHERE order_id IN (?,?,... 25 ids) — reduces N to N/25

public interface OrderSummary {
  Long getId();
  String getCustomerId();
  int getLineCount();
}

@Query("""
    SELECT o.id AS id, o.customerId AS customerId, COUNT(l) AS lineCount
    FROM Order o LEFT JOIN o.lines l
    GROUP BY o.id, o.customerId
    """)
List<OrderSummary> findSummaries();

Page<Order> findByCustomerIdAndStatusOrderByCreatedAtDesc(
    String customerId, OrderStatus status, Pageable pageable);

List<Order> findTop10ByStatusOrderByCreatedAtDesc(OrderStatus status);

@Query("SELECT o FROM Order o WHERE o.createdAt >= :since AND o.status IN :statuses")
List<Order> findRecent(@Param("since") Instant since, @Param("statuses") Collection<OrderStatus> statuses);

@Query(value = """
    SELECT o.* FROM orders o
    WHERE o.customer_id = :customerId
    ORDER BY o.created_at DESC
    LIMIT :limit
    """, nativeQuery = true)
List<Order> findRecentNative(@Param("customerId") String customerId, @Param("limit") int limit);

@Modifying(clearAutomatically = true, flushAutomatically = true)
@Query("UPDATE Order o SET o.status = :newStatus WHERE o.id = :id")
int updateStatus(@Param("id") Long id, @Param("newStatus") OrderStatus newStatus);

@Service
public class OrderService {
  private final OrderRepository orderRepository;
  private final InventoryClient inventoryClient;

  @Transactional
  public Order placeOrder(PlaceOrderCommand cmd) {
    Order order = orderRepository.save(new Order(cmd.customerId()));
    inventoryClient.reserve(cmd.sku(), cmd.qty());  // participates in same TX if client is @Transactional
    return order;
  }

  @Transactional(readOnly = true)
  public OrderDto getOrder(long id) {
    return orderRepository.findById(id)
        .map(OrderDto::from)
        .orElseThrow(() -> new OrderNotFoundException(id));
  }
}

@Service
public class BrokenOrderService {
  public void process(long id) {
    doTransactionalWork(id);  // NO proxy — @Transactional ignored!
  }

  @Transactional
  void doTransactionalWork(long id) { /* ... */ }
}

// Fix: inject self (careful with cycles), move to another bean, or use AspectJ weaving

@Entity
@Cacheable
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Product {
  @Id private Long id;
  private String sku;
  private String name;
}

@Transactional(readOnly = true)
public Order getOrder(long id) {
  return orderRepository.findById(id).orElseThrow();  // TX ends here
}

// Controller — outside TX
order.getLines().size();  // LazyInitializationException

@Configuration
@EnableJpaAuditing(auditorAwareRef = "auditorProvider")
class JpaAuditingConfig {

  @Bean
  AuditorAware<String> auditorProvider() {
    return () -> Optional.ofNullable(SecurityContextHolder.getContext())
        .map(SecurityContext::getAuthentication)
        .filter(Authentication::isAuthenticated)
        .map(Authentication::getName);
  }
}

@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class AuditableEntity {
  @CreatedDate
  @Column(nullable = false, updatable = false)
  private Instant createdAt;

  @LastModifiedDate
  @Column(nullable = false)
  private Instant updatedAt;

  @CreatedBy
  @Column(updatable = false, length = 64)
  private String createdBy;

  @LastModifiedBy
  @Column(length = 64)
  private String updatedBy;
}

@Entity
public class Order extends AuditableEntity {
  @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
}