Beginner

package com.example.demo.entity;              // => JPA entity package location
 
import jakarta.persistence.*;                 // => Jakarta Persistence API (JPA 3.0+)
 
@Entity                                       // => Marks class as JPA entity (database table mapping)
                                              // => Hibernate creates table schema from this class
@Table(name = "users")                        // => Explicitly maps to "users" table
                                              // => Without @Table, defaults to class name "User"
public class User {                           // => JPA-managed entity class
    @Id                                       // => Primary key field
    @GeneratedValue(strategy = GenerationType.IDENTITY)  // => Auto-increment strategy
                                              // => Database generates ID on INSERT
    private Long id;                          // => Primary key type (Long supports null for new entities)
 
    @Column(nullable = false)                 // => NOT NULL constraint in database
                                              // => JPA validates before persisting
    private String name;                      // => Required field (cannot be null)
 
    private String email;                     // => Optional field (nullable=true by default)
                                              // => Maps to VARCHAR(255) in database
 
    public User() {}                          // => Default constructor REQUIRED by JPA
                                              // => JPA uses reflection to instantiate entities
 
    public User(String name, String email) {  // => Convenience constructor for application code
        this.name = name;                     // => Sets name field
        this.email = email;                   // => Sets email field
    }                                         // => Note: id remains null (assigned on persist)
 
    public Long getId() { return id; }        // => Getter for primary key
    public void setId(Long id) {              // => Setter for primary key
        this.id = id;                         // => Usually only set by JPA, not application code
    }                                         // => id normally set only by JPA persistence provider
    public String getName() { return name; }  // => Getter for name field
    public void setName(String name) {        // => Setter for name field
        this.name = name;                     // => Updates name in managed entity
    }                                         // => Triggers dirty checking if entity is MANAGED
    public String getEmail() { return email; }  // => Getter for email field
    public void setEmail(String email) {      // => Setter for email field
        this.email = email;                   // => Updates email in managed entity
    }                                         // => JPA detects change; UPDATE on flush/commit
}
 
 

package com.example.demo.repository;         // => Repository layer package
 
import com.example.demo.entity.User;          // => Entity this repository manages
import org.springframework.data.jpa.repository.JpaRepository;  // => Base repository interface
import org.springframework.stereotype.Repository;              // => Spring stereotype annotation
 
@Repository                                   // => Marks as Spring Data repository bean
                                              // => Optional - Spring auto-detects interfaces extending JpaRepository
public interface UserRepository extends JpaRepository<User, Long> {
    // => JpaRepository<User, Long> signature breakdown:
    // => - User: Entity type this repository manages
    // => - Long: Primary key type of User entity
    // => No method implementations needed - Spring Data JPA provides them at runtime
 
    // => Inherited CRUD methods (15+ methods):
    // => - save(User user) - INSERT or UPDATE
    // => - findById(Long id) - SELECT by primary key, returns Optional<User>
    // => - findAll() - SELECT *, returns List<User>
    // => - deleteById(Long id) - DELETE by primary key
    // => - count() - SELECT COUNT(*), returns long
    // => - existsById(Long id) - SELECT COUNT(*) WHERE id=?, returns boolean
 
    // => Spring generates proxy implementation at startup
    // => All methods use parameterized queries (SQL injection safe)
}
 
 

package com.example.demo.service;                // => Service layer package
 
import com.example.demo.entity.User;             // => Import User entity
import com.example.demo.repository.UserRepository; // => Import repository interface
import org.springframework.stereotype.Service;    // => Spring @Service annotation
 
@Service                                          // => Marks class as Spring service component
                                                  // => Auto-detected by component scanning
public class UserService {
    private final UserRepository userRepository;  // => Injected repository (immutable)
 
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;     // => Constructor injection (Spring dependency)
                                                  // => Recommended over @Autowired field injection
    }
 
    public void demo() {
        // Create new user
        User user = new User("Alice", "alice@example.com");
        // => Creates TRANSIENT entity (not yet tracked by persistence context)
        // => Entity state: {id=null, name="Alice", email="alice@example.com"}
        // => No database interaction yet
 
        // Save to database
        User saved = userRepository.save(user);
        // => Detects null ID, performs INSERT operation
        // => SQL: INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')
        // => Entity transitions: TRANSIENT → MANAGED (tracked by persistence context)
        // => Returns: {id=1, name="Alice", email="alice@example.com"}
 
        System.out.println("Saved user ID: " + saved.getId());
        // => Prints: 1 (auto-generated primary key)
    }
}
 
 

package com.example.demo.service;                // => Service layer package
 
import com.example.demo.entity.User;             // => Import User entity
import com.example.demo.repository.UserRepository; // => Import repository
import org.springframework.stereotype.Service;    // => Spring component annotation
 
@Service                                          // => Service bean registered in Spring context
public class UserPersistenceService {
    private final UserRepository userRepository;  // => Injected repository dependency
 
    public UserPersistenceService(UserRepository userRepository) {
        this.userRepository = userRepository;     // => Constructor injection
                                                  // => Enables immutability and testability
    }
 
    public void demonstrateSave() {
        // CREATE: New entity (id = null)
        User newUser = new User("Bob", "bob@example.com");
        // => Creates TRANSIENT entity (not tracked, id=null)
        // => Entity state: {id=null, name="Bob", email="bob@example.com"}
 
        User savedUser = userRepository.save(newUser);
        // => JPA detects id==null, performs INSERT operation
        // => SQL: INSERT INTO users (name, email) VALUES ('Bob', 'bob@example.com')
        // => Database assigns auto-increment ID (strategy=IDENTITY)
        // => Entity transitions: TRANSIENT → MANAGED (tracked by persistence context)
        // => Returns: {id=2, name="Bob", email="bob@example.com"}
 
        System.out.println("Created user with ID: " + savedUser.getId());
        // => Prints: 2 (generated primary key)
 
        // UPDATE: Existing entity (id != null)
        savedUser.setEmail("bob.updated@example.com");
        // => Modifies MANAGED entity field (dirty checking enabled)
        // => Changes not persisted until save() called
        // => Persistence context tracks modification
 
        User updatedUser = userRepository.save(savedUser);
        // => JPA detects id!=null, performs UPDATE operation
        // => SQL: UPDATE users SET name='Bob', email='bob.updated@example.com' WHERE id=2
        // => Returns updated entity: {id=2, name="Bob", email="bob.updated@example.com"}
 
        System.out.println("Updated email: " + updatedUser.getEmail());
        // => Prints: "bob.updated@example.com"
    }
}
 
 

package com.example.demo.service;                // => Service layer package
 
import com.example.demo.entity.User;             // => Import User entity
import com.example.demo.repository.UserRepository; // => Import repository
import org.springframework.stereotype.Service;    // => Spring component annotation
import java.util.Optional;                        // => Java 8+ Optional type
 
@Service                                          // => Service bean for Spring container
public class UserLookupService {
    private final UserRepository userRepository;  // => Injected repository dependency
 
    public UserLookupService(UserRepository userRepository) {
        this.userRepository = userRepository;     // => Constructor injection
    }
 
    public void demonstrateFindById() {
        // FOUND: ID exists in database
        Optional<User> found = userRepository.findById(1L);
        // => SQL: SELECT * FROM users WHERE id=1
        // => Uses index on primary key (fast lookup)
        // => Returns Optional[User{id=1, name="Alice", ...}] (not null)
 
        found.ifPresent(user -> {
            // => Lambda executes only if Optional contains value
            System.out.println("Found: " + user.getName());
            // => Prints: "Alice" (safe access, no NPE risk)
        });
 
        // NOT FOUND: ID doesn't exist
        Optional<User> notFound = userRepository.findById(999L);
        // => SQL: SELECT * FROM users WHERE id=999
        // => No rows returned
        // => Returns Optional.empty() (not null), never throws exception
 
        User defaultUser = notFound.orElse(new User("Guest", "guest@example.com"));
        // => Provides fallback value when Optional is empty
        // => Creates Guest user as default
        System.out.println("User: " + defaultUser.getName());
        // => Prints: "Guest" (fallback executed)
 
        // THROW EXCEPTION: Handle missing entity explicitly
        try {
            User user = userRepository.findById(999L)
                .orElseThrow(() -> new RuntimeException("User not found"));
            // => Throws RuntimeException when Optional.empty()
            // => Forces explicit error handling
        } catch (RuntimeException e) {
            System.out.println("Error: " + e.getMessage());
            // => Catches thrown exception
            // => Prints: "Error: User not found"
        }
    }
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.stereotype.Service;
import java.util.List;
 
@Service                                          // => Service bean for Spring container
public class UserListService {
    private final UserRepository userRepository;  // => Injected repository dependency
 
    public UserListService(UserRepository userRepository) {
        this.userRepository = userRepository;     // => Constructor injection
    }
 
    public void demonstrateFindAll() {
        // Setup: Create test data
        userRepository.save(new User("Alice", "alice@example.com"));
        // => SQL: INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')
        // => Returns User{id=1, ...}
        userRepository.save(new User("Bob", "bob@example.com"));
        // => SQL: INSERT INTO users (name, email) VALUES ('Bob', 'bob@example.com')
        // => Returns User{id=2, ...}
        userRepository.save(new User("Charlie", "charlie@example.com"));
        // => SQL: INSERT INTO users (name, email) VALUES ('Charlie', 'charlie@example.com')
        // => Returns User{id=3, ...}
        // => 3 entities persisted with auto-generated IDs
 
        // Retrieve all users
        List<User> allUsers = userRepository.findAll();
        // => SQL: SELECT * FROM users
        // => Fetches ALL rows into memory as List<User>
        // => Returns List, never null (empty list if no records)
        // => ⚠️ OOM risk for large tables (use Pageable for 1000+ rows)
 
        System.out.println("Total users: " + allUsers.size());
        // => Prints: 3 (List size)
 
        allUsers.forEach(user -> {
            // => Lambda iterates each User in the list
            System.out.println(user.getName());
            // => Prints: "Alice", "Bob", "Charlie" (one per iteration)
        });
 
        // Empty table scenario
        userRepository.deleteAll();
        // => SQL: DELETE FROM users (no WHERE clause)
        // => Executes DELETE for each entity (N queries, inefficient)
        List<User> emptyList = userRepository.findAll();
        // => SQL: SELECT * FROM users
        // => Returns: [] (empty ArrayList, NOT null)
        // => Safe to call .size() without null check
 
        System.out.println("Empty list size: " + emptyList.size());
        // => Prints: 0 (empty list size)
    }
}
 
 

package com.example.demo.service;                // => Service layer package
 
import com.example.demo.entity.User;             // => Import User entity
import com.example.demo.repository.UserRepository; // => Import repository
import org.springframework.stereotype.Service;    // => Spring component annotation
 
@Service                                          // => Service bean for Spring container
public class UserDeletionService {
    private final UserRepository userRepository;  // => Injected repository dependency
 
    public UserDeletionService(UserRepository userRepository) {
        this.userRepository = userRepository;     // => Constructor injection
    }
 
    public void demonstrateDelete() {
        // Setup: Create test users
        User user1 = userRepository.save(new User("Alice", "alice@example.com"));
        // => SQL: INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')
        // => Returns User{id=1, name="Alice", ...}
        User user2 = userRepository.save(new User("Bob", "bob@example.com"));
        // => SQL: INSERT INTO users (name, email) VALUES ('Bob', 'bob@example.com')
        // => Returns User{id=2, name="Bob", ...}
        User user3 = userRepository.save(new User("Charlie", "charlie@example.com"));
        // => SQL: INSERT INTO users (name, email) VALUES ('Charlie', 'charlie@example.com')
        // => Returns User{id=3, name="Charlie", ...}
 
        // Method 1: deleteById() - deletes by primary key
        userRepository.deleteById(1L);
        // => SQL 1: SELECT * FROM users WHERE id=1 (verifies existence)
        // => SQL 2: DELETE FROM users WHERE id=1 (deletes Alice)
        // => Two queries total (less efficient than delete(entity))
 
        // Method 2: delete() - deletes by entity object
        userRepository.delete(user2);
        // => SQL: DELETE FROM users WHERE id=2 (single query)
        // => More efficient (no SELECT needed, entity already loaded)
        // => Deletes Bob
 
        System.out.println("Remaining users: " + userRepository.count());
        // => SQL: SELECT COUNT(*) FROM users
        // => Prints: 1 (only Charlie remains)
 
        // Method 3: deleteAll() - deletes all records
        userRepository.deleteAll();
        // => SQL 1: SELECT * FROM users (loads all into memory)
        // => SQL 2+: DELETE FROM users WHERE id=? (one DELETE per row)
        // => ⚠️ OOM risk for large tables (use TRUNCATE or batch delete)
 
        System.out.println("Final count: " + userRepository.count());
        // => SQL: SELECT COUNT(*) FROM users
        // => Prints: 0 (table empty)
    }
}
 
 

package com.example.demo.service;                // => Service layer package
 
import com.example.demo.entity.User;             // => Import User entity
import com.example.demo.repository.UserRepository; // => Import repository
import org.springframework.stereotype.Service;    // => Spring component annotation
 
@Service                                          // => Service bean for Spring container
public class UserCountService {
    private final UserRepository userRepository;  // => Injected repository dependency
 
    public UserCountService(UserRepository userRepository) {
        this.userRepository = userRepository;     // => Constructor injection
    }
 
    public void demonstrateCountAndExists() {
        // Setup: Create test data
        userRepository.save(new User("Alice", "alice@example.com"));
        // => SQL: INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')
        userRepository.save(new User("Bob", "bob@example.com"));
        // => SQL: INSERT INTO users (name, email) VALUES ('Bob', 'bob@example.com')
        // => 2 users persisted with auto-generated IDs
 
        // Count total records
        long totalUsers = userRepository.count();
        // => SQL: SELECT COUNT(*) FROM users
        // => Returns: 2 (total row count)
 
        System.out.println("Total users: " + totalUsers);
        // => Prints: 2
 
        // Check existence by ID
        boolean exists = userRepository.existsById(1L);
        // => SQL: SELECT 1 FROM users WHERE id=1 LIMIT 1
        // => Optimized query (no columns fetched, just existence check)
        // => Returns: true (ID 1 exists)
 
        System.out.println("User 1 exists: " + exists);
        // => Prints: true
 
        boolean notExists = userRepository.existsById(999L);
        // => SQL: SELECT 1 FROM users WHERE id=999 LIMIT 1
        // => Returns: false (ID 999 doesn't exist, no exception)
 
        System.out.println("User 999 exists: " + notExists);
        // => Prints: false
 
        // INEFFICIENT: Don't use findById() just to check existence
        boolean inefficient = userRepository.findById(1L).isPresent();
        // => SQL: SELECT * FROM users WHERE id=1 (fetches ALL columns)
        // => ⚠️ Wasteful - use existsById() instead (10x faster for existence checks)
    }
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.stereotype.Service;
import java.util.Arrays;
import java.util.List;
 
@Service
public class UserBatchService {
    private final UserRepository userRepository;
 
    public UserBatchService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
 
    public void demonstrateSaveAll() {
        // Create multiple users
        List<User> users = Arrays.asList(          // => Creating list of transient entities
            new User("Alice", "alice@example.com"),  // => TRANSIENT entity {id=null, name="Alice", email="alice@example.com"}
            new User("Bob", "bob@example.com"),      // => TRANSIENT entity {id=null, name="Bob", email="bob@example.com"}
            new User("Charlie", "charlie@example.com"),  // => TRANSIENT entity {id=null, name="Charlie", email="charlie@example.com"}
            new User("Diana", "diana@example.com")   // => TRANSIENT entity {id=null, name="Diana", email="diana@example.com"}
        );                                          // => List contains 4 transient entities (id=null for all)
 
        // Batch save
        List<User> savedUsers = userRepository.saveAll(users);
                                                    // => Executes batch INSERT operation
                                                    // => SQL: INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')
                                                    // => SQL: INSERT INTO users (name, email) VALUES ('Bob', 'bob@example.com')
                                                    // => SQL: INSERT INTO users (name, email) VALUES ('Charlie', 'charlie@example.com')
                                                    // => SQL: INSERT INTO users (name, email) VALUES ('Diana', 'diana@example.com')
                                                    // => With hibernate.jdbc.batch_size configured, reduces to 1-2 roundtrips instead of 4
                                                    // => Returns List<User> with assigned IDs: [{id=1,...}, {id=2,...}, {id=3,...}, {id=4,...}]
 
        System.out.println("Saved " + savedUsers.size() + " users");  // => Output: "Saved 4 users"
 
        savedUsers.forEach(user -> {                // => Iterates each User in savedUsers
            System.out.println("ID: " + user.getId() + ", Name: " + user.getName());
                                                    // => Output: "ID: 1, Name: Alice"
                                                    // => Output: "ID: 2, Name: Bob"
                                                    // => Output: "ID: 3, Name: Charlie"
                                                    // => Output: "ID: 4, Name: Diana"
        });
 
        // Update multiple entities
        savedUsers.forEach(user -> user.setEmail(user.getEmail().toUpperCase()));
                                                    // => Modifies email field in each MANAGED entity
                                                    // => Changes: "alice@example.com" → "ALICE@EXAMPLE.COM", etc.
        List<User> updated = userRepository.saveAll(savedUsers);
                                                    // => Executes batch UPDATE operation
                                                    // => SQL: UPDATE users SET name='Alice', email='ALICE@EXAMPLE.COM' WHERE id=1
                                                    // => SQL: UPDATE users SET name='Bob', email='BOB@EXAMPLE.COM' WHERE id=2
                                                    // => (Similar for id=3 and id=4)
                                                    // => With batching, reduces to 1-2 roundtrips
                                                    // => Returns List<User> with updated state
 
        System.out.println("Updated emails to uppercase");  // => Output: "Updated emails to uppercase"
    }
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class UserTransactionService {
    private final UserRepository userRepository;
 
    public UserTransactionService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
 
    @Transactional                                // => Enables transaction boundaries and flush() support
                                                  // => Without @Transactional, flush() does nothing
    public void demonstrateFlush() {
        // Create user without flushing
        User user = new User("Alice", "alice@example.com");
        // => Creates TRANSIENT entity (not yet in persistence context)
        // => id field is null (will be assigned on INSERT)
 
        userRepository.save(user);
        // => Entity added to persistence context (MANAGED state)
        // => No SQL executed yet (batched until flush/commit)
 
        System.out.println("After save, before flush");
        // => Prints message (no database interaction yet)
 
        // Force immediate database write
        userRepository.flush();
        // => Synchronizes persistence context to database immediately
        // => SQL: INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')
        // => Database assigns auto-increment ID (id=1)
 
        System.out.println("After flush: ID = " + user.getId());
        // => Prints: "After flush: ID = 1" (ID now assigned)
 
        // Modify entity
        user.setEmail("alice.updated@example.com");
        // => Changes MANAGED entity field (dirty checking enabled)
        // => Persistence context marks entity as "dirty" (modified)
 
        userRepository.flush();
        // => Synchronizes dirty entities to database immediately
        // => SQL: UPDATE users SET email='alice.updated@example.com' WHERE id=1
        // => Changes written to database before transaction commit
 
        // Transaction commits at method end
        // => Any remaining dirty entities flushed automatically
        // => @Transactional triggers COMMIT (finalizes changes)
    }
 
    @Transactional
    public void demonstrateSaveAndFlush() {
        User user = new User("Bob", "bob@example.com");
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        // => Creates transient entity (not yet persisted, id=null)
 
        // saveAndFlush() = save() + flush()
        User saved = userRepository.saveAndFlush(user);
// => Combines save() + flush() in single operation
// => Immediately persists and synchronizes to database
// => ID available immediately after call
        // => SQL: INSERT INTO users (name, email) VALUES ('Bob', 'bob@example.com')
        // => Immediately written to database, ID available
 
        System.out.println("ID immediately available: " + saved.getId()); // => 2
    }
}
 
 

package com.example.demo.repository;                         // => Repository layer package
 
import com.example.demo.entity.User;                          // => User entity import
import org.springframework.data.jpa.repository.JpaRepository; // => Base repository interface
import java.util.List;                                        // => Java List collection
import java.util.Optional;                                    // => Java Optional wrapper
 
public interface UserRepository extends JpaRepository<User, Long> {
                                                              // => Repository interface for User entity (no implementation needed)
 
    Optional<User> findByName(String name);                   // => Query derivation from method name
                                                              // => "findBy" prefix triggers query generation
                                                              // => "Name" matches User.name field
                                                              // => Generates SQL: SELECT * FROM users WHERE name = ?
                                                              // => Parameter binding: ? = name (SQL injection safe)
                                                              // => Returns Optional<User> (single result expected)
                                                              // => If multiple matches, returns first one (non-deterministic)
                                                              // => Returns Optional.empty() if no match
 
    List<User> findByEmail(String email);                     // => Query derivation for multiple results
                                                              // => "Email" matches User.email field
                                                              // => Generates SQL: SELECT * FROM users WHERE email = ?
                                                              // => Returns List<User> (supports 0 or more results)
                                                              // => Empty list if no matches (never null)
}
 
 

package com.example.demo.service;                            // => Service layer package
 
import com.example.demo.entity.User;                          // => User entity import
import com.example.demo.repository.UserRepository;            // => Repository import
import org.springframework.stereotype.Service;                // => Spring @Service annotation
import java.util.Optional;                                    // => Optional wrapper for single results
import java.util.List;                                        // => List for multiple results
 
@Service                                                      // => Spring service bean
public class UserQueryService {                               // => Service layer for User query operations
    private final UserRepository userRepository;              // => Repository dependency (final for immutability)
 
    public UserQueryService(UserRepository userRepository) {  // => Constructor injection (preferred over @Autowired)
        this.userRepository = userRepository;                 // => Assigns injected repository
    }
 
    public void demonstrateFindByProperty() {                 // => Demo method showing query derivation
        userRepository.save(new User("Alice", "alice@example.com"));
                                                              // => Creates User entity {id=null, name="Alice", email="alice@example.com"}
                                                              // => Executes INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')
                                                              // => Returns User {id=1, name="Alice", email="alice@example.com"}
        userRepository.save(new User("Bob", "bob@example.com"));
                                                              // => Creates User entity {id=null, name="Bob", email="bob@example.com"}
                                                              // => Executes INSERT INTO users (name, email) VALUES ('Bob', 'bob@example.com')
                                                              // => Returns User {id=2, name="Bob", email="bob@example.com"}
        userRepository.save(new User("Alice", "alice2@example.com"));
                                                              // => DUPLICATE name "Alice" (different email)
                                                              // => Executes INSERT INTO users (name, email) VALUES ('Alice', 'alice2@example.com')
                                                              // => Returns User {id=3, name="Alice", email="alice2@example.com"}
 
        Optional<User> alice = userRepository.findByName("Alice");
                                                              // => Calls derived query method findByName("Alice")
                                                              // => Executes SQL: SELECT * FROM users WHERE name = 'Alice'
                                                              // => WARNING: Multiple "Alice" records exist (id=1 and id=3)
                                                              // => Returns first match (non-deterministic order): Optional[User{id=1, name="Alice", email="alice@example.com"}]
                                                              // => Optional prevents null pointer exceptions
 
        alice.ifPresent(user -> {                             // => Executes lambda ONLY if Optional contains a value
                                                              // => Safe alternative to alice.get() which throws NoSuchElementException if empty
            System.out.println("Found: " + user.getEmail());  // => Output: "Found: alice@example.com"
        });                                                   // => No output if alice is Optional.empty()
 
        List<User> bobUsers = userRepository.findByEmail("bob@example.com");
                                                              // => Calls derived query method findByEmail("bob@example.com")
                                                              // => Executes SQL: SELECT * FROM users WHERE email = 'bob@example.com'
                                                              // => Returns List<User> with 1 element: [User{id=2, name="Bob", email="bob@example.com"}]
                                                              // => List return type supports 0 or more results (never null)
 
        System.out.println("Users with bob@example.com: " + bobUsers.size());
                                                              // => Output: "Users with bob@example.com: 1"
    }
}
 
 

package com.example.demo.repository;
 
import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
 
public interface UserRepository extends JpaRepository<User, Long> {
    // AND condition - both parameters must match
    List<User> findByNameAndEmail(String name, String email);
    // => Generates: SELECT * FROM users WHERE name = ? AND email = ?
    // => Parameters bound in method order: name→?, email→?
    // => Returns: List (empty if no matches, never null)
 
    // OR condition - either parameter can match
    List<User> findByNameOrEmail(String name, String email);
    // => Generates: SELECT * FROM users WHERE name = ? OR email = ?
    // => Parameters bound in method order: name→?, email→?
    // => Returns: List with all matching rows
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.stereotype.Service;
import java.util.List;
 
@Service
public class UserMultiQueryService {
    private final UserRepository userRepository;
 
    public UserMultiQueryService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
 
    public void demonstrateMultiPropertyQueries() {
        // Setup test data
        userRepository.save(new User("Alice", "alice@example.com"));
        // => Inserts id=1: {name="Alice", email="alice@example.com"}
        userRepository.save(new User("Bob", "bob@example.com"));
        // => Inserts id=2: {name="Bob", email="bob@example.com"}
        userRepository.save(new User("Alice", "alice2@example.com"));
        // => Inserts id=3: {name="Alice", email="alice2@example.com"}
 
        // AND query - both conditions must match
        List<User> exact = userRepository.findByNameAndEmail("Alice", "alice@example.com");
        // => Executes: SELECT * FROM users WHERE name = 'Alice' AND email = 'alice@example.com'
        // => Matches only id=1 (both conditions satisfied)
        // => Returns: [User{id=1, name="Alice", email="alice@example.com"}]
 
        System.out.println("Exact match: " + exact.size()); // => 1
 
        // OR query - either condition can match
        List<User> either = userRepository.findByNameOrEmail("Alice", "bob@example.com");
        // => Executes: SELECT * FROM users WHERE name = 'Alice' OR email = 'bob@example.com'
        // => Matches id=1 (name), id=2 (email), id=3 (name)
        // => Returns: [
        // =>   User{id=1, name="Alice", email="alice@example.com"},
        // =>   User{id=2, name="Bob", email="bob@example.com"},
        // =>   User{id=3, name="Alice", email="alice2@example.com"}
        // => ]
 
        System.out.println("OR match: " + either.size()); // => 3
    }
}
 
 

package com.example.demo.entity;                 // => JPA entity package
 
import jakarta.persistence.*;                     // => Jakarta Persistence API (JPA 3.0+)
 
@Entity                                           // => Marks class as JPA entity (table mapping)
                                                  // => Hibernate scans for @Entity classes at startup
@Table(name = "products")                         // => Maps to "products" table in database
                                                  // => Without @Table, defaults to class name "Product"
public class Product {
    @Id                                           // => Primary key field
    @GeneratedValue(strategy = GenerationType.IDENTITY)
                                                  // => Auto-increment strategy (database-generated ID)
                                                  // => Database assigns ID on INSERT
    private Long id;                              // => Primary key type (Long supports null for new entities)
 
    private String name;                          // => Product name (nullable=true by default)
                                                  // => Maps to VARCHAR(255) in database
    private Double price;                         // => Product price (nullable=true by default)
                                                  // => Maps to DOUBLE in database
 
    public Product() {}                           // => Default constructor REQUIRED by JPA
                                                  // => JPA uses reflection to instantiate entities
 
    public Product(String name, Double price) {   // => Convenience constructor for application code
        this.name = name;                         // => Sets name field
        this.price = price;                       // => Sets price field
    }                                             // => Note: id remains null (assigned on persist)
 
    // Getters and setters
    public Long getId() { return id; }            // => Getter for primary key
    public void setId(Long id) {                  // => Setter for primary key
        this.id = id;                             // => Usually only set by JPA, not application code
    }
    public String getName() { return name; }      // => Getter for name field
    public void setName(String name) {            // => Setter for name field
        this.name = name;                         // => Updates name in managed entity
    }
    public Double getPrice() { return price; }    // => Getter for price field
    public void setPrice(Double price) {          // => Setter for price field
        this.price = price;                       // => Updates price in managed entity
    }
}
 
 

package com.example.demo.repository;
 
import com.example.demo.entity.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
 
public interface ProductRepository extends JpaRepository<Product, Long> {
    // Less than
    List<Product> findByPriceLessThan(Double price);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM products WHERE price < ?
 
    // Greater than or equal
    List<Product> findByPriceGreaterThanEqual(Double price);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM products WHERE price >= ?
 
    // Between (inclusive)
    List<Product> findByPriceBetween(Double min, Double max);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM products WHERE price BETWEEN ? AND ?
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.Product;
import com.example.demo.repository.ProductRepository;
import org.springframework.stereotype.Service;
import java.util.List;
 
@Service
public class ProductQueryService {
    private final ProductRepository productRepository;
 
    public ProductQueryService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }
 
    public void demonstrateComparisons() {
        // Setup data
        productRepository.save(new Product("Laptop", 999.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        productRepository.save(new Product("Mouse", 29.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        productRepository.save(new Product("Keyboard", 79.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        productRepository.save(new Product("Monitor", 299.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
 
        // Find cheap products (< $50)
        List<Product> cheap = productRepository.findByPriceLessThan(50.0);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM products WHERE price < 50.0
        // => Result: [Product{name="Mouse", price=29.99}]
 
        System.out.println("Cheap products: " + cheap.size()); // => 1
 
        // Find expensive products (>= $100)
        List<Product> expensive = productRepository.findByPriceGreaterThanEqual(100.0);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM products WHERE price >= 100.0
        // => Result: [
        // =>   Product{name="Laptop", price=999.99},
        // =>   Product{name="Monitor", price=299.99}
        // => ]
 
        System.out.println("Expensive products: " + expensive.size()); // => 2
 
        // Find mid-range products ($50 - $300)
        List<Product> midRange = productRepository.findByPriceBetween(50.0, 300.0);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM products WHERE price BETWEEN 50.0 AND 300.0
        // => Result: [
        // =>   Product{name="Keyboard", price=79.99},
        // =>   Product{name="Monitor", price=299.99}
        // => ]
 
        System.out.println("Mid-range products: " + midRange.size()); // => 2
    }
}
 
 

package com.example.demo.repository;
 
import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
 
public interface UserRepository extends JpaRepository<User, Long> {
    // Starts with prefix
    List<User> findByNameStartingWith(String prefix);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM users WHERE name LIKE 'prefix%'
 
    // Ends with suffix
    List<User> findByNameEndingWith(String suffix);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM users WHERE name LIKE '%suffix'
 
    // Contains substring
    List<User> findByNameContaining(String substring);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM users WHERE name LIKE '%substring%'
 
    // Email domain matching
    List<User> findByEmailEndingWith(String domain);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM users WHERE email LIKE '%domain'
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.stereotype.Service;
import java.util.List;
 
@Service
public class UserPatternService {
    private final UserRepository userRepository;
 
    public UserPatternService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
 
    public void demonstrateStringMatching() {
        // Setup data
        userRepository.save(new User("Alice", "alice@gmail.com"));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        userRepository.save(new User("Alex", "alex@yahoo.com"));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        userRepository.save(new User("Bob", "bob@gmail.com"));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        userRepository.save(new User("Charlie", "charlie@example.com"));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
 
        // Find names starting with "Al"
        List<User> alNames = userRepository.findByNameStartingWith("Al");
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM users WHERE name LIKE 'Al%'
        // => Result: [
        // =>   User{name="Alice", email="alice@gmail.com"},
        // =>   User{name="Alex", email="alex@yahoo.com"}
        // => ]
 
        System.out.println("Names starting with 'Al': " + alNames.size()); // => 2
 
        // Find names ending with "ie"
        List<User> ieNames = userRepository.findByNameEndingWith("ie");
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM users WHERE name LIKE '%ie'
        // => Result: [User{name="Charlie", email="charlie@example.com"}]
 
        System.out.println("Names ending with 'ie': " + ieNames.size()); // => 1
 
        // Find names containing "li"
        List<User> liNames = userRepository.findByNameContaining("li");
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM users WHERE name LIKE '%li%'
        // => Result: [
        // =>   User{name="Alice", email="alice@gmail.com"},
        // =>   User{name="Charlie", email="charlie@example.com"}
        // => ]
 
        System.out.println("Names containing 'li': " + liNames.size()); // => 2
 
        // Find Gmail users
        List<User> gmailUsers = userRepository.findByEmailEndingWith("@gmail.com");
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM users WHERE email LIKE '%@gmail.com'
        // => Result: [
        // =>   User{name="Alice", email="alice@gmail.com"},
        // =>   User{name="Bob", email="bob@gmail.com"}
        // => ]
 
        System.out.println("Gmail users: " + gmailUsers.size()); // => 2
    }
}
 
 

package com.example.demo.repository;                 // => Repository layer package
 
import com.example.demo.entity.Product;              // => Import Product entity
import org.springframework.data.jpa.repository.JpaRepository; // => Base repository interface
import java.util.List;                                // => Java List collection
 
public interface ProductRepository extends JpaRepository<Product, Long> {
                                                      // => Repository for Product entity (Long primary key)
                                                      // => Spring generates implementation at runtime
 
    // Single property ascending
    List<Product> findAllByOrderByPriceAsc();
    // => Spring derives query from method name: findAllBy + OrderBy + Price + Asc
    // => SQL: SELECT * FROM products ORDER BY price ASC
    // => Returns List sorted by price (lowest first)
 
    // Single property descending
    List<Product> findAllByOrderByPriceDesc();
    // => Spring derives query from method name: findAllBy + OrderBy + Price + Desc
    // => SQL: SELECT * FROM products ORDER BY price DESC
    // => Returns List sorted by price (highest first)
 
    // Multiple properties
    List<Product> findAllByOrderByNameAscPriceDesc();
    // => Spring derives multi-column sort: OrderBy + Name + Asc + Price + Desc
    // => SQL: SELECT * FROM products ORDER BY name ASC, price DESC
    // => Returns List sorted by name alphabetically, then price descending
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.Product;
import com.example.demo.repository.ProductRepository;
import org.springframework.stereotype.Service;
import java.util.List;
 
@Service
public class ProductSortService {
    private final ProductRepository productRepository;
 
    public ProductSortService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }
 
    public void demonstrateOrdering() {
        // Setup data
        productRepository.save(new Product("Laptop", 999.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        productRepository.save(new Product("Mouse", 29.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        productRepository.save(new Product("Keyboard", 79.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        productRepository.save(new Product("Monitor", 299.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
 
        // Ascending price order
        List<Product> cheapFirst = productRepository.findAllByOrderByPriceAsc();
        // => SQL: SELECT * FROM products ORDER BY price ASC
        // => Result: [
        // =>   Product{name="Mouse", price=29.99},
        // =>   Product{name="Keyboard", price=79.99},
        // =>   Product{name="Monitor", price=299.99},
        // =>   Product{name="Laptop", price=999.99}
        // => ]
 
        System.out.println("Cheapest: " + cheapFirst.get(0).getName()); // => "Mouse"
 
        // Descending price order
        List<Product> expensiveFirst = productRepository.findAllByOrderByPriceDesc();
        // => SQL: SELECT * FROM products ORDER BY price DESC
        // => Result: [
        // =>   Product{name="Laptop", price=999.99},
        // =>   Product{name="Monitor", price=299.99},
        // =>   Product{name="Keyboard", price=79.99},
        // =>   Product{name="Mouse", price=29.99}
        // => ]
 
        System.out.println("Most expensive: " + expensiveFirst.get(0).getName());
        // => "Laptop"
    }
}
 
 

package com.example.demo.repository;                 // => Repository layer package
 
import com.example.demo.entity.Product;              // => Import Product entity
import org.springframework.data.jpa.repository.JpaRepository; // => Base repository interface
import java.util.List;                                // => Java List collection
import java.util.Optional;                            // => Java Optional wrapper
 
public interface ProductRepository extends JpaRepository<Product, Long> {
                                                      // => Repository for Product entity (Long primary key)
                                                      // => Spring generates implementation at runtime
 
    // First result only
    Optional<Product> findFirstByOrderByPriceAsc();
    // => Spring derives query: findFirst + By + OrderBy + Price + Asc
    // => SQL: SELECT * FROM products ORDER BY price ASC LIMIT 1
    // => Returns Optional<Product> (single result or empty)
 
    // Top 3 results
    List<Product> findTop3ByOrderByPriceDesc();
    // => Spring derives query: findTop3 + By + OrderBy + Price + Desc
    // => SQL: SELECT * FROM products ORDER BY price DESC LIMIT 3
    // => Returns List<Product> (max 3 items, could be fewer)
 
    // First 5 with condition
    List<Product> findFirst5ByPriceGreaterThanOrderByPriceAsc(Double price);
    // => Spring derives: findFirst5 + By + Price + GreaterThan + OrderBy + Price + Asc
    // => SQL: SELECT * FROM products WHERE price > ? ORDER BY price ASC LIMIT 5
    // => Parameter binding: ? = price (SQL injection safe)
    // => Returns List<Product> (max 5 items matching condition)
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.Product;
import com.example.demo.repository.ProductRepository;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
 
@Service
public class ProductLimitService {
    private final ProductRepository productRepository;
 
    public ProductLimitService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }
 
    public void demonstrateLimiting() {
        // Setup data
        productRepository.save(new Product("Laptop", 999.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        productRepository.save(new Product("Mouse", 29.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        productRepository.save(new Product("Keyboard", 79.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        productRepository.save(new Product("Monitor", 299.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        productRepository.save(new Product("Webcam", 89.99));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
 
        // Get cheapest product
        Optional<Product> cheapest = productRepository.findFirstByOrderByPriceAsc();
        // => SQL: SELECT * FROM products ORDER BY price ASC LIMIT 1
        // => Result: Optional[Product{name="Mouse", price=29.99}]
 
        cheapest.ifPresent(p -> {
// => Executes lambda only if value is present
// => Safe alternative to .get() which throws NoSuchElementException
            System.out.println("Cheapest: " + p.getName() + " - $" + p.getPrice());
            // => "Cheapest: Mouse - $29.99"
        });
 
        // Get top 3 most expensive
        List<Product> topExpensive = productRepository.findTop3ByOrderByPriceDesc();
        // => SQL: SELECT * FROM products ORDER BY price DESC LIMIT 3
        // => Result: [
        // =>   Product{name="Laptop", price=999.99},
        // =>   Product{name="Monitor", price=299.99},
        // =>   Product{name="Webcam", price=89.99}
        // => ]
 
        System.out.println("Top 3 expensive products: " + topExpensive.size()); // => 3
 
        // Get first 5 products over $50
        List<Product> affordable = productRepository
            .findFirst5ByPriceGreaterThanOrderByPriceAsc(50.0);
        // => SQL: SELECT * FROM products WHERE price > 50.0 ORDER BY price ASC LIMIT 5
        // => Result: [
        // =>   Product{name="Keyboard", price=79.99},
        // =>   Product{name="Webcam", price=89.99},
        // =>   Product{name="Monitor", price=299.99},
        // =>   Product{name="Laptop", price=999.99}
        // => ] (only 4 results because only 4 products > $50)
 
        System.out.println("Products over $50: " + affordable.size()); // => 4
    }
}
 
 

package com.example.demo.entity;                     // => JPA entity package
 
import jakarta.persistence.*;                         // => Jakarta Persistence API (JPA 3.0+)
 
@Entity                                               // => Marks class as JPA entity (table mapping)
                                                      // => Hibernate creates users table from this class
@Table(name = "users")                                // => Explicit table name mapping
                                                      // => Without @Table, defaults to "User"
public class User {
    @Id                                               // => Primary key field
    @GeneratedValue(strategy = GenerationType.IDENTITY)
                                                      // => Auto-increment strategy (database-generated ID)
                                                      // => Database assigns ID on INSERT
    private Long id;                                  // => Primary key type (Long supports null for new entities)
 
    @Column(nullable = false)                         // => NOT NULL constraint in database
                                                      // => JPA validates before persisting
                                                      // => Database rejects INSERT/UPDATE if name is null
    private String name;                              // => Required field (cannot be null)
 
    private String email;                             // => Nullable field (nullable=true by default)
                                                      // => Can be null in database (email is optional)
                                                      // => Maps to VARCHAR(255) in database
 
    public User() {}                                  // => Default constructor REQUIRED by JPA
                                                      // => JPA uses reflection to instantiate
 
    public User(String name, String email) {          // => Convenience constructor
        this.name = name;                             // => Sets required name field
        this.email = email;                           // => Sets optional email field (can be null)
    }                                                 // => Note: id remains null (assigned on persist)
 
    // Getters and setters
    public Long getId() { return id; }                // => Getter for primary key
    public void setId(Long id) {                      // => Setter for primary key
        this.id = id;                                 // => Usually only set by JPA
    }
    public String getName() { return name; }          // => Getter for required name
    public void setName(String name) {                // => Setter for required name
        this.name = name;                             // => Updates name in managed entity
    }
    public String getEmail() { return email; }        // => Getter for optional email
    public void setEmail(String email) {              // => Setter for optional email
        this.email = email;                           // => Updates email (can set to null)
    }
}
 
 

package com.example.demo.repository;
 
import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
 
public interface UserRepository extends JpaRepository<User, Long> {
    // Find users with no email
    List<User> findByEmailIsNull();
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM users WHERE email IS NULL
 
    // Find users with email
    List<User> findByEmailIsNotNull();
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM users WHERE email IS NOT NULL
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.stereotype.Service;
import java.util.List;
 
@Service
public class UserNullService {
    private final UserRepository userRepository;
 
    public UserNullService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
 
    public void demonstrateNullHandling() {
        // Setup data with null emails
        userRepository.save(new User("Alice", "alice@example.com"));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        userRepository.save(new User("Bob", null)); // No email
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        userRepository.save(new User("Charlie", "charlie@example.com"));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        userRepository.save(new User("Diana", null)); // No email
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
 
        // Find users without email
        List<User> noEmail = userRepository.findByEmailIsNull();
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM users WHERE email IS NULL
        // => Result: [
        // =>   User{name="Bob", email=null},
        // =>   User{name="Diana", email=null}
        // => ]
 
        System.out.println("Users without email: " + noEmail.size()); // => 2
 
        // Find users with email
        List<User> hasEmail = userRepository.findByEmailIsNotNull();
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM users WHERE email IS NOT NULL
        // => Result: [
        // =>   User{name="Alice", email="alice@example.com"},
        // =>   User{name="Charlie", email="charlie@example.com"}
        // => ]
 
        System.out.println("Users with email: " + hasEmail.size()); // => 2
 
        // Verify total count
        long total = userRepository.count();
// => Executes SELECT COUNT(*) FROM table
// => Returns total number of records as long
        // => Executes COUNT(*) query, returns total records
        System.out.println("Total users: " + total); // => 4
        System.out.println("Sum check: " + (noEmail.size() + hasEmail.size())); // => 4
    }
}
 
 

package com.example.demo.repository;
 
import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
import java.util.Optional;
 
public interface UserRepository extends JpaRepository<User, Long> {
    // Case-insensitive exact match
    Optional<User> findByNameIgnoreCase(String name);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM users WHERE UPPER(name) = UPPER(?)
 
    // Case-insensitive contains
    List<User> findByNameContainingIgnoreCase(String substring);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM users WHERE UPPER(name) LIKE UPPER('%substring%')
 
    // Case-insensitive starts with
    List<User> findByEmailStartingWithIgnoreCase(String prefix);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM users WHERE UPPER(email) LIKE UPPER('prefix%')
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
 
@Service
public class UserCaseService {
    private final UserRepository userRepository;
 
    public UserCaseService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
 
    public void demonstrateCaseInsensitive() {
        // Setup data with mixed case
        userRepository.save(new User("Alice", "ALICE@example.com"));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        userRepository.save(new User("BOB", "bob@example.com"));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
        userRepository.save(new User("Charlie", "Charlie@Example.COM"));
// => Creates TRANSIENT entity (not yet in database)
// => id field is null (will be assigned on save)
 
        // Case-insensitive exact match
        Optional<User> alice = userRepository.findByNameIgnoreCase("alice");
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM users WHERE UPPER(name) = UPPER('alice')
        // => Matches "Alice" (stored as "Alice" in database)
        // => Result: Optional[User{name="Alice", email="ALICE@example.com"}]
 
        alice.ifPresent(u -> {
// => Executes lambda only if value is present
// => Safe alternative to .get() which throws NoSuchElementException
            System.out.println("Found: " + u.getName()); // => "Alice"
        });
 
        Optional<User> bob = userRepository.findByNameIgnoreCase("bob");
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM users WHERE UPPER(name) = UPPER('bob')
        // => Matches "BOB" (stored as "BOB")
        // => Result: Optional[User{name="BOB", email="bob@example.com"}]
 
        bob.ifPresent(u -> {
// => Executes lambda only if value is present
// => Safe alternative to .get() which throws NoSuchElementException
            System.out.println("Found: " + u.getName()); // => "BOB"
        });
 
        // Case-insensitive contains
        List<User> charlieVariants = userRepository.findByNameContainingIgnoreCase("CHAR");
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM users WHERE UPPER(name) LIKE UPPER('%CHAR%')
        // => Matches "Charlie"
        // => Result: [User{name="Charlie", email="Charlie@Example.COM"}]
 
        System.out.println("Names containing 'CHAR': " + charlieVariants.size()); // => 1
 
        // Case-insensitive email search
        List<User> exampleEmails = userRepository
            .findByEmailStartingWithIgnoreCase("alice");
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM users WHERE UPPER(email) LIKE UPPER('alice%')
        // => Matches "ALICE@example.com"
        // => Result: [User{name="Alice", email="ALICE@example.com"}]
 
        System.out.println("Emails starting with 'alice': " + exampleEmails.size());
        // => 1
    }
}
 
 

package com.example.demo.entity;
 
import jakarta.persistence.*;
import java.util.ArrayList;
import java.util.List;
 
@Entity                                           // => Marks class as JPA entity (table mapping)
                                                  // => Hibernate creates departments table from this class
@Table(name = "departments")                      // => Explicit table name mapping
                                                  // => Without @Table, defaults to "Department"
public class Department {
    @Id                                           // => Primary key field
    @GeneratedValue(strategy = GenerationType.IDENTITY)
                                                  // => Auto-increment strategy (database-generated ID)
                                                  // => Database assigns ID on INSERT
    private Long id;                              // => Primary key type (Long supports null for new entities)
 
    private String name;                          // => Department name (nullable=true by default)
                                                  // => Maps to VARCHAR(255) in database
 
    // One department has many employees
    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL)
                                                  // => One-to-many relationship definition
                                                  // => mappedBy="department" references Employee.department field (inverse side)
                                                  // => cascade=ALL operations propagate to employees (save, delete, etc.)
                                                  // => Lazy loaded by default (fetch=LAZY implicit)
    private List<Employee> employees = new ArrayList<>();
                                                  // => Collection initialized to prevent NPE
                                                  // => Empty list for new departments
 
    public Department() {}                        // => Default constructor REQUIRED by JPA
                                                  // => JPA uses reflection to instantiate
 
    public Department(String name) {              // => Convenience constructor
        this.name = name;                         // => Sets department name
    }                                             // => employees list auto-initialized (empty)
 
    // Helper method to maintain both sides of relationship
    public void addEmployee(Employee employee) {
        employees.add(employee);                  // => Adds employee to collection (one side)
        employee.setDepartment(this);             // => Sets back-reference (inverse side)
    }                                             // => Maintains bidirectional consistency
 
    // Getters and setters
    public Long getId() { return id; }            // => Getter for primary key
    public void setId(Long id) {                  // => Setter for primary key
        this.id = id;                             // => Usually only set by JPA
    }
    public String getName() { return name; }      // => Getter for department name
    public void setName(String name) {            // => Setter for department name
        this.name = name;                         // => Updates name in managed entity
    }
    public List<Employee> getEmployees() { return employees; } // => Getter for employees collection
    public void setEmployees(List<Employee> employees) {      // => Setter for employees collection
        this.employees = employees;               // => Replaces entire collection
    }
}
 
 

package com.example.demo.entity;
 
import jakarta.persistence.*;
 
@Entity                                           // => Marks class as JPA entity (table mapping)
                                                  // => Hibernate creates employees table from this class
@Table(name = "employees")                        // => Explicit table name mapping
                                                  // => Without @Table, defaults to "Employee"
public class Employee {
    @Id                                           // => Primary key field
    @GeneratedValue(strategy = GenerationType.IDENTITY)
                                                  // => Auto-increment strategy (database-generated ID)
                                                  // => Database assigns ID on INSERT
    private Long id;                              // => Primary key type (Long supports null for new entities)
 
    private String name;                          // => Employee name (nullable=true by default)
                                                  // => Maps to VARCHAR(255) in database
 
    // Many employees belong to one department
    @ManyToOne                                    // => Many-to-one relationship definition
                                                  // => This is the "owning side" (has foreign key)
                                                  // => Eager loaded by default (fetch=EAGER implicit)
    @JoinColumn(name = "department_id")           // => Foreign key column name
                                                  // => Creates department_id column in employees table
                                                  // => References departments.id (implicit)
    private Department department;                // => Department reference (can be null)
 
    public Employee() {}                          // => Default constructor REQUIRED by JPA
                                                  // => JPA uses reflection to instantiate
 
    public Employee(String name) {                // => Convenience constructor
        this.name = name;                         // => Sets employee name
    }                                             // => department remains null (set via setter)
 
    // Getters and setters
    public Long getId() { return id; }            // => Getter for primary key
    public void setId(Long id) {                  // => Setter for primary key
        this.id = id;                             // => Usually only set by JPA
    }
    public String getName() { return name; }      // => Getter for employee name
    public void setName(String name) {            // => Setter for employee name
        this.name = name;                         // => Updates name in managed entity
    }
    public Department getDepartment() { return department; } // => Getter for department reference
    public void setDepartment(Department department) {      // => Setter for department reference
        this.department = department;             // => Sets foreign key relationship
    }
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.Department;
import com.example.demo.entity.Employee;
import com.example.demo.repository.DepartmentRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class DepartmentService {
    private final DepartmentRepository departmentRepository;
 
    public DepartmentService(DepartmentRepository departmentRepository) {
        this.departmentRepository = departmentRepository;
    }
 
    @Transactional
    public void demonstrateOneToMany() {
        // Create department
        Department engineering = new Department("Engineering");
        // => Department state: {id=null, name="Engineering", employees=[]}
 
        // Create employees
        Employee alice = new Employee("Alice");
        Employee bob = new Employee("Bob");
        // => Employee states: {id=null, name="Alice", department=null}
 
        // Add employees to department
        engineering.addEmployee(alice);
        engineering.addEmployee(bob);
        // => Department: {id=null, name="Engineering", employees=[alice, bob]}
        // => alice: {id=null, name="Alice", department=engineering}
        // => bob: {id=null, name="Bob", department=engineering}
 
        // Save department (cascade saves employees too)
        Department saved = departmentRepository.save(engineering);
// => Persists entity to database (INSERT if id=null, UPDATE if id exists)
// => Entity transitions from TRANSIENT to MANAGED state
// => Returns entity with database-assigned ID
        // => Persists entity to database (INSERT or UPDATE)
        // => Entity transitions to MANAGED state with assigned ID
        // => SQL: INSERT INTO departments (name) VALUES ('Engineering')
        // => SQL: INSERT INTO employees (name, department_id) VALUES ('Alice', 1)
        // => SQL: INSERT INTO employees (name, department_id) VALUES ('Bob', 1)
 
        System.out.println("Department ID: " + saved.getId()); // => 1
        System.out.println("Employees: " + saved.getEmployees().size()); // => 2
    }
}
 
 

package com.example.demo.repository;
 
import com.example.demo.entity.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
 
public interface EmployeeRepository extends JpaRepository<Employee, Long> {
    // Find employees by department name (navigates relationship)
    List<Employee> findByDepartmentName(String departmentName);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT e.* FROM employees e
    // =>      JOIN departments d ON e.department_id = d.id
    // =>      WHERE d.name = ?
 
    // Find employees by department ID
    List<Employee> findByDepartmentId(Long departmentId);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
    // => SQL: SELECT * FROM employees WHERE department_id = ?
}
 
 

package com.example.demo.service;           // => Service layer package
 
import com.example.demo.entity.Department;   // => Import Department entity for setup
import com.example.demo.entity.Employee;     // => Import Employee entity
import com.example.demo.repository.DepartmentRepository;  // => Department persistence
import com.example.demo.repository.EmployeeRepository;    // => Employee persistence
import org.springframework.stereotype.Service;            // => Spring service stereotype
import org.springframework.transaction.annotation.Transactional; // => Transaction management
import java.util.List;                        // => Java List collection
 
@Service                                      // => Spring service bean (auto-detected)
public class EmployeeQueryService {
    private final DepartmentRepository departmentRepository;  // => Injected repository
    private final EmployeeRepository employeeRepository;      // => Injected repository
 
    public EmployeeQueryService(DepartmentRepository departmentRepository,
                                EmployeeRepository employeeRepository) {
        this.departmentRepository = departmentRepository;  // => Constructor injection
        this.employeeRepository = employeeRepository;      // => Both repos injected
    }
 
    @Transactional                            // => Wraps all queries in single transaction
    public void demonstrateRelationshipQueries() {
        // Setup data
        Department engineering = new Department("Engineering");
        // => Creates TRANSIENT department (not yet persisted, id=null)
        engineering.addEmployee(new Employee("Alice"));
        // => Adds Alice to engineering's employee list + sets alice.department = engineering
        engineering.addEmployee(new Employee("Bob"));
        // => Adds Bob to engineering's employee list + sets bob.department = engineering
        departmentRepository.save(engineering);
        // => INSERT INTO departments (name) VALUES ('Engineering') → id=1
        // => INSERT INTO employees (name, department_id) VALUES ('Alice', 1)
        // => INSERT INTO employees (name, department_id) VALUES ('Bob', 1)
 
        Department sales = new Department("Sales");
        // => Creates TRANSIENT Sales department
        sales.addEmployee(new Employee("Charlie"));
        // => Adds Charlie to sales' employee list
        departmentRepository.save(sales);
        // => INSERT INTO departments (name) VALUES ('Sales') → id=2
        // => INSERT INTO employees (name, department_id) VALUES ('Charlie', 2)
 
        // Query by department name (auto-join)
        List<Employee> engineers = employeeRepository.findByDepartmentName("Engineering");
        // => Spring derives query from method name: findBy + Department.Name
        // => SQL: SELECT e.* FROM employees e
        // =>      JOIN departments d ON e.department_id = d.id
        // =>      WHERE d.name = 'Engineering'
        // => Returns: [Employee{name="Alice"}, Employee{name="Bob"}]
 
        System.out.println("Engineers: " + engineers.size());
        // => Prints: 2 (Alice and Bob from Engineering)
 
        // Query by department ID (no join needed)
        List<Employee> salesTeam = employeeRepository.findByDepartmentId(1L);
        // => Spring derives query from method name: findBy + Department.Id
        // => SQL: SELECT * FROM employees WHERE department_id = 1
        // => No JOIN needed (foreign key direct match)
        // => Returns: [Employee{name="Alice"}, Employee{name="Bob"}]
 
        System.out.println("Sales team: " + salesTeam.size());
        // => Prints: 2 (Alice and Bob from department id=1)
    }
}
 
 

package com.example.demo.repository;                 // => Repository layer package
 
import com.example.demo.entity.Employee;             // => Import Employee entity
import com.example.demo.entity.Department;           // => Import Department entity
import org.springframework.data.jpa.repository.JpaRepository; // => Base repository interface
import java.util.List;                                // => Java List collection
 
public interface EmployeeRepository extends JpaRepository<Employee, Long> {
                                                      // => Repository for Employee entity (Long primary key)
                                                      // => Spring generates implementation at runtime
 
    // Find all employees in specific department
    List<Employee> findByDepartment(Department department);
    // => Spring derives query from method name: findBy + Department
    // => SQL: SELECT * FROM employees WHERE department_id = ?
    // => Parameter binding: ? = department.id (foreign key match)
    // => Returns List<Employee> (all employees in that department)
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.Department;
import com.example.demo.entity.Employee;
import com.example.demo.repository.DepartmentRepository;
import com.example.demo.repository.EmployeeRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
 
@Service
public class EmployeeRelationService {
    private final DepartmentRepository departmentRepository;
    private final EmployeeRepository employeeRepository;
 
    public EmployeeRelationService(DepartmentRepository departmentRepository,
                                   EmployeeRepository employeeRepository) {
        this.departmentRepository = departmentRepository;
        this.employeeRepository = employeeRepository;
    }
 
    @Transactional
    public void demonstrateManyToOne() {
        // Create department first
        Department engineering = new Department("Engineering");
        Department saved = departmentRepository.save(engineering);
// => Persists entity to database (INSERT if id=null, UPDATE if id exists)
// => Entity transitions from TRANSIENT to MANAGED state
// => Returns entity with database-assigned ID
        // => Persists entity to database (INSERT or UPDATE)
        // => Entity transitions to MANAGED state with assigned ID
        // => SQL: INSERT INTO departments (name) VALUES ('Engineering')
        // => Saved: {id=1, name="Engineering", employees=[]}
 
        // Create employees with department reference
        Employee alice = new Employee("Alice");
        alice.setDepartment(saved);
        employeeRepository.save(alice);
        // => SQL: INSERT INTO employees (name, department_id) VALUES ('Alice', 1)
 
        Employee bob = new Employee("Bob");
        bob.setDepartment(saved);
        employeeRepository.save(bob);
        // => SQL: INSERT INTO employees (name, department_id) VALUES ('Bob', 1)
 
        // Query by department object
        List<Employee> engineers = employeeRepository.findByDepartment(saved);
// => Spring derives SQL WHERE clause from method name
// => Returns List<Entity> or Optional<Entity> based on return type
        // => SQL: SELECT * FROM employees WHERE department_id = 1
        // => Result: [Employee{name="Alice"}, Employee{name="Bob"}]
 
        System.out.println("Engineers: " + engineers.size()); // => 2
 
        // Access department from employee
        Employee retrievedAlice = employeeRepository.findById(alice.getId()).get();
// => Executes SELECT by primary key
// => Returns Optional<Entity> (empty if not found)
// => Entity loaded into persistence context if found
        // => Queries database by primary key
        // => Returns Optional to handle missing records safely
        System.out.println("Alice's department: " + retrievedAlice.getDepartment().getName());
        // => SQL: SELECT * FROM employees WHERE id = 1
        // => SQL: SELECT * FROM departments WHERE id = 1 (lazy load)
        // => "Engineering"
    }
}
 
 

package com.example.demo.entity;                     // => JPA entity package
 
import jakarta.persistence.*;                         // => Jakarta Persistence API
import java.util.ArrayList;                           // => ArrayList implementation
import java.util.List;                                // => List interface
 
@Entity                                               // => Marks class as JPA entity (table mapping)
@Table(name = "departments")                          // => Maps to "departments" table
public class Department {
    @Id                                               // => Primary key field
    @GeneratedValue(strategy = GenerationType.IDENTITY)
                                                      // => Auto-increment (database-generated ID)
    private Long id;                                  // => Primary key type
 
    private String name;                              // => Department name (nullable by default)
 
    // CascadeType options:
    // PERSIST: save() cascades to employees
    // MERGE: update() cascades
    // REMOVE: delete() cascades
    // REFRESH: refresh() cascades
    // DETACH: detach() cascades
    // ALL: all of the above
    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL, orphanRemoval = true)
                                                      // => One-to-many relationship (inverse side)
                                                      // => mappedBy="department" references Employee.department field
                                                      // => cascade=ALL propagates all operations to employees
                                                      // => orphanRemoval=true deletes employees removed from collection
    private List<Employee> employees = new ArrayList<>();
                                                      // => Collection initialized to prevent NPE
 
    public Department() {}                            // => Default constructor REQUIRED by JPA
 
    public Department(String name) {                  // => Convenience constructor
        this.name = name;                             // => Sets department name
    }
 
    public void addEmployee(Employee employee) {
        employees.add(employee);                      // => Adds to collection (one side)
        employee.setDepartment(this);                 // => Sets back-reference (inverse side)
    }                                                 // => Maintains bidirectional consistency
 
    public void removeEmployee(Employee employee) {
        employees.remove(employee);                   // => Removes from collection
        employee.setDepartment(null);                 // => Clears back-reference
    }                                                 // => orphanRemoval=true triggers DELETE
 
    // Getters and setters
    public Long getId() { return id; }                // => Getter for primary key
    public void setId(Long id) { this.id = id; }      // => Setter for primary key
    public String getName() { return name; }          // => Getter for name
    public void setName(String name) { this.name = name; } // => Setter for name
    public List<Employee> getEmployees() { return employees; } // => Getter for employees
    public void setEmployees(List<Employee> employees) {
        this.employees = employees;                   // => Setter for employees
    }
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.Department;
import com.example.demo.entity.Employee;
import com.example.demo.repository.DepartmentRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class CascadeService {
    private final DepartmentRepository departmentRepository;
 
    public CascadeService(DepartmentRepository departmentRepository) {
        this.departmentRepository = departmentRepository;
    }
 
    @Transactional
    public void demonstrateCascade() {
        // CASCADE PERSIST: Save department saves employees too
        Department dept = new Department("Engineering");
        dept.addEmployee(new Employee("Alice"));
        dept.addEmployee(new Employee("Bob"));
 
        departmentRepository.save(dept);
        // => SQL: INSERT INTO departments (name) VALUES ('Engineering')
        // => SQL: INSERT INTO employees (name, department_id) VALUES ('Alice', 1)
        // => SQL: INSERT INTO employees (name, department_id) VALUES ('Bob', 1)
        // => All 3 entities saved with one repository call
 
        // CASCADE MERGE: Update department updates employees
        dept.setName("Engineering Team");
        dept.getEmployees().get(0).setName("Alice Smith");
        departmentRepository.save(dept);
        // => SQL: UPDATE departments SET name='Engineering Team' WHERE id=1
        // => SQL: UPDATE employees SET name='Alice Smith' WHERE id=1
        // => Changes cascaded to employees
 
        // ORPHAN REMOVAL: Remove employee from collection
        Employee bob = dept.getEmployees().get(1);
        dept.removeEmployee(bob);
        departmentRepository.save(dept);
        // => SQL: DELETE FROM employees WHERE id=2
        // => Bob deleted because removed from collection
 
        // CASCADE REMOVE: Delete department deletes employees
        departmentRepository.delete(dept);
// => Single DELETE operation (more efficient than deleteById)
// => Uses entity ID directly, no SELECT needed
        // => SQL: DELETE FROM employees WHERE department_id=1
        // => SQL: DELETE FROM departments WHERE id=1
        // => All employees deleted first, then department
 
        System.out.println("Cascade operations completed");
    }
}
 
 

package com.example.demo.entity;                     // => JPA entity package
 
import jakarta.persistence.*;                         // => Jakarta Persistence API
import java.util.ArrayList;                           // => ArrayList implementation
import java.util.List;                                // => List interface
 
@Entity                                               // => Marks class as JPA entity (table mapping)
@Table(name = "departments")                          // => Maps to "departments" table
public class Department {
    @Id                                               // => Primary key field
    @GeneratedValue(strategy = GenerationType.IDENTITY)
                                                      // => Auto-increment (database-generated ID)
    private Long id;                                  // => Primary key type
 
    private String name;                              // => Department name
 
    // LAZY: Default for @OneToMany - load only when accessed
    @OneToMany(mappedBy = "department", fetch = FetchType.LAZY)
                                                      // => One-to-many relationship (inverse side)
                                                      // => mappedBy="department" references Employee.department
                                                      // => fetch=LAZY delays loading until employees accessed
                                                      // => Initial SELECT only loads department (no employees)
                                                      // => Accessing employees triggers SELECT for employees
    private List<Employee> employees = new ArrayList<>();
                                                      // => Collection initialized to prevent NPE
 
    // EAGER alternative: Load immediately with department
    // @OneToMany(mappedBy = "department", fetch = FetchType.EAGER)
    //                                               // => fetch=EAGER loads employees immediately
    //                                               // => Initial SELECT uses JOIN to load both
    //                                               // => ⚠️ N+1 problem risk with multiple departments
    // private List<Employee> employees = new ArrayList<>();
 
    public Department() {}                            // => Default constructor REQUIRED by JPA
 
    public Department(String name) {                  // => Convenience constructor
        this.name = name;                             // => Sets department name
    }
 
    // Getters and setters
    public Long getId() { return id; }                // => Getter for primary key
    public void setId(Long id) { this.id = id; }      // => Setter for primary key
    public String getName() { return name; }          // => Getter for name
    public void setName(String name) { this.name = name; } // => Setter for name
    public List<Employee> getEmployees() { return employees; } // => Getter for employees
                                                      // => Triggers LAZY load if not yet loaded
    public void setEmployees(List<Employee> employees) {
        this.employees = employees;                   // => Setter for employees
    }
}
 
 

package com.example.demo.service;
 
import com.example.demo.entity.Department;
import com.example.demo.repository.DepartmentRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class FetchStrategyService {
    private final DepartmentRepository departmentRepository;
 
    public FetchStrategyService(DepartmentRepository departmentRepository) {
        this.departmentRepository = departmentRepository;
    }
 
    @Transactional
    public void demonstrateLazyLoading() {
        // Find department (LAZY loading)
        Department dept = departmentRepository.findById(1L).orElseThrow();
// => Executes SELECT by primary key
// => Returns Optional<Entity> (empty if not found)
// => Entity loaded into persistence context if found
        // => Queries database by primary key
        // => Returns Optional to handle missing records safely
        // => SQL: SELECT * FROM departments WHERE id = 1
        // => Employees NOT loaded yet
 
        System.out.println("Department: " + dept.getName()); // => No SQL
 
        // Access employees triggers lazy load
        int count = dept.getEmployees().size();
        // => SQL: SELECT * FROM employees WHERE department_id = 1
        // => NOW employees are loaded
 
        System.out.println("Employee count: " + count); // => 2
    }
 
    // MUST be @Transactional for lazy loading to work
    // Outside transaction, accessing lazy collection throws LazyInitializationException
    public void demonstrateLazyException() {
        Department dept = departmentRepository.findById(1L).orElseThrow();
// => Executes SELECT by primary key
// => Returns Optional<Entity> (empty if not found)
// => Entity loaded into persistence context if found
        // => Queries database by primary key
        // => Returns Optional to handle missing records safely
        // => Transaction ends here
 
        // FAILS: LazyInitializationException
        // dept.getEmployees().size(); // => ERROR: no session
    }
 
    @Transactional
    public void demonstrateEagerLoading() {
        // With FetchType.EAGER on Department.employees:
        Department dept = departmentRepository.findById(1L).orElseThrow();
// => Executes SELECT by primary key
// => Returns Optional<Entity> (empty if not found)
// => Entity loaded into persistence context if found
        // => Queries database by primary key
        // => Returns Optional to handle missing records safely
        // => SQL: SELECT d.*, e.* FROM departments d
        // =>      LEFT JOIN employees e ON d.id = e.department_id
        // =>      WHERE d.id = 1
        // => Employees loaded immediately (single JOIN query)
 
        int count = dept.getEmployees().size(); // => No additional SQL
        System.out.println("Employee count: " + count); // => 2
    }
}
 
 

package com.example.demo.entity;                     // => JPA entity package
 
import jakarta.persistence.*;                         // => Jakarta Persistence API
import java.util.ArrayList;                           // => ArrayList implementation
import java.util.List;                                // => List interface
 
@Entity                                               // => Marks class as JPA entity (table mapping)
@Table(name = "departments")                          // => Maps to "departments" table
public class Department {
    @Id                                               // => Primary key field
    @GeneratedValue(strategy = GenerationType.IDENTITY)
                                                      // => Auto-increment (database-generated ID)
    private Long id;                                  // => Primary key type
 
    private String name;                              // => Department name
 
    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL, orphanRemoval = true)
                                                      // => One-to-many relationship (inverse side)
                                                      // => mappedBy="department" references Employee.department
                                                      // => cascade=ALL propagates operations to employees
                                                      // => orphanRemoval=true deletes orphaned employees
    private List<Employee> employees = new ArrayList<>();
                                                      // => Collection initialized to prevent NPE
 
    public Department() {}                            // => Default constructor REQUIRED by JPA
 
    public Department(String name) {                  // => Convenience constructor
        this.name = name;                             // => Sets department name
    }
 
    // CORRECT: Sync both sides of bidirectional relationship
    public void addEmployee(Employee employee) {
        employees.add(employee);                      // => Adds to collection (one side)
        employee.setDepartment(this);                 // => Sets back-reference (inverse side)
    }                                                 // => CRITICAL: Both sides must be synchronized
 
    public void removeEmployee(Employee employee) {
        employees.remove(employee);                   // => Removes from collection
        employee.setDepartment(null);                 // => Clears back-reference
    }                                                 // => orphanRemoval=true triggers DELETE
 
    // WRONG PATTERN: Only sets one side (causes data inconsistency)
    // public void addEmployeeWrong(Employee employee) {
    //     employees.add(employee);                  // => Only adds to collection
    //                                               // => Missing: employee.setDepartment(this)
    //                                               // => ⚠️ Employee's department_id remains NULL
    // }
 
    // Getters and setters
    public Long getId() { return id; }                // => Getter for primary key
    public void setId(Long id) { this.id = id; }      // => Setter for primary key
    public String getName() { return name; }          // => Getter for name
    public void setName(String name) { this.name = name; } // => Setter for name
    public List<Employee> getEmployees() { return employees; } // => Getter for employees
    public void setEmployees(List<Employee> employees) {
        this.employees = employees;                   // => Setter for employees
    }
}
 
 

package com.example.demo.entity;                     // => JPA entity package
 
import jakarta.persistence.*;                         // => Jakarta Persistence API
 
@Entity                                               // => Marks class as JPA entity (table mapping)
@Table(name = "employees")                            // => Maps to "employees" table
public class Employee {
    @Id                                               // => Primary key field
    @GeneratedValue(strategy = GenerationType.IDENTITY)
                                                      // => Auto-increment (database-generated ID)
    private Long id;                                  // => Primary key type
 
    private String name;                              // => Employee name
 
    @ManyToOne                                        // => Many-to-one relationship (owning side)
                                                      // => This side owns the foreign key
    @JoinColumn(name = "department_id")               // => Foreign key column name
                                                      // => Creates department_id column in employees table
                                                      // => References departments.id (implicit)
    private Department department;                    // => Department reference (can be null)
 
    public Employee() {}                              // => Default constructor REQUIRED by JPA
 
    public Employee(String name) {                    // => Convenience constructor
        this.name = name;                             // => Sets employee name
    }                                                 // => department remains null (set via setter)
 
    // Defensive setter: automatically syncs both sides of relationship
    public void setDepartment(Department department) {
        if (this.department != null) {
            this.department.getEmployees().remove(this);
                                                      // => Removes from old department's collection
                                                      // => Prevents duplicate references
        }
        this.department = department;                 // => Sets new department reference (or null)
        if (department != null && !department.getEmployees().contains(this)) {
            department.getEmployees().add(this);      // => Adds to new department's collection
                                                      // => Maintains bidirectional consistency
        }
    }                                                 // => Alternative to manual add/remove helpers
 
    // Getters and setters
    public Long getId() { return id; }                // => Getter for primary key
    public void setId(Long id) { this.id = id; }      // => Setter for primary key
    public String getName() { return name; }          // => Getter for name
    public void setName(String name) { this.name = name; } // => Setter for name
    public Department getDepartment() { return department; } // => Getter for department
}
 
 

package com.example.demo.service;           // => Service layer package
 
import com.example.demo.entity.Department;   // => Department entity
import com.example.demo.entity.Employee;     // => Employee entity
import com.example.demo.repository.DepartmentRepository;  // => Department persistence
import org.springframework.stereotype.Service;            // => Spring service stereotype
import org.springframework.transaction.annotation.Transactional; // => Transaction management
 
@Service                                      // => Spring service bean (auto-detected)
public class BidirectionalSyncService {
    private final DepartmentRepository departmentRepository;  // => Injected repository
 
    public BidirectionalSyncService(DepartmentRepository departmentRepository) {
        this.departmentRepository = departmentRepository;  // => Constructor injection
    }
 
    @Transactional                            // => Single transaction for all operations
    public void demonstrateSynchronization() {
        Department engineering = new Department("Engineering");  // => TRANSIENT, id=null
 
        // CORRECT: Use helper method
        Employee alice = new Employee("Alice");          // => TRANSIENT employee
        engineering.addEmployee(alice);
        // => engineering.employees = [alice]
        // => alice.department = engineering
        // => Both sides synchronized (helper method sets both)
 
        // WRONG: Direct list manipulation
        Employee bob = new Employee("Bob");              // => TRANSIENT employee
        engineering.getEmployees().add(bob);             // => Only updates one side!
        // => engineering.employees = [alice, bob]
        // => bob.department = null (INCONSISTENT!)
 
        departmentRepository.save(engineering);
        // => SQL: INSERT INTO departments (name) VALUES ('Engineering')
        // => SQL: INSERT INTO employees (name, department_id) VALUES ('Alice', 1)
        // => SQL: INSERT INTO employees (name, department_id) VALUES ('Bob', NULL)
        // => Bob's department_id is NULL because relationship not synced!
 
        System.out.println("Alice's dept: " + alice.getDepartment().getName()); // => Engineering
        System.out.println("Bob's dept: " + bob.getDepartment()); // => null (BUG!)
    }
}
 
 

package com.example.demo.entity;                               // => Entity class package
 
import jakarta.persistence.*;                                  // => Imports all JPA annotations
 
@Entity
// => Marks class as JPA entity (database table mapping)
@Table(name = "employees")
// => Maps to "employees" table in database
public class Employee {
    @Id
    // => Primary key field
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    // => Auto-increment strategy (database assigns ID)
    private Long id;                                           // => Primary key (null for new entities)
 
    private String name;                                       // => VARCHAR(255) column (nullable by default)
 
    @ManyToOne                                                 // => Many employees can belong to one department
    // => Defines entity relationship for foreign key mapping
    @JoinColumn(
        name = "dept_id",              // Custom column name (default: department_id)
        nullable = false,              // NOT NULL constraint
        foreignKey = @ForeignKey(name = "fk_employee_department")  // FK constraint name
    )
    private Department department;                             // => Reference to owning Department entity
 
    public Employee() {}                                       // => No-arg constructor required by JPA
    public Employee(String name) {                             // => Convenience constructor
        this.name = name;                                      // => Sets name; department set separately
    }
 
    // Getters and setters
    public Long getId() { return id; }                         // => Returns primary key
    public void setId(Long id) { this.id = id; }               // => Normally set by JPA, not application
    public String getName() { return name; }                   // => Returns employee name
    public void setName(String name) { this.name = name; }     // => Updates name in managed entity
    public Department getDepartment() { return department; }   // => Returns associated Department
    public void setDepartment(Department department) { this.department = department; } // => Sets FK relationship
}
 
 

package com.example.demo.service;                              // => Service layer package
 
import com.example.demo.entity.Department;                     // => Department entity for relationship
import com.example.demo.entity.Employee;                       // => Employee entity being demonstrated
import com.example.demo.repository.DepartmentRepository;       // => Repository for Department persistence
import com.example.demo.repository.EmployeeRepository;         // => Repository for Employee persistence
import org.springframework.stereotype.Service;                 // => Marks as Spring service bean
import org.springframework.transaction.annotation.Transactional; // => Declarative transaction management
 
@Service                                                       // => Spring component (auto-detected by scan)
public class JoinColumnService {
    private final DepartmentRepository departmentRepository;   // => Injected via constructor
    private final EmployeeRepository employeeRepository;       // => Injected via constructor
 
    public JoinColumnService(DepartmentRepository departmentRepository,
                             EmployeeRepository employeeRepository) {
        this.departmentRepository = departmentRepository;      // => Constructor injection (recommended over @Autowired)
        this.employeeRepository = employeeRepository;
    }
 
    @Transactional                                             // => All operations in single transaction
    public void demonstrateJoinColumn() {
        Department dept = departmentRepository.save(new Department("Engineering"));
// => Persists entity to database (INSERT if id=null, UPDATE if id exists)
// => Entity transitions from TRANSIENT to MANAGED state
// => Returns entity with database-assigned ID
 
        // Create employee with custom FK column
        Employee alice = new Employee("Alice");                // => TRANSIENT entity, no DB row yet
        alice.setDepartment(dept);                             // => Sets the FK relationship
        employeeRepository.save(alice);
        // => SQL: INSERT INTO employees (name, dept_id) VALUES ('Alice', 1)
        // => Uses custom column name "dept_id" instead of "department_id"
 
        // Try to save employee without department (nullable=false)
        try {
            Employee orphan = new Employee("Orphan");          // => Employee without department (FK will be null)
            // orphan.department is null
            employeeRepository.save(orphan);
            // => SQL fails: NOT NULL constraint violation on dept_id
        } catch (Exception e) {
            System.out.println("Error: Department required (NOT NULL constraint)"); // => nullable=false enforced
        }
 
        // Generated schema:
        // CREATE TABLE employees (
        //   id BIGINT AUTO_INCREMENT PRIMARY KEY,
        //   name VARCHAR(255),
        //   dept_id BIGINT NOT NULL,
        //   CONSTRAINT fk_employee_department FOREIGN KEY (dept_id)
        //     REFERENCES departments(id)
        // );
    }
}