Spring Framework의 JPA를 위한 기능들 (Spring Data JPA)

public interface UserRepository extends JpaRepository<User, Long> {
    // 기본 CRUD 메서드들이 자동 제공됨
    // save(), findById(), findAll(), delete() 등
}

@Service
@Transactional
public class UserService {
    private final UserRepository userRepository;
    
    public User createUser(User user) {
        return userRepository.save(user);
    }
    
    public Page<User> findAllUsers(int page, int size) {
        Pageable pageable = PageRequest.of(page, size, 
            Sort.by("createdAt").descending());
        return userRepository.findAll(pageable);
    }
}

public interface UserRepository extends JpaRepository<User, Long> {
    // 단일 조건 검색
    Optional<User> findByUsername(String username);
    Optional<User> findByEmail(String email);
    
    // 복합 조건 검색
    List<User> findByUsernameAndEmail(String username, String email);
    List<User> findByUsernameOrEmail(String username, String email);
    
    // 비교 연산자
    List<User> findByAgeGreaterThan(int age);
    List<User> findByAgeBetween(int startAge, int endAge);
    
    // 문자열 검색
    List<User> findByUsernameContaining(String keyword);
    List<User> findByUsernameStartingWith(String prefix);
    
    // 정렬과 제한
    List<User> findTop10ByActiveOrderByCreatedAtDesc(boolean active);
    
    // 존재 여부 확인
    boolean existsByUsername(String username);
    long countByActive(boolean active);
}

public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT u FROM User u WHERE u.username = :username AND u.active = :active")
    Optional<User> findByUsernameAndActive(@Param("username") String username, 
                                          @Param("active") boolean active);
    
    @Query("SELECT DISTINCT u FROM User u " +
           "JOIN FETCH u.orders o " +
           "WHERE o.status = :status")
    List<User> findUsersWithOrdersByStatus(@Param("status") OrderStatus status);
    
    @Query(value = "SELECT * FROM users u WHERE u.created_at > DATE_SUB(NOW(), INTERVAL ?1 DAY)", 
           nativeQuery = true)
    List<User> findUsersCreatedInLastDays(int days);
}

@Modifying
@Query("UPDATE User u SET u.active = :active WHERE u.lastLogin < :date")
int updateInactiveUsers(@Param("active") boolean active, @Param("date") LocalDateTime date);

@Modifying
@Query("DELETE FROM User u WHERE u.active = false AND u.createdAt < :date")
int deleteInactiveOldUsers(@Param("date") LocalDateTime date);

@Service
@Transactional(readOnly = true) // class level: 기본적으로 read-only
public class UserService {
    private final UserRepository userRepository;
    
    // Read-only method (class level 설정 사용)
    public Optional<User> findById(Long id) {
        return userRepository.findById(id);
    }
    
    // Write method (method level에서 readOnly override)
    @Transactional
    public User createUser(User user) {
        validateUser(user);
        return userRepository.save(user);
    }
    
    @Transactional(rollbackFor = {BusinessException.class})
    public void processUserData(List<User> users) throws BusinessException {
        for (User user : users) {
            validateUser(user);
            userRepository.save(user);
        }
    }
}

@Service
@Transactional
public class OrderProcessingService {
    
    // 기본 REQUIRED propagation
    public void processOrder(OrderRequest request) {
        Order order = orderService.createOrder(request);
        processPayment(order);
        updateInventory(order);
    }
    
    // REQUIRES_NEW: 독립적인 transaction
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void logAuditEvent(String event, String details) {
        // 메인 transaction과 별개로 실행
        auditService.createAuditLog(event, details);
    }
}

@Service
@Transactional(readOnly = true)
public class UserQueryService {
    
    public UserDetailDto getUserDetails(Long userId) {
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException("User not found"));
        
        // 같은 transaction 내에서 일관된 데이터 조회
        List<Order> orders = orderRepository.findByUserId(userId);
        long orderCount = orderRepository.countByUserId(userId);
        
        return UserDetailDto.builder()
            .user(user)
            .orders(orders)
            .orderCount(orderCount)
            .build();
    }
}

// Mapping: JPA Exception -> Spring Exception
// EntityNotFoundException -> EmptyResultDataAccessException
// OptimisticLockException -> ObjectOptimisticLockingFailureException
// ConstraintViolationException -> DataIntegrityViolationException

@Service
@Transactional
public class UserService {
    
    public User findUserByUsername(String username) {
        try {
            return userRepository.findByUsername(username);
        } catch (EmptyResultDataAccessException e) {
            throw new UserNotFoundException("User not found: " + username);
        }
    }
}

@ControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(EntityNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public ErrorResponse handleEntityNotFound(EntityNotFoundException e) {
        return ErrorResponse.builder()
            .error("ENTITY_NOT_FOUND")
            .message(e.getMessage())
            .timestamp(LocalDateTime.now())
            .build();
    }
    
    @ExceptionHandler(DataIntegrityViolationException.class)
    @ResponseStatus(HttpStatus.CONFLICT)
    public ErrorResponse handleDataIntegrityViolation(DataIntegrityViolationException e) {
        String message = "Data integrity constraint violation";
        if (e.getCause() instanceof ConstraintViolationException) {
            message = parseConstraintViolation((ConstraintViolationException) e.getCause());
        }
        
        return ErrorResponse.builder()
            .error("DATA_INTEGRITY_VIOLATION")
            .message(message)
            .timestamp(LocalDateTime.now())
            .build();
    }
}

@DataJpaTest
class UserRepositoryTest {
    
    @Autowired
    private TestEntityManager testEntityManager;
    
    @Autowired
    private UserRepository userRepository;
    
    @Test
    void findByUsername_shouldReturnUser_whenUserExists() {
        // Given
        User user = User.builder()
            .username("john_doe")
            .email("john@example.com")
            .active(true)
            .build();
        
        testEntityManager.persistAndFlush(user);
        
        // When
        Optional<User> found = userRepository.findByUsername("john_doe");
        
        // Then
        assertThat(found).isPresent();
        assertThat(found.get().getEmail()).isEqualTo("john@example.com");
    }
    
    @Test
    void findByActiveTrue_shouldReturnOnlyActiveUsers() {
        // Given
        testEntityManager.persist(createUser("active_user", true));
        testEntityManager.persist(createUser("inactive_user", false));
        testEntityManager.flush();
        
        // When
        List<User> activeUsers = userRepository.findByActive(true);
        
        // Then
        assertThat(activeUsers).hasSize(1);
        assertThat(activeUsers.get(0).getUsername()).isEqualTo("active_user");
    }
    
    private User createUser(String username, boolean active) {
        return User.builder()
            .username(username)
            .email(username + "@example.com")
            .active(active)
            .build();
    }
}

public interface UserRepository extends JpaRepository<User, Long> {
    
    @Query("SELECT DISTINCT u FROM User u JOIN FETCH u.orders WHERE u.active = true")
    List<User> findActiveUsersWithOrders();
    
    @EntityGraph(attributePaths = {"orders", "profile"})
    List<User> findByActive(boolean active);
}

@Service
@Transactional
public class BatchUserService {
    
    @Modifying
    @Query("UPDATE User u SET u.status = :newStatus WHERE u.lastLogin < :cutoffDate")
    int updateInactiveUsers(@Param("newStatus") UserStatus newStatus, 
                           @Param("cutoffDate") LocalDateTime cutoffDate);
    
    public void processBatchUsers(int batchSize) {
        int page = 0;
        Page<User> userPage;
        
        do {
            Pageable pageable = PageRequest.of(page, batchSize);
            userPage = userRepository.findByActive(false, pageable);
            
            userPage.getContent().forEach(this::processUser);
            page++;
            
        } while (userPage.hasNext());
    }
}