JDBC 소개 (Java Database Connectivity)
**JDBC(Java Database Connectivity)**는 자바에서 데이터베이스와 상호작용하기 위한 표준 API입니다. JDBC를 통해 자바 애플리케이션은 데이터베이스에 SQL 쿼리를 실행하고, 데이터를 가져오고, 업데이트하는 등의 작업을 할 수 있습니다. 이 API는 데이터베이스의 세부 사항에 대해 걱정할 필요 없이 다양한 DB 시스템과의 연결을 쉽게 처리할 수 있도록 도와줍니다.
JDBC의 주요 개념과 구성 요소
1. JDBC 드라이버:
JDBC 드라이버는 자바 애플리케이션과 데이터베이스 사이에서 번역기 역할을 합니다. 자바의 API 호출을 데이터베이스가 이해할 수 있는 명령으로 변환합니다. JDBC 드라이버는 네 가지 유형이 있습니다:
• Type 1: JDBC-ODBC 브리지 드라이버 (거의 사용되지 않음).
• Type 2: 네이티브-API 드라이버, 일부 자바로 작성됨.
• Type 3: 네트워크 프로토콜 드라이버, 중간 서버와 통신.
• Type 4: 자바로 완전히 작성된 “Thin” 드라이버로, 데이터베이스에 직접 연결합니다.
2. JDBC 아키텍처:
JDBC의 구조는 간단합니다:
• DriverManager: 여러 데이터베이스 드라이버를 관리하며, 데이터베이스 연결을 설정합니다.
• Connection: 데이터베이스와의 연결을 나타내며, SQL 문을 생성하는 데 사용됩니다.
• Statement: SQL 쿼리를 실행하는 객체입니다. 대표적으로 Statement, PreparedStatement, CallableStatement가 있습니다.
• ResultSet: SQL 쿼리의 결과를 저장하는 객체입니다.
• SQLException: 데이터베이스 작업 중 발생하는 오류를 처리합니다.
3. JDBC 사용의 핵심 단계:
JDBC를 이용한 기본적인 데이터베이스 작업은 다음과 같이 이루어집니다:
• 드라이버 로드: 데이터베이스에 연결하기 전에 JDBC 드라이버를 로드해야 합니다.
Class.forName("com.mysql.cj.jdbc.Driver");
• SQL 쿼리 실행: Statement 또는 PreparedStatement를 사용하여 SQL 쿼리를 실행할 수 있습니다.
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users");
• 결과 처리: ResultSet을 통해 SQL 쿼리의 결과를 처리할 수 있습니다.
while (rs.next()) {
String name = rs.getString("name");
System.out.println(name);
}
• 리소스 닫기: 작업이 끝나면 반드시 연결을 종료하여 리소스를 해제합니다.
rs.close();
stmt.close();
conn.close();
다음은 JDBC 사용 시 알아야 할 핵심 사항들이야:
1. Connection:
• 데이터베이스에 연결하기 위해 Connection 객체를 생성해야 해.
• JDBC는 DriverManager를 통해 데이터베이스 연결을 관리하는데, URL, 사용자명, 비밀번호를 사용해 연결할 수 있어.
Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "password");
2. Statement:
• Statement는 SQL 쿼리를 실행할 때 사용하는 객체야. Statement 또는 PreparedStatement를 사용해 SQL을 실행할 수 있어.
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("SELECT * FROM users");
3. ResultSet:
• SQL 쿼리의 결과를 ResultSet 객체로 받아서 처리할 수 있어. 데이터를 순차적으로 탐색하며 각 열에 접근할 수 있어.
while (resultSet.next()) {
String name = resultSet.getString("name");
}
4. Transaction Management:
• JDBC는 기본적으로 자동 커밋 모드를 사용하지만, 직접 트랜잭션을 관리하려면 자동 커밋을 끄고 수동으로 커밋/롤백할 수 있어.
connection.setAutoCommit(false); // 자동 커밋 끄기
connection.commit(); // 트랜잭션 커밋
connection.rollback(); // 오류 시 롤백
5. PreparedStatement:
• 동적 파라미터가 포함된 SQL을 작성할 때는 PreparedStatement를 사용해 SQL 인젝션을 방지할 수 있어.
• 동적 파라미터 바인딩을 통해 성능 최적화와 보안을 향상할 수 있어.
PreparedStatement ps = connection.prepareStatement("INSERT INTO users (name, age) VALUES (?, ?)");
ps.setString(1, "John");
ps.setInt(2, 30);
ps.executeUpdate();
6. Exception Handling:
• JDBC 사용 중 발생할 수 있는 예외는 SQLException을 통해 처리해야 해. 특히 데이터베이스 연결이 실패할 때나 SQL 구문 오류가 발생할 때 예외 처리가 필요해.
try {
// JDBC logic
} catch (SQLException e) {
e.printStackTrace();
} finally {
connection.close(); // 연결 종료
}
이런 사항을 알고 있다면 기본적인 JDBC 활용에는 큰 문제가 없을 거야. 그러나 실무에서는 Connection Pooling, 트랜잭션 관리, 성능 최적화 같은 추가적인 고려 사항도 필요할 수 있어.
JPA와의 연결 고리
JDBC를 이해하면, JPA가 JDBC를 기반으로 어떻게 더 높은 수준의 추상화를 제공하는지 이해하기 쉽지. 예를 들어, JPA는 데이터베이스 연결과 SQL 작성을 자동으로 처리하여 복잡성을 줄여줘. JDBC와 JPA는 함께 이해하면 더 나은 성능 최적화와 유지보수가 가능한 코드를 작성할 수 있어.
JDBC의 주요 기능
• 데이터베이스 연결: 다양한 데이터베이스 시스템(MySQL, Oracle, PostgreSQL 등)과 연결할 수 있습니다.
• SQL 쿼리 실행: 데이터 조회, 삽입, 수정, 삭제 등의 SQL 명령을 실행할 수 있습니다.
• 트랜잭션 처리: JDBC는 트랜잭션을 지원하여 여러 데이터베이스 작업을 하나의 트랜잭션으로 묶어 처리할 수 있습니다.
• 배치 처리: 여러 SQL 쿼리를 한 번에 실행하여 성능을 향상시킬 수 있습니다.
이러한 특징들을 통해 JDBC는 자바 기반 애플리케이션에서 데이터베이스와의 상호작용을 단순화하고 표준화된 방법으로 제공합니다.
JPA 소개 (Java Persistence API)
**JPA (Java Persistence API)**는 자바 애플리케이션에서 관계형 데이터베이스를 사용하는 객체 관계 매핑(ORM) 표준입니다. JPA는 자바 객체를 데이터베이스 테이블에 매핑하고, SQL을 직접 작성하지 않고도 데이터베이스에서 데이터를 조회하거나 저장할 수 있는 기능을 제공합니다.
JPA는 데이터베이스 작업을 더 쉽게 하고, 객체지향 프로그래밍 패러다임을 유지하면서 데이터베이스와 상호작용할 수 있게 해줍니다. 이는 전통적인 JDBC를 사용했을 때의 복잡성을 줄이고, 코드의 재사용성과 유지보수성을 높이는 장점이 있습니다.
JPA와 JDBC의 차이점
JPA와 JDBC는 모두 자바 애플리케이션에서 데이터베이스와 상호작용하는 방법을 제공합니다. 그러나 두 방법 간에는 큰 차이점이 있습니다.
• JDBC는 SQL 쿼리를 직접 작성하여 데이터베이스와 상호작용합니다. 이를 통해 고성능의 데이터베이스 작업을 수행할 수 있지만, SQL 문을 직접 관리하고 데이터베이스 종속적인 코드가 많아지기 쉽습니다.
• JPA는 자바 객체와 데이터베이스 간의 매핑을 자동으로 관리하여, SQL을 직접 작성할 필요 없이 객체를 다루듯이 데이터를 처리할 수 있습니다. 이로 인해 코드가 더 깔끔하고 유지보수가 용이해집니다.
JPA의 주요 구성 요소
1. Entity (엔티티):
• JPA에서 데이터베이스 테이블에 매핑되는 자바 클래스입니다. 각 인스턴스는 데이터베이스의 행(row)에 해당합니다.
• 엔티티 클래스는 보통 @Entity 어노테이션을 사용하여 선언되며, 클래스의 필드는 테이블의 컬럼과 매핑됩니다.
@Entity
public class User {
@Id
private Long id;
private String name;
private String email;
// getters, setters
}
2. EntityManager:
• EntityManager는 JPA의 핵심 인터페이스로, 엔티티 객체의 생명 주기를 관리하고, 데이터베이스와 상호작용하는 역할을 합니다. 이를 통해 CRUD(Create, Read, Update, Delete) 작업을 수행할 수 있습니다.
EntityManager em = entityManagerFactory.createEntityManager();
em.persist(newUser); // 데이터베이스에 새로운 사용자 저장
User user = em.find(User.class, userId); // 사용자 조회
3. JPQL (Java Persistence Query Language):
• JPA는 SQL 대신 JPQL이라는 쿼리 언어를 사용합니다. JPQL은 데이터베이스 테이블이 아닌 엔티티 객체를 대상으로 쿼리를 작성합니다. SQL과 유사하지만, 객체 중심의 쿼리라는 차이점이 있습니다.
String jpql = "SELECT u FROM User u WHERE u.name = :name";
List<User> users = em.createQuery(jpql, User.class)
.setParameter("name", "John")
.getResultList();
4. Transaction (트랜잭션):
• JPA는 트랜잭션을 지원하여 데이터베이스 작업을 안전하게 수행할 수 있게 합니다. 트랜잭션을 통해 여러 데이터베이스 작업을 하나로 묶어서 처리할 수 있으며, 오류가 발생하면 작업을 롤백할 수 있습니다.
EntityTransaction transaction = em.getTransaction();
transaction.begin();
em.persist(newUser);
transaction.commit();
JPA 사용의 장점
1. 객체 중심 개발: JPA는 객체와 데이터베이스 테이블 간의 매핑을 자동으로 처리하여, 객체지향적인 방식으로 데이터베이스와 상호작용할 수 있습니다.
2. 데이터베이스 독립성: JPA는 SQL을 직접 작성하지 않으므로 특정 데이터베이스에 종속되지 않습니다. 이를 통해 애플리케이션의 이식성이 높아집니다.
3. SQL 관리 감소: 복잡한 SQL 쿼리를 직접 작성할 필요 없이 JPQL로 쉽게 데이터 조회와 조작을 할 수 있습니다.
4. 생산성 증가: 데이터베이스와 상호작용하는 코드를 간소화하여 개발자가 비즈니스 로직에 더 집중할 수 있습니다.
JPA의 작동 방식
JPA는 자바 객체를 데이터베이스의 레코드와 매핑합니다. 이를 통해 데이터베이스와의 상호작용이 투명하게 이루어지며, 자바 애플리케이션이 데이터를 관리하는 방식을 더 직관적으로 만들어 줍니다. JPA가 제공하는 주요 기능 중 하나는 엔티티의 생명 주기를 관리하는 것입니다. 엔티티는 다음 네 가지 상태를 가집니다:
• 새로 생성된 (New): 아직 데이터베이스에 저장되지 않은 상태.
• 관리됨 (Managed): EntityManager에 의해 관리되며 데이터베이스에 존재하는 상태.
• 분리됨 (Detached): 데이터베이스와 연결은 끊겼지만 여전히 애플리케이션 내에 존재하는 상태.
• 삭제됨 (Removed): 데이터베이스에서 삭제된 상태.
JPA와 Hibernate
JPA는 인터페이스와 표준 규격만 제공하는 반면, Hibernate는 JPA의 구체적인 구현체 중 하나입니다. JPA의 모든 기능을 사용하면서 추가적인 기능(캐싱, 성능 최적화 등)을 제공합니다. 보통 JPA와 Hibernate를 함께 사용하여 더 강력한 ORM을 구축합니다.
JPA는 기본적으로 JDBC 위에서 동작하지만, 객체와 관계형 데이터베이스 간의 복잡한 매핑을 처리하여 더 쉽게 데이터베이스 작업을 수행할 수 있습니다. JPA를 통해 SQL 코드에 신경 쓰지 않고 객체지향적인 방식으로 애플리케이션을 개발할 수 있습니다.
JPA의 기본 개념
다음은 JPA 사용 시 알아야 할 핵심 개념들이야:
1. Entity:
• JPA에서 Entity는 데이터베이스 테이블과 매핑되는 자바 클래스야. 이를 통해 객체지향적인 방식으로 데이터베이스 작업을 수행할 수 있어.
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String email;
// getters and setters
}
2. EntityManager:
• JPA는 EntityManager를 통해 데이터베이스와 상호작용해. 이 객체는 엔티티의 생성, 읽기, 업데이트, 삭제 작업을 처리해.
EntityManager em = entityManagerFactory.createEntityManager();
em.getTransaction().begin();
User user = new User();
user.setName("John");
em.persist(user);
em.getTransaction().commit();
3. JPQL (Java Persistence Query Language):
• JPQL은 객체를 대상으로 한 쿼리 언어로, SQL과 유사하지만, 테이블이 아닌 엔티티 객체를 대상으로 쿼리를 작성해.
List<User> users = em.createQuery("SELECT u FROM User u WHERE u.name = :name", User.class)
.setParameter("name", "John")
.getResultList();
4. Transaction Management:
• JPA는 트랜잭션 관리를 지원하며, EntityManager를 통해 명시적으로 트랜잭션을 제어할 수 있어. 또는 스프링의 @Transactional 어노테이션을 사용해 트랜잭션 관리를 할 수도 있어.
@Transactional
public void saveUser(User user) {
entityManager.persist(user);
}
5. Persistence Context:
• Persistence Context는 엔티티 객체를 관리하는 공간이야. EntityManager는 엔티티 객체의 상태를 추적하고, 자동으로 변경된 데이터를 데이터베이스에 반영해.
6. Lazy vs. Eager Loading:
• JPA는 연관된 엔티티를 불러올 때 두 가지 방식(Lazy, Eager)을 사용해. Lazy는 필요한 순간에 데이터를 불러오고, Eager는 처음부터 데이터를 다 불러와.
@OneToMany(fetch = FetchType.LAZY)
private List<Order> orders;
7. Mapping Associations:
• JPA는 @OneToOne, @OneToMany, @ManyToOne, @ManyToMany 등의 어노테이션을 사용해 엔티티 간의 관계를 매핑해.
@ManyToOne
@JoinColumn(name = "user_id")
private User user;
추가적으로 알아두면 좋은 개념
기본 개념을 숙지했다면, 다음과 같은 심화 주제들도 알아두면 좋아:
1. 2차 캐시:
• JPA는 1차 캐시(EntityManager 범위 내 캐시)와 2차 캐시(애플리케이션 레벨 캐시)를 지원해. 2차 캐시는 성능 최적화를 위해 사용돼.
2. N+1 문제:
• 연관된 엔티티를 불러올 때 발생하는 성능 문제로, 이 문제를 해결하기 위해 fetch join 또는 배치 처리 전략을 사용할 수 있어.
3. Query Optimization:
• JPA의 @NamedQuery, Criteria API 등을 활용해 최적화된 쿼리를 작성하는 것도 중요한 개념이야.
JPA의 기본 개념을 잘 이해하고 있다면, JPA를 사용하는 데 큰 어려움은 없을 거야. 그러나 성능 최적화, 복잡한 데이터 매핑, 트랜잭션 관리 등의 심화 개념을 이해하고 있으면 더 복잡한 프로젝트에서도 효율적으로 사용할 수 있어. JPA 학습을 위해서는 실습을 많이 해보고, 실제 프로젝트에서 어떻게 동작하는지 파악하는 것이 매우 중요해.
JPA(Java Persistence API)의 이름이 이제는 Jakarta Persistence로 바뀌었어. 2019년에 Oracle에서 Jakarta EE로의 전환이 이루어졌고, 기존에 사용되던 Java EE 기술들이 Jakarta EE 프로젝트로 이관되었지. 그 과정에서 JPA도 Jakarta Persistence라는 이름으로 변경됐어.
이 변화는 주로 네이밍에 관한 것이고, 기존 JPA와 기능적으로는 큰 차이가 없지만 패키지 명이 javax.persistence에서 **jakarta.persistence**로 변경된 게 주요 차이점이야. 그래서 기존의 JPA 애플리케이션을 Jakarta Persistence로 마이그레이션할 때 패키지 이름을 업데이트하는 것이 필요해
관계형 데이터베이스(RDB, Relational Database)와 NoSQL의 차이는 주로 데이터 구조, 확장성, 유연성 등의 측면에서 나타나. 다음은 두 가지 데이터베이스의 주요 차이점이야:
1. 데이터 구조
• 관계형 데이터베이스 (RDB): 데이터는 테이블(Table)이라는 형태로 구조화되어 있고, 테이블은 행(Row)과 열(Column)로 구성돼. 각 행은 고유한 데이터를 나타내며, 열은 특정 속성(Attribute)을 의미해. 데이터를 저장할 때 정규화를 통해 중복을 최소화하고 데이터 일관성을 유지하려고 해.
• NoSQL: 데이터는 테이블 대신 다양한 방식으로 저장될 수 있어. 예를 들어, 문서(Document), 키-값(Key-Value), 그래프(Graph), 열(Column-Family) 형태 등 다양한 데이터 모델을 지원해. 고정된 스키마가 없고, 데이터 구조가 유연해서 비정형 데이터를 처리하기가 좋아.
2. 스키마
• RDB: 미리 정의된 **스키마(Schema)**가 필요하고, 모든 데이터는 그 스키마에 따라 저장돼야 해. 이 때문에 데이터 구조를 사전에 계획해야 하고, 스키마를 변경하는 것이 어렵고 복잡할 수 있어.
• NoSQL: 스키마가 없거나 매우 유연해. 미리 데이터 구조를 정의할 필요가 없고, 필요에 따라 쉽게 데이터 구조를 변경할 수 있어. 비정형 데이터나 반정형 데이터 처리가 수월해.
3. 확장성
• RDB: 수직 확장(서버의 성능을 높이는 방법)이 일반적이야. 데이터가 증가하면 더 성능이 좋은 서버가 필요하게 돼.
• NoSQL: 수평 확장(여러 서버를 추가하는 방법)에 최적화되어 있어. 서버를 추가하면서 데이터 분산 처리를 쉽게 할 수 있기 때문에, 대규모 데이터를 효율적으로 관리할 수 있어.
4. 트랜잭션
• RDB: ACID(Atomicity, Consistency, Isolation, Durability) 속성을 지원해. 이는 데이터의 일관성과 무결성을 보장하는 중요한 특징이야. 복잡한 트랜잭션 처리에 강점이 있어.
• NoSQL: CAP 이론을 따르는 경우가 많아. 즉, 일관성(Consistency), 가용성(Availability), 네트워크 파티션 허용성(Partition Tolerance) 중에서 두 가지를 우선시할 수 있어. NoSQL은 일반적으로 **최종 일관성(Eventual Consistency)**을 제공해 ACID 트랜잭션보다 유연하지만, 데이터 무결성을 완벽히 보장하지는 않을 수 있어.
5. 유연성 및 사용 사례
• RDB: 구조화된 데이터를 저장하고, 데이터 간의 관계를 명확하게 정의해야 할 때 사용돼. 예를 들어, 은행 시스템, ERP 시스템 등 트랜잭션과 데이터 일관성이 중요한 곳에서 사용돼.
• NoSQL: 대규모 비정형 데이터를 다루거나 빠르게 변화하는 데이터를 처리해야 할 때 적합해. 예를 들어, 소셜 미디어, 빅데이터 분석, 실시간 웹 애플리케이션에서 많이 사용돼.
6. 성능
• RDB: 정규화된 데이터베이스 구조로 인해 복잡한 조인(Join) 연산이 필요할 수 있고, 대용량 데이터 처리 시 성능이 저하될 수 있어.
• NoSQL: 조인 연산이 없거나 최소화된 구조로 설계되어 있어, 대규모 데이터를 빠르게 조회하고 처리할 수 있어.
결론적으로, RDB는 구조화된 데이터를 강력하게 관리하고 일관성을 중시하는 환경에 적합하고, NoSQL은 유연성, 확장성, 비정형 데이터 처리에 강점이 있어. 둘 중 어떤 것을 사용할지는 프로젝트의 요구사항에 따라 달라져.
ORM(Object-Relational Mapping)은 객체 지향 프로그래밍 언어에서 사용하는 객체와 관계형 데이터베이스에서 사용하는 테이블 간의 매핑을 자동으로 처리해주는 기술이야. 간단히 말하면, 객체와 데이터베이스의 데이터를 자동으로 연결해주는 도구야. 이렇게 하면, 데이터베이스의 복잡한 SQL 쿼리를 직접 작성하지 않고도 객체를 통해 데이터베이스와 상호작용할 수 있어.
주요 개념
1. 객체와 테이블 매핑: 객체의 속성(필드)들이 데이터베이스의 컬럼과 매핑돼. 예를 들어, 자바의 User 클래스의 name 필드는 데이터베이스의 users 테이블의 name 컬럼과 연결될 수 있어.
2. 쿼리 자동 생성: ORM은 객체를 통해 데이터베이스에 CRUD(생성, 읽기, 갱신, 삭제) 작업을 쉽게 할 수 있게 해줘. 개발자가 SQL 쿼리를 직접 작성할 필요 없이, 객체의 메서드 호출을 통해 데이터베이스 작업을 처리할 수 있어.
3. 데이터 일관성 보장: 객체 간의 관계(1:1, 1:N, N:M 등)를 ORM이 관리해주기 때문에, 데이터의 무결성과 일관성을 쉽게 유지할 수 있어.
ORM의 장점
• 생산성 향상: 개발자는 비즈니스 로직에 집중할 수 있고, 반복적인 SQL 작성에서 벗어날 수 있어.
• 유지보수성 증가: 코드와 데이터베이스 간의 변경 사항이 있을 때, ORM이 그 변화를 자동으로 반영해 주기 때문에 유지보수가 쉬워져.
• DB 독립성: ORM은 데이터베이스에 종속되지 않고, 다른 데이터베이스로 쉽게 전환할 수 있어.
대표적인 ORM 도구
• Hibernate (자바)
• JPA (Jakarta Persistence API, 자바)
• Entity Framework (C#/.NET)
ORM을 사용하면 객체 지향 프로그래밍과 관계형 데이터베이스 간의 패러다임 차이를 매끄럽게 연결할 수 있어서, 더 효율적인 개발이 가능해져.
“매핑(Mapping)“을 쉽게 설명하면 두 가지 요소를 연결하거나 짝을 지어주는 것을 의미해.
예를 들어:
• 객체와 데이터베이스 매핑: 자바 객체의 **필드(속성)**를 데이터베이스의 **컬럼(열)**과 연결하는 거야. 예를 들어, 자바 클래스 User에 있는 name 필드를 데이터베이스 users 테이블의 name 컬럼과 대응시키는 것을 “매핑”한다고 해.
비유로 설명하면:
• 매핑을 “주소록에 이름과 전화번호를 연결하는 것”으로 생각할 수 있어. 이름과 전화번호가 연결되어 있듯이, 자바 객체의 속성과 데이터베이스의 값을 연결하는 것이 매핑이야.
즉, 데이터베이스와 자바 객체 간의 정보를 서로 주고받기 위해 대응 관계를 만들어주는 것이 매핑의 핵심이야.
JPA에서 validate는 데이터베이스 스키마를 엔티티 클래스와 비교하여 유효성을 검사하는 역할을 합니다. 즉, 엔티티 클래스에서 정의한 매핑 정보와 실제 데이터베이스 테이블 구조가 일치하는지 확인하는 거예요.
hibernate.hbm2ddl.auto 속성에서 validate를 설정하면, 애플리케이션이 시작될 때 데이터베이스 테이블이 존재하고 그 구조가 올바른지 검사만 하고, 테이블을 수정하거나 생성하지 않아요. 이 설정은 데이터베이스 스키마를 변경하지 않고, 이미 존재하는 스키마가 엔티티 매핑과 정확히 일치하는지 확인할 때 유용해요.
예를 들어, hibernate.hbm2ddl.auto 속성을 validate로 설정하면, 엔티티 클래스의 필드와 데이터베이스 테이블의 컬럼 구조가 일치하지 않으면 애플리케이션이 오류를 던지고 시작되지 않아요.
<property name="hibernate.hbm2ddl.auto" value="validate"/>
이 옵션을 사용하면, 개발 단계에서 데이터베이스 스키마가 코드와 맞는지 쉽게 확인할 수 있어.
'Database > JPA' 카테고리의 다른 글
| 객체 간 관계를 완벽히 이해하는 JPA 연관관계 매핑 (0) | 2024.09.11 |
|---|---|
| JPA 기본 키 생성 전략: IDENTITY, SEQUENCE, TABLE과 allocationSize의 이해 (1) | 2024.09.10 |
| QueryDSL로 JPA 쿼리 쉽게 작성하기 (3) | 2024.09.10 |
| JPA 엔티티 관리 메서드 (0) | 2024.09.10 |
| JPA 영속성 컨텍스트 완벽 이해: persist, flush, 그리고 엔티티 관리의 차이점 (2) | 2024.09.10 |
