[ Object equals ]

equals 메서드는 같은 객체(인스턴스) 일 경우에만 동일하다고 판단.

reflexive : x.equals(x) 는 항상 참

symmetric : x.equals(y) 가 참이라면 y.equals(x) 역시 참이어야 한다

transitive : x.equals(y) 가 참이고 y.equals(z) 가 참일 때 x.equals(z) 역시 참이어야 한다

consistent : x.equals(y)가 참일 때 equals 메서드에 사용된 값이 변하지 않는 이상 몇번을 호출해도 같은 결과가 나와야 한다

x가 null이 아닐 때 x.equals(null) 은 항상 거짓이어야 한다

 

[ JPA 에서의 equals ]

엔티티 매니저의 영속성 컨텍스트에서 1차 캐시를 이용해 같은 ID의 엔티티를 항상 같은 객체로 가져올 수 있다. 하지만 1차 캐시를 초기화 한 후 다시 데이터베이스에서 동일한 엔티티를 읽어오는 경우 초기화 전에 얻었던 객체와 초기화 이후에 얻은 객체가 서로 다른 객체로 생성된다.

이는 equals 메서드의 consistent 원칙을 위반하는 것이며 엔티티는 자바 객체라기 보단 데이터베이스 테이블 레코드에 가깝기 때문에 엔티티 객체의 필드(pk)가 동일하다면 같은 레코드, 즉 객체라고 판단해야 한다. 

이와 같은 이유로 equals 메서드와 hashCode 메서드를 재정의 해야 한다.

 

* 준영속 상태의 엔티티 간 비교, 비교할 두 인자가 둘 다 null 인 상태에서의 비교 등을 고려하여 

Objects.hash 메서드를 사용하여 hashCode 구현

 

https://velog.io/@park2348190/JPA-Entity%EC%9D%98-equals%EC%99%80-hashCode

 

반응형

'back > JPA' 카테고리의 다른 글

[JPA] cascade  (0) 2022.11.10
[JPA] JPQL, QueryDSL  (0) 2020.03.21
[JPA] JPA 영속성 컨텍스트  (0) 2020.03.08
[JPA] 연관관계 매핑 : 단방향, 양방향 매핑  (0) 2020.03.01
[JPA] JPA 기초 설정 및 entity 필드 매핑  (0) 2020.02.27

JPA에서의 연관관계 매핑

 

1. 단방향 매핑

Team 1 : User N 인 경우

User entity가 참조할 Team entity 매핑키(tid)를 넣어준다.

* 1:N 관계에서 N 테이블에 1테이블의 fk 를 가지고 있다.

  관계의 주인은 N 테이블이 된다.

 

[Sample Code]

[Team entity]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package com.jpp.webservice.web.domain.team;
 
import java.util.ArrayList;
import java.util.List;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
 
import com.jpp.webservice.web.domain.user.User;
 
@Entity
public class Team {
    
   @Id
   @GeneratedValue(strategy=GenerationType.AUTO)
   private Long tid;
    
   private String teamNm;
 
   public Long getTid() {
      return tid;
   }
 
   public void setTid(Long tid) {
      this.tid = tid;
   }
 
   public String getTeamNm() {
      return teamNm;
   }
 
   public void setTeamNm(String teamNm) {
      this.teamNm = teamNm;
   }
}
cs

 

[User entity]

User 엔티티가 참조할 Team 의 tid 칼럼을 필드로 갖게한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package com.jpp.webservice.web.domain.user;
 
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
 
@Entity
public class User {
    
   @Id
   @GeneratedValue
   private Long id;
    
   private String name;
    
   private String mobileNum;
 
   private Long tid;
    
   public Long getId() {
      return id;
   }
   public void setId(Long id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getMobileNum() {
      return mobileNum;
   }
   public void setMobileNum(String mobileNum) {
      this.mobileNum = mobileNum;
   }
   public Long getTid() {
      return tid;
   }
   public void setTid(Long tid) {
      this.tid = tid;
   }
    
}
cs

 

[테스트]

User 를 저장할때 tid를 넣어주어 Team과 User를 매핑해준다.

실제로 참조관계를 설정해준건 아니기 때문에 연관관계가 있다고 하긴 모호하다.

일단 tid를 기준으로 User를 조회해보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package com.jpp.webservice.web.domain.team;
 
import java.util.List;
 
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;
 
import com.jpp.webservice.web.domain.user.User;
import com.jpp.webservice.web.domain.user.UserRepository;
 
@RunWith(SpringRunner.class)
@SpringBootTest
@ActiveProfiles("test")
public class TeamRepositoryTest {
   
   protected static final Logger LOGGER = LoggerFactory.getLogger(TeamRepositoryTest.class);
   
   @Autowired
   TeamRepository teamRepository;
   
   @Autowired
   UserRepository userRepository;
   
   @Test
   public void test() {
      Team team = new Team();
      team.setTeamNm("vip");
      LOGGER.info("tid before save >>> " + team.getTid());    //save 를 하기 전엔 entity의 id(pk)가 생성되지 않는다
      teamRepository.save(team);
      
      Long tid = team.getTid();
      LOGGER.info("tid after save >>> " + tid); //save 를 하고 난 후 entity의 id(pk)가 생성되어 있다
      
      List<Team> teams = teamRepository.findAll();
      for(Team t : teams) {
         LOGGER.info("t nm:"+t.getTeamNm());
         LOGGER.info("id:"+t.getTid());
      }
      
      User user = new User();
      user.setMobileNum("01012345678");
      user.setName("pyo");
      user.setTid(tid);    //team entity를 save 할 때 사용한 tid를 user entity 의 fk칼럼인 tid에 넣어준다
      
      userRepository.save(user);
      List<User> users = userRepository.findByName("pyo");
      for(User u : users) {
         LOGGER.info("u nm:"+u.getName());
         LOGGER.info("u tid:"+u.getTid());
         List<User> users2 = userRepository.findByTid(u.getTid());
         for(User us : users2) {
            LOGGER.info("us : " + us.getName());
         }
      }
   }
}
cs

 

[결과]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
Hibernate: 
    drop table posts if exists
Hibernate: 
    drop table team if exists
Hibernate: 
    drop table user if exists
Hibernate: 
    create table posts (
        id bigint generated by default as identity,
        author varchar(255),
        content TEXT not null,
        title varchar(500not null,
        primary key (id)
    )
Hibernate: 
    create table team (
        tid bigint generated by default as identity,
        team_nm varchar(255),
        primary key (tid)
    )
Hibernate: 
    create table user (
        id bigint generated by default as identity,
        mobile_num varchar(255),
        name varchar(255),
        tid bigint,
        primary key (id)
    )
09:53:57.773 [main] INFO  o.h.tool.hbm2ddl.SchemaExport - HHH000230: Schema export complete
 
 
 
09:54:00.266 [main] INFO  c.j.w.w.d.team.TeamRepositoryTest - tid before save >>> null
Hibernate: 
    insert 
    into
        team
        (tid, team_nm) 
    values
        (null, ?)
09:54:00.324 [main] INFO  c.j.w.w.d.team.TeamRepositoryTest - tid after save >>> 1
09:54:00.344 [main] INFO  o.h.h.i.QueryTranslatorFactoryInitiator - HHH000397: Using ASTQueryTranslatorFactory
Hibernate: 
    select
        team0_.tid as tid1_1_,
        team0_.team_nm as team_nm2_1_ 
    from
        team team0_
09:54:00.485 [main] INFO  c.j.w.w.d.team.TeamRepositoryTest - t nm:vip
09:54:00.485 [main] INFO  c.j.w.w.d.team.TeamRepositoryTest - id:1
Hibernate: 
    insert 
    into
        user
        (id, mobile_num, name, tid) 
    values
        (null, ?, ?, ?)
Hibernate: 
    select
        user0_.id as id1_2_,
        user0_.mobile_num as mobile_n2_2_,
        user0_.name as name3_2_,
        user0_.tid as tid4_2_ 
    from
        user user0_ 
    where
        user0_.name=?
09:54:00.525 [main] INFO  c.j.w.w.d.team.TeamRepositoryTest - u nm:pyo
09:54:00.525 [main] INFO  c.j.w.w.d.team.TeamRepositoryTest - u tid:1
Hibernate: 
    select
        user0_.id as id1_2_,
        user0_.mobile_num as mobile_n2_2_,
        user0_.name as name3_2_,
        user0_.tid as tid4_2_ 
    from
        user user0_ 
    where
        user0_.tid=?
09:54:00.530 [main] INFO  c.j.w.w.d.team.TeamRepositoryTest - us : pyo
 
cs

위와같이 Team 에 넣은 tid 값을 기준으로 User를 조회할 수 있다.

중요한건 DDL 부분인데, pk만 지정되었을 뿐 참조관계, 즉 fk가 설정되지 않았다. (~28 Line 까지가 DDL 이며, 참조관계가 설정되는 구문이 보이지 않는다)

참조관계를 설정해줬다기 보단 User 테이블에 Team 테이블의 pk 칼럼을 포함시켰을 뿐이다.

(코드는 마치 fk 가 잡혀있듯이 개발하고, 실제 테이블엔 fk를 설정하지 않는 것 처럼)

 

그렇다면 진짜 참조관계(fk)를 설정해보자.

 

2. 양방향 매핑

1) 테이블에서의 양방향 매핑

- 외래 키 하나로 두 테이블 연관관계 관리

- MEMBER.TEAM_ID FK키 하나로 양방향 연관관계를 가지며 양쪽으로 조인이 가능하다 

SELECT *
FROM MEMBER M
JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID

SELECT * 
FROM TEAM T
JOIN MEMBER M ON T.TEAM_ID M.TEAM_ID

2) 객체에서의 양방향 매핑

- 객체의 양방향 관계는 Table의 양방향 관계와 달리 서로 다른 단방향 관계 2개(순환참조)로 만든다.

  (위에서 살펴본 단방향 매핑 두개가 양쪽에 있는 개념)

Class A {
  B b;
}
Class B {
  A a;
}

 

[Sample Code]

[Team entity]

List<User> users 를 넣어주었다.

mappedBy는 말 그대로 매핑이 ?에 의해 이루어 진다는 의미로 참조를 당한다는 의미다.

@OneToMany는 1:N을 의미(앞쪽의 One 은 현재 엔티티 뒷쪽의 Many는 매핑된 다른 엔티티)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package com.jpp.webservice.web.domain.team;
 
import java.util.ArrayList;
import java.util.List;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
 
import com.jpp.webservice.web.domain.user.User;
 
@Entity
public class Team {
    
   @Id
   @GeneratedValue(strategy=GenerationType.AUTO)
   private Long tid;
    
   private String teamNm;
 
   @OneToMany(mappedBy = "team")
   private List<User> users = new ArrayList<User>();
    
   public Long getTid() {
      return tid;
   }
 
   public void setTid(Long tid) {
      this.tid = tid;
   }
 
   public String getTeamNm() {
      return teamNm;
   }
 
   public void setTeamNm(String teamNm) {
      this.teamNm = teamNm;
   }
 
   public List<User> getUsers() {
      return users;
   }
 
   public void setUsers(List<User> users) {
      this.users = users;
   }
}
 
cs

 

[User entity]

Team team을 넣어주었다.

@JoinColumn 어노테이션을 달아 주었으며 이는 외부 엔티티의 필드를 참조함을 의미한다.

@ManyToOne은 N:1을 의미 (앞쪽의 Many가 현재 entity)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package com.jpp.webservice.web.domain.user;
 
 
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
 
import com.jpp.webservice.web.domain.team.Team;
 
@Entity
public class User {
    
  @Id
  @GeneratedValue
  private Long id;
    
  private String name;
    
  private String mobileNum;
    
  @ManyToOne
  @JoinColumn
  private Team team;
    
   public Long getId() {
      return id;
   }
   public void setId(Long id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getMobileNum() {
      return mobileNum;
   }
   public void setMobileNum(String mobileNum) {
      this.mobileNum = mobileNum;
   }
   public Team getTeam() {
      return team;
   }
   public void setTeam(Team team) {
      this.team = team;
   }
    
}
 
cs

JPA Entity 매핑에선

1 Entity엔 @OneToMany(mappedBy= 1의 Table명)

N Entity엔 @ManyToOne @JoinColumn(id = 1의 Key)

ex) Member 1 : Order N 관계에서의 Entity 설정은 아래와 같다

@Entity

class Member {

  @OneToMany(mappedBy = "member")

   private List<Order> orders = new ArrayList<>();

}

@Entity

class Order {

  @ManyToOne @JoinColumn(name = "member_id")

  private Member member;

}

 

 

[테스트]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
package com.jpp.webservice.web.domain.team;
 
import java.util.List;
 
import org.junit.After;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
 
import com.jpp.webservice.web.domain.user.User;
import com.jpp.webservice.web.domain.user.UserRepository;
 
@RunWith(SpringRunner.class)
@SpringBootTest
@ActiveProfiles("test")
public class TeamRepositoryTest {
   
   protected static final Logger LOGGER = LoggerFactory.getLogger(TeamRepositoryTest.class);
   
   @Autowired
   TeamRepository teamRepository;
   
   @Autowired
   UserRepository userRepository;
   
   @Test
   public void test1() {
      Team team = new Team();
      team.setTeamNm("vip");
      teamRepository.save(team);
      
      User user = new User();
      user.setMobileNum("01012345678");
      user.setName("pyo");
      
      team.getUsers().add(user);
      user.setTeam(team);
      
      userRepository.save(user);
   }
   
   @Test
   public void test2() {
      List<Team> teamList = teamRepository.findAll();
      for(Team t : teamList) {
         for(User u : t.getUsers()) {
            LOGGER.info("?!!");
            LOGGER.info("user name : "+u.getName());
            LOGGER.info("user team : "+u.getTeam());
         }
      }
   }
   
}
 
cs

[결과]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
16:15:34.405 [main] INFO  o.h.tool.hbm2ddl.SchemaExport - HHH000227: Running hbm2ddl schema export
Hibernate: 
    drop table posts if exists
Hibernate: 
    drop table team if exists
Hibernate: 
    drop table user if exists
Hibernate: 
    create table posts (
        id bigint generated by default as identity,
        author varchar(255),
        content TEXT not null,
        title varchar(500not null,
        primary key (id)
    )
Hibernate: 
    create table team (
        team_id bigint generated by default as identity,
        team_nm varchar(255),
        primary key (team_id)
    )
Hibernate: 
    create table user (
        id bigint generated by default as identity,
        mobile_num varchar(255),
        name varchar(255),
        team_id bigint,
        primary key (id)
    )
Hibernate: 
    alter table user 
        add constraint FKbmqm8c8m2aw1vgrij7h0od0ok 
        foreign key (team_id) 
        references team
16:15:34.431 [main] INFO  o.h.tool.hbm2ddl.SchemaExport - HHH000230: Schema export complete
 
Hibernate: 
    insert 
    into
        team
        (team_id, team_nm) 
    values
        (null, ?)
Hibernate: 
    insert 
    into
        user
        (id, mobile_num, name, team_id) 
    values
        (null, ?, ?, ?)
16:15:37.128 [main] INFO  o.h.h.i.QueryTranslatorFactoryInitiator - HHH000397: Using ASTQueryTranslatorFactory
Hibernate: 
    select
        team0_.team_id as team_id1_1_,
        team0_.team_nm as team_nm2_1_ 
    from
        team team0_
Hibernate: 
    select
        users0_.team_id as team_id4_2_0_,
        users0_.id as id1_2_0_,
        users0_.id as id1_2_1_,
        users0_.mobile_num as mobile_n2_2_1_,
        users0_.name as name3_2_1_,
        users0_.team_id as team_id4_2_1_ 
    from
        user users0_ 
    where
        users0_.team_id=?
16:15:37.264 [main] INFO  c.j.w.w.d.team.TeamRepositoryTest - ?!!
16:15:37.264 [main] INFO  c.j.w.w.d.team.TeamRepositoryTest - user name : pyo
cs

참조 조건이 설정됨을 확인할 수 있다. (31~34 line)

Team 에서 User를 조회할 수 있다.  (반대의 경우도 가능하다)

 

 

Owner : 연관관계의 주인

객체의 두 관계 중 하나를 연관관계의 주인으로 지정

연관관계의 주인만이 외래키를 관리(등록, 수정)

주인이 아닌 쪽은 읽기만 가능

주인은 mappeedBy 속성 사용하지 않음

주인이 아니면 mappedBy 속성으로 주인 지정

 

※ 일반적인 설계

위 예에서 User가 연관관계의 주인, 반대편인 Team은 가짜매핑(조회를 편하게 하기위한)

설계시 User의 Team을 주인으로 정한다. fk 키를 가지고 있는 칼럼을 주인으로 정해야 혼란을 방지할 수 있다.

 

※ 기타

양방향 매핑은 사실 필요가 없다.

조회를 편하게 하기 위함일 뿐, 일반적으론 단방향 매핑 관계만 적용하여 설계한다.

반대방향으로 조회가 필요한 경우, 그 때 양방향 관계(mappedBy)를 추가한다.

그리고 설계시 연관관계의 주인(JoinColumn)은 fk 키를 가지고 있는 entity의 필드를 주인으로 삼는다.

 

참고 :

Tacademy 김영한 개발자님의 강의

김영한 개발자님의 JPA 저서

https://www.baeldung.com/jpa-join-column

반응형

'back > JPA' 카테고리의 다른 글

[JPA] equals , hashcode  (0) 2022.11.08
[JPA] JPQL, QueryDSL  (0) 2020.03.21
[JPA] JPA 영속성 컨텍스트  (0) 2020.03.08
[JPA] JPA 기초 설정 및 entity 필드 매핑  (0) 2020.02.27
[JPA] JPA란? : 등장배경, ORM, 하이버네이트  (0) 2020.02.23

- JPA 는 특정 데이터베이스에 종속적이지 않음

- dialect interface 를 구현하는 MySQLDialect, OracleDialect H2Dialect 등이 존재

(dialect : SQL 표준을 지키지 않거나 특정 데이터베이스만의 고유한 기능(ROWNUM(ORACLE) vs LIMIT(Mysql)))

- h2 : 크기가 작은 메모리 DB, 테스트용으로 사용

 

[pom.xml (dependency)]

org.hibernate.hibernate-entitymanager dependency필요(해당 dependency가 jpa.persistence-api, hibernate-core 땡겨옴)

 

[persistence.xml]

jpa 설정을 위한 persistence.xml가 필요(spring fw기준)(boot는 yml 혹은 property에 작성)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence" version=“2.2">
     <persistence-unit name="hello">
         <properties>
             <!-- 필수 속성 -->
             <property name="javax.persistence.jdbc.driver" value="org.h2.Driver"/>
             <property name="javax.persistence.jdbc.user" value="sa"/>
             <property name="javax.persistence.jdbc.password" value=""/>
             <property name="javax.persistence.jdbc.url" value="jdbc:h2:tcp://localhost/~/test"/>
             <property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect" />
             <!-- 옵션 -->
             <property name="hibernate.show_sql" value="true" />
             <property name="hibernate.format_sql" value="true" />
             <property name="hibernate.use_sql_comments" value="true" />
             <property name="hibernate.id.new_generator_mappings" value="true" />
             <!--<property name="hibernate.hbm2ddl.auto" value="create" />-->
         </properties>
     </persistence-unit>
</persistence>
cs

* hibernate.hbm2ddl.auto (hibernate.ddl-auto) 옵션

create : 기존테이블 삭제 후 다시 생성

create-drop : create와 같으나 종료 시점에 테이블 drop

update : 변경분만 반영

validate : 엔티티와 테이블 정상 매핑인지만 확인

none : 사용하지않음

* 환경별 옵션 사용

개발 초기(create, update)

테스트서버 (update, validate)

운영서버 (validate, none)

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Entity
public class Member {
    @Id
    private Long id;
    
    @Column(name = "USERNAME")
    private String name;
    
    private int age;
    
    @Temporal(TemporalType.TIMESTAMP)
    private Date regDate;
    
    @Enumerated(EnumType.STRING)
    private MemberType memberType;
}
cs

@Entity (javax.persistence)

: JPA로 관리할 객체

@Id

: DB PK와 매핑 할 필드 ( * 보통 auto_increment 로 설계)

@Column

- name : 필드와 실제로 매핑할 테이블의 칼럼명(테이블 칼럼명이 필드와 다를 경우 사용)

- nullable : null허용

- unique : 유니크제약

- length 등..

@Temporal(TemporalType.DATE)

: 날짜타입매핑

@Enumerated

: 열거형 매핑

- EnumType.ORDINAL : 순서 저장(default)

- EnumType.STRING : 열거형 이름 그대로 저장 (ordinal 대신 string 사용할 것)

@Lob

: CLOB, BLOB 알아서 매핑

CLOB : char[]

BLOB : byte[]

@Transient

: DB에 저장하지 않는 Column(앱단에서만 사용)

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void main(String args[]) {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");    //factory는 하나만 생성하여 애플리케이션 전체에서 공유
    EntityManager em = emf.createEntityManager();    //요청마다 manager 생성하여 사용
    EntityTransaction tx = em.getTransaction();    //transcation
    tx.begin();
    try {
         Member member = new Member();
         member.setId(1L);
         member.setName("hello");
         em.persist(member);
         tx.commit();
    } catch (Exception e) {
        tx.rollback();
    } finally {
        em.close();
    }
    emf.close();
}
cs

 

 

반응형

'back > JPA' 카테고리의 다른 글

[JPA] equals , hashcode  (0) 2022.11.08
[JPA] JPQL, QueryDSL  (0) 2020.03.21
[JPA] JPA 영속성 컨텍스트  (0) 2020.03.08
[JPA] 연관관계 매핑 : 단방향, 양방향 매핑  (0) 2020.03.01
[JPA] JPA란? : 등장배경, ORM, 하이버네이트  (0) 2020.02.23

+ Recent posts