[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":93,"_73":94,"_35":95},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":62,"_63":64,"_65":66,"_67":68,"_69":70,"_71":72},"id",122,"title","JPA, Jackson, and Spring Integration","slug","java-collections-part-26-jpa-jackson-spring","excerpt","Navigate enterprise framework complexities: JPA collection mappings, LazyInitializationException prevention, Jackson serialization, and Spring injection patterns.","# Java Collections Compendium Part 26: Collections in JPA, Jackson & Spring\n\nNavigate the complex world of collections in enterprise Java frameworks. Master JPA/Hibernate collection mappings, Jackson serialization pitfalls, and Spring-specific collection patterns to avoid the infamous LazyInitializationException and other production nightmares.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| **Topic** | JPA PersistentBag/Set, Jackson @JsonCreator, Spring @Autowired collections |\n| **Complexity** | Advanced |\n| **Prerequisites** | Part 1 (Collection Architecture), JPA/Hibernate basics, Spring basics |\n| **Time to Master** | 4-5 hours |\n| **Interview Frequency** | Very High (enterprise Java) |\n\n## 🎯 What You'll Learn\n\nAfter completing this article, you will be able to:\n\n1. Choose the right JPA collection mapping for your use case\n2. Avoid LazyInitializationException with proper fetching strategies\n3. Serialize immutable collections correctly with Jackson\n4. Use Spring's collection injection patterns effectively\n5. Handle the N+1 problem in collection relationships\n\n---\n\n## Production Story: The Lazy Sunday Crash\n\n### The Incident\n\nOur REST API worked fine in testing but crashed in production every Sunday morning when the weekly report job ran:\n\n```java\n// ReportService.java - The problematic code\n@Service\npublic class ReportService {\n\n @Autowired\n private OrderRepository orderRepository;\n\n public WeeklyReport generateReport() {\n List orders = orderRepository.findByCreatedAfter(oneWeekAgo());\n\n // Process orders - CRASH!\n return orders.stream()\n .map(order -> {\n // Access lazy-loaded items\n int itemCount = order.getItems().size(); // LazyInitializationException!\n return new OrderSummary(order.getId(), itemCount);\n })\n .collect(toReport());\n }\n}\n\n// Order.java - JPA Entity\n@Entity\npublic class Order {\n @Id private Long id;\n\n @OneToMany(mappedBy = \"order\") // Default: LAZY loading\n private List items;\n\n // getters...\n}\n```\n\n### The Problem\n\n```text\nLazyInitializationException: could not initialize proxy - no Session\n\nTimeline:\n├─ Transaction starts\n├─ orderRepository.findByCreatedAfter() executes\n├─ Hibernate loads Order entities (without items - LAZY!)\n├─ Transaction commits, Hibernate Session closes\n├─ stream.map() starts processing\n├─ order.getItems().size() called\n├─ Hibernate tries to load items... but Session is gone!\n├─ LazyInitializationException!\n\nWhy it worked in tests:\n├─ @DataJpaTest keeps Session open during test\n├─ Integration tests with @Transactional keep Session open\n└─ Production: No spanning transaction, Session closes after query\n\nBusiness Impact:\n├─ Weekly reports not generated\n├─ Management dashboard empty\n├─ Manual data export required\n└─ 4 hours to diagnose and fix\n```\n\n### The Solution\n\n```java\n// Option 1: Fetch eagerly in query (BEST for this use case)\n@Repository\npublic interface OrderRepository extends JpaRepository {\n\n @Query(\"SELECT o FROM Order o JOIN FETCH o.items WHERE o.createdAt > :after\")\n List findByCreatedAfterWithItems(@Param(\"after\") LocalDateTime after);\n}\n\n// Option 2: Use @EntityGraph\n@Repository\npublic interface OrderRepository extends JpaRepository {\n\n @EntityGraph(attributePaths = {\"items\"})\n List findByCreatedAtAfter(LocalDateTime after);\n}\n\n// Option 3: Use DTO projection (most efficient)\n@Query(\"SELECT new com.example.OrderSummary(o.id, SIZE(o.items)) \" +\n \"FROM Order o WHERE o.createdAt > :after\")\nList findOrderSummariesAfter(@Param(\"after\") LocalDateTime after);\n\n// ReportService.java - Fixed version\n@Service\npublic class ReportService {\n\n public WeeklyReport generateReport() {\n // Items are pre-fetched, no lazy loading issues\n List orders = orderRepository.findByCreatedAfterWithItems(oneWeekAgo());\n\n return orders.stream()\n .map(order -> {\n int itemCount = order.getItems().size(); // Works! Already loaded\n return new OrderSummary(order.getId(), itemCount);\n })\n .collect(toReport());\n }\n}\n```\n\n---\n\n## Mental Model: JPA Collection Lifecycle\n\n```text\n┌─────────────────────────────────────────────────────────────────────┐\n│ JPA COLLECTION LIFECYCLE │\n├─────────────────────────────────────────────────────────────────────┤\n│ │\n│ ENTITY STATES & COLLECTION ACCESS │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ TRANSIENT → MANAGED → DETACHED │ │\n│ │ ↓ ↓ ↓ │ │\n│ │ Regular Proxied Detached │ │\n│ │ List/Set List/Set List/Set │ │\n│ │ ↓ ↓ ↓ │ │\n│ │ No magic Can lazy Cannot lazy │ │\n│ │ load load! │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n│ HIBERNATE COLLECTION TYPES │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ Your Code → Hibernate Replaces With │ │\n│ │ ────────────────────────────────────────────────────── │ │\n│ │ List → PersistentBag (unordered!) │ │\n│ │ Set → PersistentSet │ │\n│ │ List+@OrderColumn → PersistentList (ordered) │ │\n│ │ Map → PersistentMap │ │\n│ │ SortedSet → PersistentSortedSet │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n│ LAZY LOADING FLOW │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ order.getItems() items.size() Hibernate checks: │ │\n│ │ ↓ ↓ ↓ │ │\n│ │ Returns proxy Triggers load Session open? │ │\n│ │ (empty shell) if needed │ │ │\n│ │ ┌───┴───┐ │ │\n│ │ Yes No │ │\n│ │ ↓ ↓ │ │\n│ │ Load LazyInit │ │\n│ │ data Exception! │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## Deep Dive: JPA Collection Mappings\n\n### List vs Set: The Semantics Matter\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// LIST WITHOUT @OrderColumn = PersistentBag (DANGER!)\n// ═══════════════════════════════════════════════════════════════\n@Entity\npublic class Order {\n @OneToMany(mappedBy = \"order\", cascade = CascadeType.ALL)\n private List items = new ArrayList<>();\n // Hibernate: PersistentBag\n // NO order preserved!\n // NO duplicate detection!\n // Adding item: DELETE ALL + INSERT ALL (inefficient!)\n}\n\n// ═══════════════════════════════════════════════════════════════\n// LIST WITH @OrderColumn = PersistentList (Order preserved)\n// ═══════════════════════════════════════════════════════════════\n@Entity\npublic class Order {\n @OneToMany(mappedBy = \"order\", cascade = CascadeType.ALL)\n @OrderColumn(name = \"item_order\") // Column to store index\n private List items = new ArrayList<>();\n // Hibernate: PersistentList\n // Order IS preserved!\n // Requires extra column in DB\n // Insert in middle: Updates all subsequent indices\n}\n\n// ═══════════════════════════════════════════════════════════════\n// SET = PersistentSet (Recommended for @OneToMany)\n// ═══════════════════════════════════════════════════════════════\n@Entity\npublic class Order {\n @OneToMany(mappedBy = \"order\", cascade = CascadeType.ALL)\n private Set items = new HashSet<>();\n // Hibernate: PersistentSet\n // Uses equals/hashCode for identity\n // More efficient for add/remove\n // REQUIRES proper equals/hashCode on OrderItem!\n}\n```\n\n### Equals/HashCode for JPA Entities\n\n```java\n// ❌ WRONG: Using @Id in equals/hashCode\n@Entity\npublic class OrderItem {\n @Id @GeneratedValue\n private Long id;\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (!(o instanceof OrderItem)) return false;\n return id != null && id.equals(((OrderItem) o).id);\n }\n\n @Override\n public int hashCode() {\n return Objects.hash(id); // Changes when saved!\n }\n}\n// Problem: New item (id=null) added to Set, then saved (id=1)\n// hashCode changes! Item \"lost\" in HashSet!\n\n// ✅ CORRECT: Use business key or constant hashCode\n@Entity\npublic class OrderItem {\n @Id @GeneratedValue\n private Long id;\n\n @Column(nullable = false)\n private String sku; // Business key\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (!(o instanceof OrderItem that)) return false;\n return Objects.equals(sku, that.sku);\n }\n\n @Override\n public int hashCode() {\n return Objects.hash(sku); // Stable business key\n }\n}\n\n// Alternative: Constant hashCode (relies on equals for differentiation)\n@Override\npublic int hashCode() {\n return getClass().hashCode(); // Same for all instances\n}\n// Works but degrades HashSet to O(n) - acceptable for small collections\n```\n\n### @ElementCollection vs @OneToMany\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// @ElementCollection: For value types (no separate entity)\n// ═══════════════════════════════════════════════════════════════\n@Entity\npublic class User {\n @Id private Long id;\n\n @ElementCollection\n @CollectionTable(name = \"user_roles\", joinColumns = @JoinColumn(name = \"user_id\"))\n @Column(name = \"role\")\n private Set roles = new HashSet<>();\n\n @ElementCollection\n @CollectionTable(name = \"user_addresses\")\n private List

addresses = new ArrayList<>(); // @Embeddable\n}\n\n@Embeddable\npublic class Address {\n private String street;\n private String city;\n}\n\n// ═══════════════════════════════════════════════════════════════\n// @OneToMany: For entity relationships\n// ═══════════════════════════════════════════════════════════════\n@Entity\npublic class User {\n @Id private Long id;\n\n @OneToMany(mappedBy = \"user\", cascade = CascadeType.ALL, orphanRemoval = true)\n private Set roles = new HashSet<>();\n\n @OneToMany(mappedBy = \"user\", cascade = CascadeType.ALL)\n private List orders = new ArrayList<>();\n}\n\n// When to use which:\n// @ElementCollection:\n// - Simple values (String, Integer, Enum)\n// - Embeddable objects without identity\n// - Always fetched with parent (no lazy loading of individual elements)\n// - Update = DELETE ALL + INSERT ALL\n\n// @OneToMany:\n// - Entities with their own lifecycle\n// - Need individual lazy loading\n// - More efficient updates (individual row operations)\n```\n\n---\n\n## Deep Dive: Fetching Strategies\n\n### FetchType.LAZY vs FetchType.EAGER\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// LAZY (Default for collections) - Load on first access\n// ═══════════════════════════════════════════════════════════════\n@OneToMany(mappedBy = \"order\", fetch = FetchType.LAZY)\nprivate Set items;\n\n// SQL when loading Order:\n// SELECT o.* FROM orders o WHERE o.id = ?\n// (items NOT loaded)\n\n// SQL when accessing items:\n// SELECT i.* FROM order_items i WHERE i.order_id = ?\n// (triggered by items.size(), items.iterator(), etc.)\n\n// ═══════════════════════════════════════════════════════════════\n// EAGER - Always load with parent\n// ═══════════════════════════════════════════════════════════════\n@OneToMany(mappedBy = \"order\", fetch = FetchType.EAGER)\nprivate Set items;\n\n// SQL when loading Order:\n// SELECT o.*, i.* FROM orders o LEFT JOIN order_items i ON o.id = i.order_id\n\n// Problems with EAGER:\n// 1. Always loads even when not needed\n// 2. Multiple EAGER collections → Cartesian product (N×M rows!)\n// 3. Cannot override at query time\n// 4. Can cause massive memory usage\n\n// RECOMMENDATION: Always use LAZY, fetch eagerly in specific queries\n```\n\n### JOIN FETCH for Eager Loading\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// JPQL JOIN FETCH\n// ═══════════════════════════════════════════════════════════════\n@Query(\"SELECT o FROM Order o JOIN FETCH o.items WHERE o.id = :id\")\nOrder findByIdWithItems(@Param(\"id\") Long id);\n\n// ═══════════════════════════════════════════════════════════════\n// Multiple JOIN FETCH (careful with Cartesian product!)\n// ═══════════════════════════════════════════════════════════════\n// ❌ WRONG: Two bag fetches → MultipleBagFetchException!\n@Query(\"SELECT o FROM Order o \" +\n \"JOIN FETCH o.items \" +\n \"JOIN FETCH o.shipments\") // Error if both are List!\n\n// ✅ CORRECT: Use Set, or fetch separately\n@Entity\npublic class Order {\n @OneToMany(mappedBy = \"order\")\n private Set items; // Changed to Set\n\n @OneToMany(mappedBy = \"order\")\n private Set shipments; // Changed to Set\n}\n\n// Or fetch in separate queries:\nOrder order = orderRepository.findByIdWithItems(id);\nHibernate.initialize(order.getShipments()); // Second query\n```\n\n### @EntityGraph\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// Named EntityGraph (defined on entity)\n// ═══════════════════════════════════════════════════════════════\n@Entity\n@NamedEntityGraph(\n name = \"Order.withItems\",\n attributeNodes = @NamedAttributeNode(\"items\")\n)\n@NamedEntityGraph(\n name = \"Order.withItemsAndShipments\",\n attributeNodes = {\n @NamedAttributeNode(\"items\"),\n @NamedAttributeNode(\"shipments\")\n }\n)\npublic class Order {\n // ...\n}\n\n@Repository\npublic interface OrderRepository extends JpaRepository {\n @EntityGraph(\"Order.withItems\")\n List findByStatus(OrderStatus status);\n}\n\n// ═══════════════════════════════════════════════════════════════\n// Ad-hoc EntityGraph (defined in repository)\n// ═══════════════════════════════════════════════════════════════\n@Repository\npublic interface OrderRepository extends JpaRepository {\n\n @EntityGraph(attributePaths = {\"items\", \"customer\"})\n Optional findById(Long id);\n\n @EntityGraph(attributePaths = {\"items\", \"items.product\"}) // Nested!\n List findByCustomerId(Long customerId);\n}\n```\n\n### Batch Fetching (N+1 Solution)\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// The N+1 Problem\n// ═══════════════════════════════════════════════════════════════\nList orders = orderRepository.findAll(); // 1 query\nfor (Order order : orders) {\n order.getItems().size(); // N queries! (one per order)\n}\n// Total: 1 + N queries\n\n// ═══════════════════════════════════════════════════════════════\n// Solution 1: @BatchSize\n// ═══════════════════════════════════════════════════════════════\n@Entity\npublic class Order {\n @OneToMany(mappedBy = \"order\")\n @BatchSize(size = 25) // Load 25 orders' items at a time\n private Set items;\n}\n// Now: 1 query for orders + ceil(N/25) queries for items\n\n// Global batch size in application.properties:\n// spring.jpa.properties.hibernate.default_batch_fetch_size=25\n\n// ═══════════════════════════════════════════════════════════════\n// Solution 2: Subselect fetching\n// ═══════════════════════════════════════════════════════════════\n@OneToMany(mappedBy = \"order\")\n@Fetch(FetchMode.SUBSELECT)\nprivate Set items;\n// Loads ALL items for ALL orders in one query using subselect\n// SELECT * FROM items WHERE order_id IN (SELECT id FROM orders WHERE ...)\n```\n\n---\n\n## Deep Dive: Jackson and Collections\n\n### Default Serialization\n\n```java\n// Jackson serializes collections normally\n@Data\npublic class OrderDTO {\n private Long id;\n private List items; // Serializes as JSON array\n}\n\n// JSON output:\n// {\"id\": 1, \"items\": [{\"name\": \"Widget\"}, {\"name\": \"Gadget\"}]}\n```\n\n### Immutable Collections Problem\n\n```java\n// ❌ PROBLEM: Jackson can't deserialize to List.of()\n@Data\npublic class OrderDTO {\n private Long id;\n private List items = List.of(); // Immutable!\n}\n\n// Deserialization fails!\n// Cannot deserialize: no suitable constructor/factory method\n\n// ✅ SOLUTION 1: Use @JsonCreator\npublic class OrderDTO {\n private final Long id;\n private final List items;\n\n @JsonCreator\n public OrderDTO(\n @JsonProperty(\"id\") Long id,\n @JsonProperty(\"items\") List items\n ) {\n this.id = id;\n this.items = items != null ? List.copyOf(items) : List.of();\n }\n\n public Long getId() { return id; }\n public List getItems() { return items; }\n}\n\n// ✅ SOLUTION 2: Record with custom deserialization\npublic record OrderDTO(Long id, List items) {\n public OrderDTO {\n items = items != null ? List.copyOf(items) : List.of();\n }\n}\n// Jackson 2.12+ handles records automatically\n\n// ✅ SOLUTION 3: Custom deserializer\n@JsonDeserialize(using = ImmutableListDeserializer.class)\nprivate List items;\n```\n\n### Handling Null vs Empty Collections\n\n```java\n// Control serialization of empty/null collections\npublic class OrderDTO {\n private Long id;\n\n @JsonInclude(JsonInclude.Include.NON_EMPTY) // Skip if empty\n private List items;\n\n @JsonInclude(JsonInclude.Include.NON_NULL) // Skip if null\n private Set tags;\n}\n\n// Or globally:\n@Configuration\npublic class JacksonConfig {\n @Bean\n public ObjectMapper objectMapper() {\n return new ObjectMapper()\n .setSerializationInclusion(JsonInclude.Include.NON_NULL);\n }\n}\n\n// Deserialization: Handle missing fields\npublic class OrderDTO {\n private Long id;\n private List items = new ArrayList<>(); // Default to empty\n}\n```\n\n### Polymorphic Collections\n\n```java\n// Serialize collection of different types\n@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = \"type\")\n@JsonSubTypes({\n @JsonSubTypes.Type(value = EmailNotification.class, name = \"email\"),\n @JsonSubTypes.Type(value = SmsNotification.class, name = \"sms\")\n})\npublic abstract class Notification {\n private String recipient;\n}\n\npublic class NotificationBatch {\n private List notifications; // Mixed types OK!\n}\n\n// JSON:\n// {\n// \"notifications\": [\n// {\"type\": \"email\", \"recipient\": \"user@example.com\", \"subject\": \"Hello\"},\n// {\"type\": \"sms\", \"recipient\": \"+1234567890\", \"message\": \"Hi\"}\n// ]\n// }\n```\n\n---\n\n## Deep Dive: Spring and Collections\n\n### @Autowired Collection Injection\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// Inject ALL beans of a type\n// ═══════════════════════════════════════════════════════════════\n@Service\npublic class NotificationService {\n\n // Injects ALL NotificationSender beans\n @Autowired\n private List senders;\n\n // With ordering\n @Autowired\n private List orderedSenders;\n // Beans with @Order(1), @Order(2) injected in order\n\n // As Set (unique beans)\n @Autowired\n private Set uniqueSenders;\n\n // As Map (bean name → bean)\n @Autowired\n private Map sendersByName;\n}\n\n// Define beans:\n@Component(\"emailSender\")\n@Order(1)\npublic class EmailNotificationSender implements NotificationSender { }\n\n@Component(\"smsSender\")\n@Order(2)\npublic class SmsNotificationSender implements NotificationSender { }\n\n// ═══════════════════════════════════════════════════════════════\n// Optional: May be empty if no beans found\n// ═══════════════════════════════════════════════════════════════\n@Autowired(required = false)\nprivate List optionalSenders; // Empty if none\n// Default: Exception if no beans found\n```\n\n### @Value with Collections\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// Inject from properties\n// ═══════════════════════════════════════════════════════════════\n// application.yml:\n// app:\n// allowed-origins:\n// - http://localhost:3000\n// - https://example.com\n// admin-emails: admin@example.com,support@example.com\n\n@Service\npublic class ConfigService {\n\n // From list property\n @Value(\"${app.allowed-origins}\")\n private List allowedOrigins;\n\n // From comma-separated string\n @Value(\"#{'${app.admin-emails}'.split(',')}\")\n private List adminEmails;\n\n // With default\n @Value(\"${app.allowed-origins:http://localhost:8080}\")\n private List originsWithDefault;\n\n // From array property\n @Value(\"${app.feature-flags:}\")\n private String[] featureFlags;\n}\n```\n\n### @ConfigurationProperties with Collections\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// Type-safe configuration binding\n// ═══════════════════════════════════════════════════════════════\n// application.yml:\n// app:\n// security:\n// allowed-origins:\n// - http://localhost:3000\n// - https://example.com\n// cors-headers:\n// Access-Control-Allow-Methods: GET,POST,PUT,DELETE\n// Access-Control-Max-Age: 3600\n\n@Configuration\n@ConfigurationProperties(prefix = \"app.security\")\npublic class SecurityConfig {\n private List allowedOrigins = new ArrayList<>();\n private Map corsHeaders = new HashMap<>();\n\n // Getters and setters required for binding!\n public List getAllowedOrigins() { return allowedOrigins; }\n public void setAllowedOrigins(List origins) {\n this.allowedOrigins = origins;\n }\n\n public Map getCorsHeaders() { return corsHeaders; }\n public void setCorsHeaders(Map headers) {\n this.corsHeaders = headers;\n }\n}\n\n// ═══════════════════════════════════════════════════════════════\n// Immutable configuration (Java 16+ record)\n// ═══════════════════════════════════════════════════════════════\n@ConfigurationProperties(prefix = \"app.security\")\npublic record SecurityConfig(\n List allowedOrigins,\n Map corsHeaders\n) {\n public SecurityConfig {\n allowedOrigins = allowedOrigins != null ? List.copyOf(allowedOrigins) : List.of();\n corsHeaders = corsHeaders != null ? Map.copyOf(corsHeaders) : Map.of();\n }\n}\n```\n\n### Spring Data Collection Queries\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// Query methods returning collections\n// ═══════════════════════════════════════════════════════════════\n@Repository\npublic interface UserRepository extends JpaRepository {\n\n // Returns List (default)\n List findByStatus(UserStatus status);\n\n // Returns Set\n Set findByRoleIn(Set roles);\n\n // Returns Stream (must be in transaction!)\n @Query(\"SELECT u FROM User u WHERE u.active = true\")\n Stream findAllActiveAsStream();\n\n // Slice (for pagination without count)\n Slice findByDepartment(String dept, Pageable pageable);\n\n // Page (includes total count)\n Page findByCreatedAtAfter(LocalDateTime date, Pageable pageable);\n}\n\n// Using Stream (must be in transaction)\n@Transactional(readOnly = true)\npublic void processUsers() {\n try (Stream users = userRepository.findAllActiveAsStream()) {\n users.filter(u -> u.needsNotification())\n .forEach(this::notify);\n } // Stream must be closed!\n}\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Accessing Lazy Collection Outside Transaction\n\n```java\n// ❌ WRONG: Transaction already closed\n@GetMapping(\"/orders/{id}\")\npublic OrderDTO getOrder(@PathVariable Long id) {\n Order order = orderRepository.findById(id).orElseThrow();\n // Transaction ends here (method not @Transactional)\n\n return new OrderDTO(\n order.getId(),\n order.getItems().size() // LazyInitializationException!\n );\n}\n\n// ✅ CORRECT Option 1: Use DTO projection\n@GetMapping(\"/orders/{id}\")\npublic OrderDTO getOrder(@PathVariable Long id) {\n return orderRepository.findOrderDTOById(id); // Query returns DTO directly\n}\n\n// ✅ CORRECT Option 2: Fetch in query\n@GetMapping(\"/orders/{id}\")\npublic OrderDTO getOrder(@PathVariable Long id) {\n Order order = orderRepository.findByIdWithItems(id); // JOIN FETCH\n return mapper.toDTO(order);\n}\n\n// ✅ CORRECT Option 3: @Transactional (careful with performance)\n@GetMapping(\"/orders/{id}\")\n@Transactional(readOnly = true)\npublic OrderDTO getOrder(@PathVariable Long id) {\n Order order = orderRepository.findById(id).orElseThrow();\n return mapper.toDTO(order); // Session open, lazy load works\n}\n```\n\n### Mistake 2: Using List Without @OrderColumn\n\n```java\n// ❌ WRONG: List becomes unordered Bag\n@OneToMany(mappedBy = \"order\")\nprivate List items; // Actually a Bag - no order!\n\n// Add item: DELETE all, INSERT all (inefficient!)\n\n// ✅ CORRECT Option 1: Add @OrderColumn\n@OneToMany(mappedBy = \"order\")\n@OrderColumn(name = \"item_index\")\nprivate List items; // Now ordered\n\n// ✅ CORRECT Option 2: Use Set (usually better)\n@OneToMany(mappedBy = \"order\")\nprivate Set items; // More efficient operations\n```\n\n### Mistake 3: Multiple Eager Collections\n\n```java\n// ❌ WRONG: Cartesian product disaster\n@Entity\npublic class Order {\n @OneToMany(fetch = FetchType.EAGER)\n private List items; // 10 items\n\n @OneToMany(fetch = FetchType.EAGER)\n private List shipments; // 5 shipments\n}\n// Query returns 10 × 5 = 50 rows for ONE order!\n// MultipleBagFetchException with Lists!\n\n// ✅ CORRECT: Use LAZY, fetch when needed\n@Entity\npublic class Order {\n @OneToMany(fetch = FetchType.LAZY)\n private Set items;\n\n @OneToMany(fetch = FetchType.LAZY)\n private Set shipments;\n}\n```\n\n### Mistake 4: Ignoring N+1 in Tests\n\n```java\n// ❌ WRONG: Test doesn't catch N+1\n@Test\nvoid testGetOrders() {\n List orders = orderService.getAllOrders(); // 1 query\n assertThat(orders).hasSize(5);\n // Never accesses items, N+1 not detected!\n}\n\n// ✅ CORRECT: Test includes collection access\n@Test\nvoid testGetOrders() {\n List orders = orderService.getAllOrders();\n\n // Force lazy loading to detect N+1\n orders.forEach(o -> o.getItems().size());\n\n // Assert query count\n assertThat(statistics.getQueryExecutionCount()).isEqualTo(1); // Not 6!\n}\n```\n\n### Mistake 5: Jackson Serializing Hibernate Proxies\n\n```java\n// ❌ WRONG: Jackson tries to serialize Hibernate proxy\n@GetMapping(\"/users/{id}\")\npublic User getUser(@PathVariable Long id) {\n return userRepository.findById(id).orElseThrow();\n // If User has lazy associations, Jackson may:\n // 1. Trigger lazy load (if session open) - N+1!\n // 2. Fail with LazyInitializationException\n // 3. Serialize proxy metadata (weird JSON)\n}\n\n// ✅ CORRECT: Use DTOs\n@GetMapping(\"/users/{id}\")\npublic UserDTO getUser(@PathVariable Long id) {\n User user = userRepository.findByIdWithRoles(id);\n return userMapper.toDTO(user); // Clean DTO, no proxies\n}\n\n// ✅ ALTERNATIVE: Configure Jackson for Hibernate\n@Bean\npublic ObjectMapper objectMapper() {\n return new ObjectMapper()\n .registerModule(new Hibernate5JakartaModule()\n .configure(Feature.FORCE_LAZY_LOADING, false)\n .configure(Feature.SERIALIZE_IDENTIFIER_FOR_LAZY_NOT_LOADED_OBJECTS, true)\n );\n}\n```\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Optimal JPA Mapping\n\nDesign entity mappings for an e-commerce order system:\n\n```java\n// Requirements:\n// - Order has many OrderItems (ordered by position)\n// - Order has many Tags (simple strings, no order)\n// - Order has many StatusChanges (audit history)\n// - Must avoid N+1 when listing orders with items\n```\n\n**✅ Solution:**\n\n```java\n@Entity\n@Table(name = \"orders\")\npublic class Order {\n @Id @GeneratedValue(strategy = GenerationType.IDENTITY)\n private Long id;\n\n // OrderItems: Ordered list, frequent access\n @OneToMany(mappedBy = \"order\", cascade = CascadeType.ALL, orphanRemoval = true)\n @OrderColumn(name = \"position\") // Preserve order!\n @BatchSize(size = 25) // Batch load for N+1\n private List items = new ArrayList<>();\n\n // Tags: Simple values, no order needed\n @ElementCollection\n @CollectionTable(name = \"order_tags\", joinColumns = @JoinColumn(name = \"order_id\"))\n @Column(name = \"tag\")\n private Set tags = new HashSet<>();\n\n // Status history: Audit, rarely accessed\n @OneToMany(mappedBy = \"order\", cascade = CascadeType.ALL)\n @OrderBy(\"timestamp DESC\")\n @BatchSize(size = 50)\n private List statusHistory = new ArrayList<>();\n\n // Helper methods\n public void addItem(OrderItem item) {\n items.add(item);\n item.setOrder(this);\n }\n\n public void removeItem(OrderItem item) {\n items.remove(item);\n item.setOrder(null);\n }\n}\n\n@Entity\n@Table(name = \"order_items\")\npublic class OrderItem {\n @Id @GeneratedValue(strategy = GenerationType.IDENTITY)\n private Long id;\n\n @ManyToOne(fetch = FetchType.LAZY)\n @JoinColumn(name = \"order_id\")\n private Order order;\n\n @Column(nullable = false)\n private String sku;\n\n private int quantity;\n\n // equals/hashCode using sku (business key)\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (!(o instanceof OrderItem that)) return false;\n return Objects.equals(sku, that.sku);\n }\n\n @Override\n public int hashCode() {\n return Objects.hash(sku);\n }\n}\n\n// Repository with fetch strategy\n@Repository\npublic interface OrderRepository extends JpaRepository {\n\n @EntityGraph(attributePaths = {\"items\"})\n List findByStatus(OrderStatus status);\n\n @Query(\"SELECT o FROM Order o JOIN FETCH o.items WHERE o.id = :id\")\n Optional findByIdWithItems(@Param(\"id\") Long id);\n}\n```\n\n### Exercise 2: Safe Jackson DTO\n\nCreate an immutable DTO that serializes correctly:\n\n```java\n// Requirements:\n// - Immutable (all fields final)\n// - Collections are immutable copies\n// - Works with Jackson serialization/deserialization\n// - Null-safe (handles missing fields)\n```\n\n**✅ Solution:**\n\n```java\npublic record OrderDTO(\n Long id,\n String customerEmail,\n List items,\n Set tags,\n Map metadata\n) {\n // Compact constructor for validation and defensive copying\n public OrderDTO {\n Objects.requireNonNull(id, \"id is required\");\n Objects.requireNonNull(customerEmail, \"customerEmail is required\");\n items = items != null ? List.copyOf(items) : List.of();\n tags = tags != null ? Set.copyOf(tags) : Set.of();\n metadata = metadata != null ? Map.copyOf(metadata) : Map.of();\n }\n\n // Static factory for creating from entity\n public static OrderDTO fromEntity(Order order) {\n return new OrderDTO(\n order.getId(),\n order.getCustomer().getEmail(),\n order.getItems().stream()\n .map(ItemDTO::fromEntity)\n .toList(),\n Set.copyOf(order.getTags()),\n Map.copyOf(order.getMetadata())\n );\n }\n}\n\npublic record ItemDTO(\n String sku,\n String name,\n int quantity,\n BigDecimal price\n) {\n public ItemDTO {\n Objects.requireNonNull(sku, \"sku is required\");\n Objects.requireNonNull(name, \"name is required\");\n if (quantity <= 0) throw new IllegalArgumentException(\"quantity must be positive\");\n Objects.requireNonNull(price, \"price is required\");\n }\n\n public static ItemDTO fromEntity(OrderItem item) {\n return new ItemDTO(\n item.getSku(),\n item.getProduct().getName(),\n item.getQuantity(),\n item.getPrice()\n );\n }\n}\n\n// Jackson config for records (Spring Boot 2.5+)\n// Works out of the box! Jackson 2.12+ has record support\n```\n\n### Exercise 3: Spring Collection Processor\n\nCreate a service that processes all beans of a type:\n\n```java\n// Requirements:\n// - Collect all Validator beans\n// - Execute in order (@Order annotation)\n// - Support conditional validation (skip if not applicable)\n// - Aggregate all validation errors\n```\n\n**✅ Solution:**\n\n```java\npublic interface Validator {\n boolean supports(Class clazz);\n List validate(T object);\n}\n\n@Service\npublic class ValidationService {\n\n private final List> validators;\n\n @Autowired\n public ValidationService(List> validators) {\n // Spring injects all Validator beans, sorted by @Order\n this.validators = validators;\n }\n\n @SuppressWarnings(\"unchecked\")\n public ValidationResult validate(T object) {\n List errors = validators.stream()\n .filter(v -> v.supports(object.getClass()))\n .map(v -> ((Validator) v).validate(object))\n .flatMap(List::stream)\n .collect(Collectors.toList());\n\n return new ValidationResult(errors.isEmpty(), List.copyOf(errors));\n }\n\n public record ValidationResult(boolean valid, List errors) {}\n}\n\n// Example validators\n@Component\n@Order(1)\npublic class NotNullValidator implements Validator