JPA 설정하고 사용하기

@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "username", nullable = false, unique = true)
    private String username;
    
    @Column(name = "email", nullable = false)
    private String email;
    
    @Column(name = "created_at")
    @Temporal(TemporalType.TIMESTAMP)
    private Date createdAt;
    
    // 기본 생성자 (필수)
    protected User() {}
    
    // 생성자
    public User(String username, String email) {
        this.username = username;
        this.email = email;
        this.createdAt = new Date();
    }
    
    // getter, setter methods
    // ...
}

// IDENTITY 전략 (MySQL AUTO_INCREMENT)
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

// SEQUENCE 전략 (PostgreSQL, Oracle)
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_seq")
@SequenceGenerator(name = "user_seq", sequenceName = "user_sequence")
private Long id;

// TABLE 전략 (모든 database 지원)
@Id
@GeneratedValue(strategy = GenerationType.TABLE, generator = "user_gen")
@TableGenerator(name = "user_gen", table = "id_generator", 
                pkColumnName = "gen_name", valueColumnName = "gen_val")
private Long id;

// @EmbeddedId 방식
@Embeddable
public class OrderItemId implements Serializable {
    private Long orderId;
    private Long productId;
    
    // 기본 생성자, equals, hashCode 필수
}

@Entity
public class OrderItem {
    @EmbeddedId
    private OrderItemId id;
    
    private Integer quantity;
    private BigDecimal price;
}

// @IdClass 방식
@Entity
@IdClass(OrderItemId.class)
public class OrderItem {
    @Id
    private Long orderId;
    
    @Id
    private Long productId;
    
    private Integer quantity;
    private BigDecimal price;
}

// 자동 mapping (firstName -> first_name)
private String firstName;

// 명시적 mapping
@Column(name = "last_name", nullable = false, length = 50)
private String lastName;

// unique constraint
@Column(unique = true)
private String email;

// default value (database level)
@Column(columnDefinition = "varchar(255) default 'ACTIVE'")
private String status;

// 날짜/시간 mapping
@Temporal(TemporalType.DATE)
private Date birthDate;

@Temporal(TemporalType.TIMESTAMP)
private Date createdAt;

// Java 8 time API (JPA 2.2+)
private LocalDate birthDate;
private LocalDateTime createdAt;

// Enum mapping
@Enumerated(EnumType.STRING)  // 권장: enum name 저장
private UserStatus status;

@Enumerated(EnumType.ORDINAL)  // 주의: enum 순서 변경 시 문제 발생
private UserType type;

// Large Object mapping
@Lob
private String description;  // CLOB

@Lob
private byte[] profileImage;  // BLOB

@Transient
private String temporaryData;

// 계산된 property
@Transient
public String getFullName() {
    return firstName + " " + lastName;
}

// static field는 자동으로 transient
private static final String CONSTANT_VALUE = "CONSTANT";

// 단방향 OneToOne
@Entity
public class User {
    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "profile_id")
    private UserProfile profile;
}

// 양방향 OneToOne
@Entity
public class UserProfile {
    @Id
    private Long id;
    
    @OneToOne(mappedBy = "profile")
    private User user;
}

@Entity
public class Order {
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, 
               orphanRemoval = true, fetch = FetchType.LAZY)
    private List<OrderItem> orderItems = new ArrayList<>();
    
    // convenience method
    public void addOrderItem(OrderItem item) {
        orderItems.add(item);
        item.setOrder(this);
    }
    
    public void removeOrderItem(OrderItem item) {
        orderItems.remove(item);
        item.setOrder(null);
    }
}

@Entity
public class OrderItem {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "order_id")
    private Order order;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "product_id")
    private Product product;
}

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

@Entity
public class Course {
    @ManyToMany(mappedBy = "courses")
    private Set<Student> students = new HashSet<>();
}

public class JPAUtil {
    private static final EntityManagerFactory emf;
    
    static {
        try {
            emf = Persistence.createEntityManagerFactory("myPersistenceUnit");
        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }
    
    public static EntityManagerFactory getEntityManagerFactory() {
        return emf;
    }
    
    public static EntityManager getEntityManager() {
        return emf.createEntityManager();
    }
    
    public static void close() {
        if (emf != null) {
            emf.close();
        }
    }
}

// 기본 사용 방식
EntityManager em = JPAUtil.getEntityManager();
try {
    // database 작업 수행
} finally {
    em.close();
}

// try-with-resources 사용 (EntityManager가 AutoCloseable 구현)
try (EntityManager em = JPAUtil.getEntityManager()) {
    // database 작업 수행
}

try (EntityManager em = JPAUtil.getEntityManager()) {
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    
    try {
        User user = new User("john_doe", "john@example.com");
        em.persist(user);  // Persistent 상태로 전환
        
        tx.commit();  // 실제 INSERT SQL 실행
    } catch (Exception e) {
        tx.rollback();
        throw e;
    }
}

try (EntityManager em = JPAUtil.getEntityManager()) {
    // Primary key로 조회
    User user = em.find(User.class, 1L);
    if (user != null) {
        System.out.println(user.getUsername());
    }
    
    // JPQL로 조회
    List<User> users = em.createQuery(
        "SELECT u FROM User u WHERE u.email LIKE :domain", User.class)
        .setParameter("domain", "%@example.com")
        .getResultList();
    
    // 단일 결과 조회
    User singleUser = em.createQuery(
        "SELECT u FROM User u WHERE u.username = :username", User.class)
        .setParameter("username", "john_doe")
        .getSingleResult();
}

try (EntityManager em = JPAUtil.getEntityManager()) {
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    
    try {
        User user = em.find(User.class, 1L);
        user.setEmail("newemail@example.com");  // dirty checking으로 자동 UPDATE
        
        tx.commit();  // UPDATE SQL 실행
    } catch (Exception e) {
        tx.rollback();
        throw e;
    }
}

try (EntityManager em = JPAUtil.getEntityManager()) {
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    
    try {
        User user = em.find(User.class, 1L);
        if (user != null) {
            em.remove(user);  // Removed 상태로 전환
        }
        
        tx.commit();  // DELETE SQL 실행
    } catch (Exception e) {
        tx.rollback();
        throw e;
    }
}

EntityManager em = JPAUtil.getEntityManager();
EntityTransaction tx = em.getTransaction();

try {
    tx.begin();
    
    // business logic
    User user = new User("alice", "alice@example.com");
    em.persist(user);
    
    // 다른 작업들도 같은 transaction 내에서 수행
    Order order = new Order(user);
    em.persist(order);
    
    tx.commit();
} catch (Exception e) {
    if (tx.isActive()) {
        tx.rollback();
    }
    throw e;
} finally {
    em.close();
}

public class TransactionTemplate {
    
    public static <T> T execute(Function<EntityManager, T> operation) {
        EntityManager em = JPAUtil.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        
        try {
            tx.begin();
            T result = operation.apply(em);
            tx.commit();
            return result;
        } catch (Exception e) {
            if (tx.isActive()) {
                tx.rollback();
            }
            throw new RuntimeException(e);
        } finally {
            em.close();
        }
    }
    
    public static void execute(Consumer<EntityManager> operation) {
        execute(em -> {
            operation.accept(em);
            return null;
        });
    }
}

// 사용 예제
TransactionTemplate.execute(em -> {
    User user = new User("bob", "bob@example.com");
    em.persist(user);
});

User foundUser = TransactionTemplate.execute(em -> 
    em.find(User.class, 1L)
);

try (EntityManager em = JPAUtil.getEntityManager()) {
    // 기본 SELECT query
    List<User> users = em.createQuery(
        "SELECT u FROM User u WHERE u.createdAt > :date", User.class)
        .setParameter("date", lastWeek)
        .getResultList();
    
    // JOIN query
    List<User> activeUsers = em.createQuery(
        "SELECT DISTINCT u FROM User u " +
        "JOIN u.orders o " +
        "WHERE o.status = :status", User.class)
        .setParameter("status", OrderStatus.ACTIVE)
        .getResultList();
    
    // Aggregate function
    Long userCount = em.createQuery(
        "SELECT COUNT(u) FROM User u WHERE u.email LIKE :domain", Long.class)
        .setParameter("domain", "%@company.com")
        .getSingleResult();
}

@Entity
@NamedQueries({
    @NamedQuery(
        name = "User.findByEmail",
        query = "SELECT u FROM User u WHERE u.email = :email"
    ),
    @NamedQuery(
        name = "User.findActiveUsers",
        query = "SELECT u FROM User u WHERE u.status = 'ACTIVE' ORDER BY u.createdAt DESC"
    )
})
public class User {
    // entity fields...
}

// named query 사용
User user = em.createNamedQuery("User.findByEmail", User.class)
    .setParameter("email", "john@example.com")
    .getSingleResult();

List<User> activeUsers = em.createNamedQuery("User.findActiveUsers", User.class)
    .getResultList();

// Native SQL query
List<User> users = em.createNativeQuery(
    "SELECT * FROM users WHERE created_at > DATE_SUB(NOW(), INTERVAL 7 DAY)", 
    User.class)
    .getResultList();

// Scalar 결과 조회
List<Object[]> results = em.createNativeQuery(
    "SELECT u.username, COUNT(o.id) as order_count " +
    "FROM users u LEFT JOIN orders o ON u.id = o.user_id " +
    "GROUP BY u.id, u.username")
    .getResultList();

for (Object[] row : results) {
    String username = (String) row[0];
    BigInteger orderCount = (BigInteger) row[1];
    System.out.println(username + ": " + orderCount + " orders");
}

public abstract class GenericDAO<T, ID> {
    
    protected final Class<T> entityClass;
    
    @SuppressWarnings("unchecked")
    protected GenericDAO() {
        this.entityClass = (Class<T>) ((ParameterizedType) getClass()
            .getGenericSuperclass()).getActualTypeArguments()[0];
    }
    
    protected EntityManager getEntityManager() {
        return JPAUtil.getEntityManager();
    }
    
    public void save(T entity) {
        TransactionTemplate.execute(em -> em.persist(entity));
    }
    
    public T findById(ID id) {
        try (EntityManager em = getEntityManager()) {
            return em.find(entityClass, id);
        }
    }
    
    public List<T> findAll() {
        try (EntityManager em = getEntityManager()) {
            return em.createQuery("SELECT e FROM " + entityClass.getSimpleName() + " e", entityClass)
                    .getResultList();
        }
    }
    
    public T update(T entity) {
        return TransactionTemplate.execute(em -> em.merge(entity));
    }
    
    public void delete(T entity) {
        TransactionTemplate.execute(em -> {
            T managedEntity = em.merge(entity);
            em.remove(managedEntity);
        });
    }
    
    public void deleteById(ID id) {
        TransactionTemplate.execute(em -> {
            T entity = em.find(entityClass, id);
            if (entity != null) {
                em.remove(entity);
            }
        });
    }
    
    public long count() {
        try (EntityManager em = getEntityManager()) {
            return em.createQuery("SELECT COUNT(e) FROM " + entityClass.getSimpleName() + " e", Long.class)
                    .getSingleResult();
        }
    }
}

public class UserDAO extends GenericDAO<User, Long> {
    
    public Optional<User> findByUsername(String username) {
        try (EntityManager em = getEntityManager()) {
            List<User> users = em.createQuery(
                "SELECT u FROM User u WHERE u.username = :username", User.class)
                .setParameter("username", username)
                .getResultList();
            
            return users.isEmpty() ? Optional.empty() : Optional.of(users.get(0));
        }
    }
    
    public Optional<User> findByEmail(String email) {
        try (EntityManager em = getEntityManager()) {
            try {
                User user = em.createNamedQuery("User.findByEmail", User.class)
                    .setParameter("email", email)
                    .getSingleResult();
                return Optional.of(user);
            } catch (NoResultException e) {
                return Optional.empty();
            }
        }
    }
    
    public List<User> findUsersByDateRange(Date startDate, Date endDate) {
        try (EntityManager em = getEntityManager()) {
            return em.createQuery(
                "SELECT u FROM User u WHERE u.createdAt BETWEEN :start AND :end " +
                "ORDER BY u.createdAt DESC", User.class)
                .setParameter("start", startDate)
                .setParameter("end", endDate)
                .getResultList();
        }
    }
    
    public List<User> findUsersWithOrders() {
        try (EntityManager em = getEntityManager()) {
            return em.createQuery(
                "SELECT DISTINCT u FROM User u " +
                "JOIN FETCH u.orders o " +
                "ORDER BY u.username", User.class)
                .getResultList();
        }
    }
    
    public long countActiveUsers() {
        try (EntityManager em = getEntityManager()) {
            return em.createQuery(
                "SELECT COUNT(u) FROM User u WHERE u.status = :status", Long.class)
                .setParameter("status", UserStatus.ACTIVE)
                .getSingleResult();
        }
    }
    
    public List<User> findUsersPaginated(int page, int size) {
        try (EntityManager em = getEntityManager()) {
            return em.createQuery("SELECT u FROM User u ORDER BY u.id", User.class)
                .setFirstResult(page * size)
                .setMaxResults(size)
                .getResultList();
        }
    }
}

public class UserService {
    
    private final UserDAO userDAO;
    private final OrderDAO orderDAO;
    
    public UserService() {
        this.userDAO = new UserDAO();
        this.orderDAO = new OrderDAO();
    }
    
    public User registerUser(String username, String email) {
        // Business validation
        if (userDAO.findByUsername(username).isPresent()) {
            throw new IllegalArgumentException("Username already exists: " + username);
        }
        
        if (userDAO.findByEmail(email).isPresent()) {
            throw new IllegalArgumentException("Email already exists: " + email);
        }
        
        // Create and save user
        User user = new User(username, email);
        userDAO.save(user);
        
        return user;
    }
    
    public User updateUserEmail(Long userId, String newEmail) {
        return TransactionTemplate.execute(em -> {
            User user = userDAO.findById(userId);
            if (user == null) {
                throw new EntityNotFoundException("User not found: " + userId);
            }
            
            // Business validation
            Optional<User> existingUser = userDAO.findByEmail(newEmail);
            if (existingUser.isPresent() && !existingUser.get().getId().equals(userId)) {
                throw new IllegalArgumentException("Email already in use: " + newEmail);
            }
            
            user.setEmail(newEmail);
            return userDAO.update(user);
        });
    }
    
    public void deleteUserWithOrders(Long userId) {
        TransactionTemplate.execute(em -> {
            User user = userDAO.findById(userId);
            if (user == null) {
                throw new EntityNotFoundException("User not found: " + userId);
            }
            
            // Business logic: delete all orders first
            List<Order> userOrders = orderDAO.findByUserId(userId);
            for (Order order : userOrders) {
                orderDAO.delete(order);
            }
            
            // Then delete user
            userDAO.delete(user);
        });
    }
    
    public UserStatistics getUserStatistics(Long userId) {
        User user = userDAO.findById(userId);
        if (user == null) {
            throw new EntityNotFoundException("User not found: " + userId);
        }
        
        long orderCount = orderDAO.countByUserId(userId);
        BigDecimal totalAmount = orderDAO.getTotalAmountByUserId(userId);
        
        return new UserStatistics(user, orderCount, totalAmount);
    }
}