Mapping File 에서 쿼리를 조회해서 쿼리를 수행하고 응답을 받아올 수 있는 세션 객체
Mapper Interface (8), (9)
DB 에서 조회하는 객체와 Java 프로그램의 객체간에 인터페이스를 정의하는 객체
방법1. Dao 클래스 정의
SqlSession 를 직접적으로 사용하는 방법
SqlSession 멤버 변수로 사용하며 쿼리파일 수행 요청
// UserDao.java
import org.apache.ibatis.session.SqlSession;
import org.springframework.stereotype.Component;
import com.thesun4sky.querymapper.domain.User;
@Component
public class UserDao {
// SqlSession 멤버 변수로 사용하며 쿼리파일 수행 요청
private final SqlSession sqlSession;
public UserDao(SqlSession sqlSession) {
this.sqlSession = sqlSession;
}
public User selectUserById(long id) {
return this.sqlSession.selectOne("selectUserById", id);
}
}
장점
쿼리문 실행 전에 넣어줄 매개변수와 쿼리 결과값의 변형을 정의할 수 있다.
Namespace를 내 마음대로 둘 수 있다.
.xml 파일의 쿼리문 id와 mapper 메소드명을 일치시킬 필요가 없다.
단점
Sqlsession 객체를 주입받아야 하며, 쿼리문 실행 시 항상 호출해야 한다.
쿼리문 호출 시 sqlsession에 .xml 파일의 namespce와 쿼리문 id를 매개변수로 넘겨야한다.
방법2. Mapper Interface 정의
SqlSession 를 간접적으로 사용하는 방법
ibatis 에서 구현해주는 org.apache.ibatis.annotations.Mapper 어노테이션을 사용하면 sqlSession 를 사용하여 자동으로 호출해줌
// UserMapper.java
@Mapper
public interface UserMapper {
User selectUserById(@Param("id") Long id);
}
장점
메소드의 내부 구현이 불필요하다.
Sqlsession 객체 주입이 불펼요하다.
.xml 파일의 쿼리문 id와 mapper 메소드 명이 일치한다.
단점
.xml의 Namespace가 실제 Mapper.java 위치를 가르켜야 한다.
메소드 내부 정의가 불가능하다.
Mapping File (10)
SqlSession 가 실행하는 쿼리가 담긴 파일
정의된 인터페이스에 기반해서 수행할 쿼리를 담아두고
쿼리 수행결과를 어떤 인터페이스 매핑할지 정의해놓은 파일
<!-- UserMapper.xml -->
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.thesun4sky.querymapper.mapper.UserMapper">
<select id="selectUserById" resultType="User">
select id, name from users where id = #{id}
</select>
</mapper>
쿼리 코드 만들기 (JpaRepository)
QueryMapper 의 DB의존성 및 중복 쿼리 문제로 ORM 이 탄생했다.
ORM 은 DB의 주도권을 뺏어왔다고 표현해도 과언이 아닙니다.
ORM 은 DAO 또는 Mapper 를 통해서 조작하는것이 아니라 테이블을 아예 하나의 객체(Object)와 대응시켜 버립니다.
말이 쉽지…. 객체지향(Object) 을 관계형 데이터베이스(Relation) 에 매핑(Mapping) 한다는건 정말 많은 난관이 있습니다.
- flush() 호출 전까지 SQL 쿼리를 영속성 컨텍스트에 모아두었다가, 한 번에 DB로 전송하는 최적화 메커니즘.
쓰기 지연 발생 시점
- 트랜잭션 중 객체 생성, 수정, 삭제 시. - flush() 호출 전까지 쿼리를 최적화하여 보관.
쓰기 지연 효과
- 여러 동작을 모아 쿼리를 한번에 전송하여 최소화. - 생성/수정/삭제 작업의 중간 상태가 발생하더라도 실제 DB에는 최적화된 쿼리만 전송. - 불필요한 쿼리 전송 방지.
주의점
- GenerationType.IDENTITY 사용 시, 쓰기 지연이 적용되지 않음. - 이유: IDENTITY 전략은 키 생성 시점에 단일 쿼리가 필요하며, 외부 트랜잭션 간의 키 중복을 방지하기 위해 즉시 DB에 반영됨.
예제 코드의 흐름
단계
동작 설명
1. 객체 생성
새로운 객체 생성 (new 상태).
2. 엔티티 매니저 생성
영속성 컨텍스트를 관리할 엔티티 매니저 생성.
3. 트랜잭션 시작
데이터의 무결성을 보장하기 위해 트랜잭션 시작.
4. 객체 저장
persist() 호출로 객체를 영속성 컨텍스트에 저장.
5. flush() 호출
영속성 컨텍스트의 SQL 쿼리를 DB로 전송 (commit 시 자동 수행).
6. commit() 호출
DB에 쿼리를 최종 반영.
7. 자원 해제
엔티티 매니저 및 팩토리 자원 반환 (close()).
ORM 을 사용하는 가장 쉬운 방법 : JpaRepository
💁♂️ Repository vs JpaRepository
기존 Repository
@Repository 을 클래스에 붙인다.
@Component 어노테이션을 포함하고 있어서 앱 실행시 생성 후 Bean으로 등록된다.
앞서배운 Repository 기본 기능만 가진 구현체가 생성된다. (DB별 예외처리 등)
새로운 JpaRepository
JpaRepository<Entity,ID> 인터페이스를 인터페이스에 extends 붙인다.
@NoRepositoryBean 된 ****상위 인터페이스들의 기능을 포함한 구현체가 프로그래밍된다. (@NoRepositoryBean = 빈생성 막음 →상속받으면 생성돼서 사용가능)
JpaRepository (마스터 셰프): 데이터 액세스를 위한 핵심 기능의 종합적인 요리책(기능) 을 제공합니다.
@NoRepositoryBean 인터페이스 (셰프): 각 인터페이스는 특정 데이터 액세스 방법을 제공하는 전문적인 기술 또는 레시피를 나타냅니다.
JpaRepository 상속: 마스터 셰프의 요리책과 셰프의 전문성을 얻습니다.
SpringDataJpa 에 의해 엔티티의 CRUD, 페이징, 정렬 기능 메소드들을 가진 빈이 등록된다. (상위 인터페이스들의 기능)
Repository 와 JpaRepository 를 통해 얼마나 간단하게 구현하게 될지 미리 확인해볼까요?
Repository 샘플
EntityManager 멤버변수를 직접적으로 사용
// UserRepository.java
@Repository
public class UserRepository {
@PersistenceContext
EntityManager entityManager;
public User insertUser(User user) {
entityManager.persist(user);
return user;
}
public User selectUser(Long id) {
return entityManager.find(User.class, id);
}
}
JpaRepository 샘플
EntityManager 멤버변수를 간접적으로 사용
// UserRepository.java
public interface UserRepository extends JpaRepository<User, Long> {
// 기본 메서드는 자동으로 만들어짐
}
CREATE TABLE MEMBER (
MEMBER_ID BIGINT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(255) NOT NULL,
home_city VARCHAR(255) NOT NULL,
home_street VARCHAR(255) NOT NULL,
company_city VARCHAR(255) NOT NULL,
company_street VARCHAR(255) NOT NULL,
PRIMARY KEY (MEMBER_ID)
);
3. Collection Value 타입 매핑
@Entity
public class Product {
@Id
@GeneratedValue
private Long id;
@ElementCollection
@CollectionTable(name = "product_tags", joinColumns = @JoinColumn(name = "product_id"))
@Column(name = "tag")
private List<String> tags = new ArrayList<>();
}
생성되는 테이블:
CREATE TABLE product_tags (
product_id BIGINT NOT NULL,
tag VARCHAR(255),
PRIMARY KEY (product_id, tag)
);
특징 및 활용 요약
기본 타입: 일반적인 데이터 저장에 사용되며, 설정 옵션으로 제약조건 지정.
Composite Value 타입: 코드의 응집도를 높이고 복합 데이터를 쉽게 관리.
Collection Value 타입: 여러 값 관리에 유용하지만, 대규모 데이터에서는 다대일 연관관계를 선호.
테이블 객체 만들기
User Entity 만들어보기
id, username, password 를 가지는 User Entity 를 만들어 봅니다.
// User.java
// lombok
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@ToString
// jpa
@Entity
@Table(name = "users")
public class User {
/**
* 컬럼 - 연관관계 컬럼을 제외한 컬럼을 정의합니다.
*/
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
private String username;
private String password;
/**
* 생성자 - 약속된 형태로만 생성가능하도록 합니다.
*/
@Builder
public User(String username, String password) {
this.username = username;
this.password = password;
}
/**
* 연관관계 - Foreign Key 값을 따로 컬럼으로 정의하지 않고 연관 관계로 정의합니다.
*/
@OneToMany
@Exclude
private Set<UserChannel> userChannel;
/**
* 연관관계 편의 메소드 - 반대쪽에는 연관관계 편의 메소드가 없도록 주의합니다.
*/
/**
* 서비스 메소드 - 외부에서 엔티티를 수정할 메소드를 정의합니다. (단일 책임을 가지도록 주의합니다.)
*/
public void updateUserName(String username) {
this.username = username;
}
public void updatePassword(String password) {
this.password = password;
}
}
기타 추천 플러그인
Key PromoterX
단축키 알림
Presentation Assistant
알림 이쁘게 보여주기
테이블 객체끼리 관계만들기
Raw JPA 연관관계 매핑 기능 요약 표
애노테이션
설명
주요 속성
예시 코드
@OneToOne
- 1:1 관계를 매핑. - 단방향 및 양방향 매핑 가능.- 테이블 분리 여부를 신중히 검토.
@Entity
public class Member {
@Id
@GeneratedValue
private Long id;
@OneToOne
@JoinColumn(name = "locker_id")
private Locker locker;
}
@Entity
public class Locker {
@Id
@GeneratedValue
private Long id;
}
2. @OneToMany와 @ManyToOne 양방향 매핑
@Entity
public class Parent {
@Id
@GeneratedValue
private Long id;
@OneToMany(mappedBy = "parent")
private List<Child> childList;
}
@Entity
public class Child {
@Id
@GeneratedValue
private Long id;
@ManyToOne
@JoinColumn(name = "parent_id")
private Parent parent;
}
3. @ManyToMany 매핑
@Entity
public class Parent {
@Id
@GeneratedValue
private Long id;
@ManyToMany(mappedBy = "parents")
private List<Child> childs;
}
@Entity
public class Child {
@Id
@GeneratedValue
private Long id;
@ManyToMany
@JoinTable(
name = "parent_child",
joinColumns = @JoinColumn(name = "parent_id"),
inverseJoinColumns = @JoinColumn(name = "child_id")
)
private List<Parent> parents;
}
