출처

https://docs.jboss.org/hibernate/orm/current/userguide/html_single/Hibernate_User_Guide.html

http://www.baeldung.com/hibernate-save-persist-update-merge-saveorupdate

http://hibernate.org/search/documentation/getting-started/

http://docs.jboss.org/hibernate/orm/5.2/userguide/html_single/Hibernate_User_Guide.html

https://docs.jboss.org/hibernate/orm/3.3/reference/en-US/html/session-configuration.html

http://docs.jboss.org/hibernate/orm/

http://www.slideshare.net/zipkyh/spring-datajpa?next_slideshow=1

http://www.javajigi.net/pages/viewpage.action?pageId=5924

http://javacan.tistory.com

group 'com.khh'

  version '1.0-SNAPSHOT'

  

  apply plugin: 'java'

  

  sourceCompatibility = 1.5

  

  repositories {

    mavenCentral()

}

  

dependencies {

    /* slf4j */

    compile(group: 'org.slf4j', name: 'slf4j-api', version: '1.7.21')

  

    /* hibernate */

      compile(group: 'org.hibernate', name: 'hibernate-core', version: '5.2.5.Final')

  

    /* lombok */

    compile(group: 'org.projectlombok', name: 'lombok', version: '1.16.8')

  

  

    /*groovy*/

      compile group: 'org.codehaus.groovy', name: 'groovy-all', version: '2.4.6'

    /* class scaner */
    compile (group: 'net.sf.corn', name: 'corn-cps', version: '1.1.7')

    /* h2 database */
    compile(group: 'com.h2database', name: 'h2', version: '1.4.193')

    /* logback-classic */
    compile(group: 'ch.qos.logback', name: 'logback-classic', version: '1.1.8')

    testCompile(group: 'junit', name: 'junit', version: '4.11')
}

build.gradle

package com.khh.hibernate.c0;

import lombok.Data;

import lombok.extern.slf4j.Slf4j;

import org.h2.tools.Server;

import org.hibernate.SessionFactory;

import org.hibernate.boot.registry.StandardServiceRegistryBuilder;

import org.hibernate.cfg.Configuration;

import org.hibernate.cfg.Environment;

import java.sql.SQLException;

  @Data

@Slf4j

  public class HibernateSetting  implements  Runnable{

  

   Server server = null;

   SessionFactory sessionFactory = null;

  

   public HibernateSetting() throws SQLException {

      //H2 Database Start

      server = Server.createWebServer("-web", "-webAllowOthers", "-webPort", "8088").start();

  

      //외부 XML으로 설정

      Configuration configuration = getHibernateConfigByCode();

      //CODE BASE로 설정

      //Configuration configuration = getHibernateConfigByCode();

  

      //Build

      StandardServiceRegistryBuilder serviceRegistryBuilder = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties());

      sessionFactory = configuration.buildSessionFactory(serviceRegistryBuilder.build());

      configuration.buildSessionFactory(serviceRegistryBuilder.build());

   }

  

   public Configuration getHibernateConfigByXML() {

      Configuration configuration = new Configuration();

      configuration.configure("hibernate.cfg.xml");

      return configuration;

   }

   public Configuration getHibernateConfigByCode() {

      Configuration configuration = new Configuration();

      configuration.setProperty(Environment.DIALECT,                   "org.hibernate.dialect.H2Dialect");

      configuration.setProperty(Environment.DRIVER,                    "org.h2.Driver");

      configuration.setProperty(Environment.URL,                       "jdbc:h2:mem:test");

      configuration.setProperty(Environment.USER,                      "sa");

      configuration.setProperty(Environment.POOL_SIZE,                 "55");

      configuration.setProperty(Environment.STATEMENT_BATCH_SIZE,      "30");

      configuration.setProperty(Environment.AUTOCOMMIT,                "true");

      configuration.setProperty(Environment.SHOW_SQL,                  "true");

      configuration.setProperty(Environment.FORMAT_SQL,                "true");

      configuration.setProperty(Environment.CURRENT_SESSION_CONTEXT_CLASS,   "thread");

      configuration.setProperty(Environment.HBM2DDL_AUTO,               "create-drop");

      return configuration;

   }

   public void run() {

   //log.debug("start");

   }

   public static void main(String[] arg)  throws SQLException {

      new HibernateSetting().run();

   }

}

매개변수로 표준 가상머신Standard VM 인수 형식을 사용할수 있다

-Dhibernate.connection.url=jdbc:derby:memory:JH;create=true

-Dhibernate.username=mk

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration SYSTEM "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
   <session-factory>
   <!--
      http://www.tutorialspoint.com/hibernate/hibernate_configuration.htm
      https://docs.jboss.org/hibernate/orm/3.3/reference/en-US/html/session-configuration.html
    -->
      <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
      <property name="hibernate.connection.driver_class">org.h2.Driver</property>
<!--      <property name="hibernate.default_schema">user</property> -->

      <!-- Assume test is the database name -->
      <property name="hibernate.connection.url">jdbc:h2:mem:test</property>
      <property name="hibernate.connection.username">sa</property>
      <property name="hibernate.connection.password"></property>
     
      <!-- JDBC connection pool -->
      <property name="hibernate.connection.pool_size">55</property>
      <property name="hibernate.jdbc.batch_size">30</property>
      <property name="hibernate.connection.autocommit">true</property>
     
<!--      <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property> -->
      <property name="hibernate.show_sql">true</property>
      <property name="hibernate.format_sql">true</property>
<!--      <property name="hibernate.use_sql_comments">true</property> -->
      <!-- current_session  ( e.g. jta | thread | managed | custom.Class )-->
      <property name="hibernate.current_session_context_class">thread</property>
     
      <!-- hbm2ddl.auto ( e.g. validate | update | create | create-drop ) -->
      <property name="hbm2ddl.auto">create-drop</property>
      <!-- List of XML mapping files -->
<!--      <mapping resource="Employee.hbm.xml" /> -->


      <!-- Infinispan 캐시 공급자 지정 -->
      <property name="hibernate.cache.provider_class">
      org.hibernate.cache.infinispan.InfinispanRegionFactory
      </property>
   </session-factory>
</hibernate-configuration>

package com.khh.hibernate.c1.entity;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import javax.persistence.Entity;
import javax.persistence.Id;

@Data
@Entity
public class UserNormal {
   @Id
   Integer seq;
   String name;
   String address;
   Integer age;
}

drop table UserNormal if exists

create table UserNormal (

        seq integer not null,

        address varchar(255),

        age integer,

        name varchar(255),

        primary key (seq)

    )

기본값으로 Entity 클래스 이름이 테이블 이름으로 적용되고  필드 이름이 컬럼 이름으로 생성된다.

package com.khh.hibernate.c1.entity;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Data
@Entity
@Table(name = "USER")
public class UserNaming {
   @Id
   @Column(name = "JUMIN_NUMBER")
   Integer seq;
   @Column(name = "USER_NAME")
   String name;
   @Column(name = "USER_ADDR")
   String address;
   @Column(name = "USER_AGE")
   Integer age;
}

drop table UserNormal if exists

create table USER (

        JUMIN_NUMBER integer not null,

        USER_ADDR varchar(255),

        USER_AGE integer,

        USER_NAME varchar(255),

        primary key (JUMIN_NUMBER)

    )

GenerationType.AUTO

기본 방법으로 다른 데이터베이스 간에도 이용할 수 있다. 하이버네이트에서는

데이터베이스를 기반으로 적절한 ID를 선택한다.

GenerationType.IDENTITY

이 설정은 몇몇 데이터베이스에서 제공하는 identity 함수를 기반으로 한다. 데

이터베이스에서 고유한 식별자를 제공하는 역할을 한다.

GenerationType.SEQUENCE

몇몇 데이터베이스에서는 연속된 숫자에 관한 메커니즘을 제공하는데, 하이버

네이트에서는 일련번호를 사용한다.

GenerationType.TABLE

다른 테이블의 고유한 컬럼 값에서 기본키를 생성하는데, 이 경우 TABLE 생성자

를 사용한다. 시퀀스seqeunce 방법에서는 strategy와 generator 속성을 모두 정의해야 한다.

@Data
@Entity
public class UserGen_AUTO {
   @Id
   @GeneratedValue(strategy = GenerationType.AUTO)
   Integer seq;
   String name;
   String address;
   Integer age;
}

create sequence hibernate_sequence start with 1 increment by 1

create table UserGen_AUTO (

        seq integer not null,

        address varchar(255),

        age integer,

        name varchar(255),

        primary key (seq)

    )

자동으로 hibernate_sequence를 생성한다.

▼실행

Session session = getSessionFactory().getCurrentSession();
      session.beginTransaction();
      UserGen_AUTO user = new UserGen_AUTO();
      user.setName("name");
      user.setAddress("addr");
      user.setAge(100);
      session.save(user);
      session.getTransaction().commit();

insert

    into

        UserGen_AUTO

        (address, age, name, seq)

    values

        (?, ?, ?, ?)

binding parameter [1] as [VARCHAR] - [addr]

binding parameter [2] as [INTEGER] - [100]

binding parameter [3] as [VARCHAR] - [name]

binding parameter [4] as [INTEGER] - [1]

@Data
@Entity
public class UserGen_IDENTITY {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   Integer seq;
   String name;
   String address;
   Integer age;
}

create table UserGen_IDENTITY (

        seq integer generated by default as identity,

        address varchar(255),

        age integer,

        name varchar(255),

        primary key (seq)

    )    )

▼실행

Session session = getSessionFactory().getCurrentSession();

  session.beginTransaction();

  UserGen_IDENTITY user = new UserGen_IDENTITY();

  user.setName("name");

  user.setAddress("addr");

  user.setAge(100);

  session.save(user);

  session.getTransaction().commit();

insert

    into

        UserGen_IDENTITY

        (seq, address, age, name)

    values

        (null, ?, ?, ?)

binding parameter [1] as [VARCHAR] - [addr]

binding parameter [2] as [INTEGER] - [100]

binding parameter [3] as [VARCHAR] - [name]

@Data
@Entity
@SequenceGenerator(name = UserGen_SEQUENCE.SEQUENCE_GEN_NAME, sequenceName = "EMP_SEQ_GEN")
public class UserGen_SEQUENCE {
   public static final String SEQUENCE_GEN_NAME = "empSeqGen";
   @Id
   @GeneratedValue (strategy = GenerationType.SEQUENCE, generator = SEQUENCE_GEN_NAME)
   Integer seq;
   String name;
   String address;
   Integer age;
}

create sequence EMP_SEQ_GEN start with 1 increment by 50

create table UserGen_SEQUENCE (

        seq integer not null,

        address varchar(255),

        age integer,

        name varchar(255),

        primary key (seq)

    )

▼실행

Session session = getSessionFactory().getCurrentSession();
      session.beginTransaction();
      UserGen_SEQUENCE user = new UserGen_SEQUENCE();
      user.setName("name");
      user.setAddress("addr");
      user.setAge(100);
      session.save(user);
      session.getTransaction().commit();

insert

    into

        UserGen_SEQUENCE

        (address, age, name, seq)

    values

        (?, ?, ?, ?)

15:18 TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [1] as [VARCHAR] - [addr]

15:18 TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [2] as [INTEGER] - [100]

15:18 TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [3] as [VARCHAR] - [name]

15:18 TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [4] as [INTEGER] - [1]

@Data
@Entity
@TableGenerator(name = UserGen_TABLE.TABLE_GEN_NAME, table = "USER_ID_TABLE")
public class UserGen_TABLE {
   public static final String TABLE_GEN_NAME = "empTableGen";
   @Id
   @GeneratedValue (strategy = GenerationType.TABLE, generator = TABLE_GEN_NAME)
   Integer seq;
   String name;
   String address;
   Integer age;
}

create table USER_ID_TABLE (

        sequence_name varchar(255) not null,

        next_val bigint,

        primary key (sequence_name)

    )

create table UserGen_TABLE (

        seq integer not null,

        address varchar(255),

        age integer,

        name varchar(255),

        primary key (seq)

    )

▼실행

Session session = getSessionFactory().getCurrentSession();
session.beginTransaction();

UserGen_TABLE user = new UserGen_TABLE();
user.setName("name");
session.save(user);

session.getTransaction().commit();

select

        tbl.next_val

    from

        USER_ID_TABLE tbl

    where

        tbl.sequence_name=? for update

    insert

    into

        USER_ID_TABLE

        (sequence_name, next_val) 

    values

    update

        USER_ID_TABLE

    set

        next_val=? 

    where

        next_val=?

    select

        tbl.next_val

    from

        USER_ID_TABLE tbl

    where

        tbl.sequence_name=? for update

    update

        USER_ID_TABLE

    set

        next_val=? 

    where

        next_val=?

insert

    into

        UserGen_TABLE

        (address, age, name, seq)

    values

        (?, ?, ?, ?)

13:35 TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [1] as [VARCHAR] - [null]

13:35 TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [2] as [INTEGER] - [null]

13:35 TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [3] as [VARCHAR] - [name]

13:35 TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [4] as [INTEGER] - [1]

ID 값으로 사용되는 클래스에서 구현해야될것들

1.     Default Constructor()

2.     hashCode()

3.     equals()

4.  implements Serializable

tip : Lombok lib사용한다면 위 내용을 자동으로 생성해준다.( https://projectlombok.org/ )

@Data
@Embeddable
public class UserPK_Embededdable implements Serializable{
   String name;
   Integer number;
}

@Data
@Entity
public class UserInfo{
   @Id
   UserPK_Embededdable id;
   String address;
   Integer age;
}

create table UserInfo (

        name varchar(255) not null,

        number integer not n

ull,

        address varchar(255),

        age integer,

        primary key (name, number)

    )

Session session = getSessionFactory().getCurrentSession();
session.beginTransaction();

UserPK_Embededdable pk = new UserPK_Embededdable();
pk.setName("name");
pk.setNumber(128);

UserInfo_Embededdable user = new UserInfo_Embededdable();
user.setId(pk);
user.setAddress("korea");
user.setAge(53);

session.save(user);
session.getTransaction().commit();

insert

    into

        UserInfo_Embededdable

        (address, age, name, number)

    values

        (?, ?, ?, ?)

binding parameter [1] as [VARCHAR] - [korea]

binding parameter [2] as [INTEGER] - [53]

binding parameter [3] as [VARCHAR] - [name]

binding parameter [4] as [INTEGER] - [128]

//select
      UserPK_Embededdable userPK = new UserPK_Embededdable();
UserPK_IdClass();
      userPK.setName("name");
      userPK.setNumber(128);
      UserInfo_Embededdable userBydb = session.get(UserInfo_Embededdable.class,userPK);
      log.info("get::"+userBydb.toString());

select

        userinfo_e0_.name as name1_1_0_,

        userinfo_e0_.number as number2_1_0_,

        userinfo_e0_.address as address3_1_0_,

        userinfo_e0_.age as age4_1_0_

    from

        UserInfo_Embededdable userinfo_e0_

    where

        userinfo_e0_.name=?

        and userinfo_e0_.number=?

binding parameter [1] as [VARCHAR] - [name]

binding parameter [2] as [INTEGER] - [128]

get::UserInfo_Embededdable(id=UserPK_Embededdable(name=name, number=128), address=korea, age=53)

tip : @Embeddable 을 선언하지 않고 @Id 로 사용한다면  해당클래스의 toString()값이 들어간다

@Data

  public class UserPK_EmbeddedId implements Serializable{

   String name;

   Integer number;

  }

@Data
@Entity
public class UserInfo_EmbeddedId {
   @EmbeddedId
   UserPK_Embededdable id;
   String address;
   Integer age;
}

create table UserInfo_EmbeddedId (

        name varchar(255) not null,

        number integer not null,

        address varchar(255),

        age integer,

        primary key (name, number)

    )

Session session = getSessionFactory().getCurrentSession();
      session.beginTransaction();


      UserPK_EmbeddedId pk = new UserPK_EmbeddedId();
      pk.setName("name");
      pk.setNumber(128);

      UserInfo_EmbeddedId user = new UserInfo_EmbeddedId();
      user.setId(pk);
      user.setAddress("korea");
      user.setAge(53);

      session.save(user);
      session.getTransaction().commit();

insert

    into

        UserInfo_EmbeddedId

        (address, age, name, number)

    values

        (?, ?, ?, ?)

binding parameter [1] as [VARCHAR] - [korea]

binding parameter [2] as [INTEGER] - [53]

binding parameter [3] as [VARCHAR] - [name]

binding parameter [4] as [INTEGER] - [128]

//select
      UserPK_EmbeddedId userPK = new UserPK_EmbeddedId();
      userPK.setName("name");
      userPK.setNumber(128);
      UserInfo_EmbeddedId userBydb = session.get(UserInfo_EmbeddedId.class,userPK);
      log.info("get::"+userBydb.toString());

select

        userinfo_e0_.name as name1_0_0_,

        userinfo_e0_.number as number2_0_0_,

        userinfo_e0_.address as address3_0_0_,

        userinfo_e0_.age as age4_0_0_

    from

        UserInfo_EmbeddedId userinfo_e0_

    where

        userinfo_e0_.name=?

        and userinfo_e0_.number=?

binding parameter [1] as [VARCHAR] - [name]

binding parameter [2] as [INTEGER] - [128]

get::UserInfo_EmbeddedId(id=UserPK_EmbeddedId(name=name, number=128), address=korea, age=53)

@Data
public class UserPK_IdClass implements Serializable{
   String name;
   Integer number;
}

@Data
@Entity
@IdClass(UserPK_IdClass.class)
public class UserInfo_IdClass {
   @Id
   String name;
   @Id
   Integer number;
   String address;
   Integer age;
}

create table UserInfo_IdClass (

        name varchar(255) not null,

        number integer not null,

        address varchar(255),

        age integer,

        primary key (name, number)

    )

▼실행

Session session = getSessionFactory().getCurrentSession();
      session.beginTransaction();

      UserInfo_IdClass pk = new UserInfo_IdClass();
      pk.setName("name");
      pk.setNumber(128);

      UserInfo_IdClass user = pk;
      user.setAddress("korea");
      user.setAge(53);

      session.save(user);
      session.getTransaction().commit();

insert

    into

        UserInfo_IdClass

        (address, age, name, number)

    values

        (?, ?, ?, ?)

binding parameter [1] as [VARCHAR] - [korea]

binding parameter [2] as [INTEGER] - [53]

binding parameter [3] as [VARCHAR] - [name]

binding parameter [4] as [INTEGER] - [128]

UserPK_IdClass userPK = new UserPK_IdClass();
userPK.setName("name");
userPK.setNumber(128);
UserInfo_IdClass userBydb = session.get(UserInfo_IdClass.class,userPK);
log.info("get::"+userBydb.toString());

select

        userinfo_i0_.name as name1_2_0_,

        userinfo_i0_.number as number2_2_0_,

        userinfo_i0_.address as address3_2_0_,

        userinfo_i0_.age as age4_2_0_

    from

        UserInfo_IdClass userinfo_i0_

    where

        userinfo_i0_.name=?

        and userinfo_i0_.number=?

binding parameter [1] as [VARCHAR] - [name]

binding parameter [2] as [INTEGER] - [128]

get::UserInfo_IdClass(name=name, number=128, address=korea, age=53)

일대일 1:1

한 테이블에서 각 레코드는 반드시 다른 테이블 의

레코드 한 개와 관계가 있다. 반대의 경우도 마찬가지다.

다른 테이블의 레코드는 0일 수도 있다.

자동차 한 대는 오직 한 개의 엔진만 가진다.

일대다

또는

다대일

1:N,  N:1

한 테이블에서 각 레코드는 다른 테이블의 0개

또는 그 이상의 레코드와 관계가 있다.

영화 한 편은 많은

배우를 가진다(일대다)

배우 한 명은 여러 작품에서

연기할 수 있다 (다대일).

N:N

양쪽 테이블 모두 각 레코드가 다른 쪽 테이블의

0개 또는 그 이상의 레코드와 관계가 있다.

타입

행위

언제

CascadeType.DETACH

엔티티가 Persistence Context에서 제거되면 (엔티티가 분리 될 것입니다)이 작업은 관계에 반영됩니다.

Finished Persistence Context

또는 entityManager.detach ()

entityManager.clear ()

CascadeType.MERGE

엔티티에 업데이트 된 데이터가 있으면이 작업이 관계에 반영됩니다

엔티티가 갱신되고 트랜잭션이 완료되거나, entityManager.merge ()

CascadeType.PERSIST

새로운 엔티티가 데이터베이스에 유지되면이 조치가 관계에 반영됩니다.

트랜잭션이 끝나거나, entityManager.persist ()

CascadeType.REFRESH

엔티티가 데이터베이스와 동기화 된 데이터를 가질 때이 조치가 반영됩니다

entityManager.refresh ()

CascadeType.REMOVE

엔터티가 데이터베이스에서 삭제되면
행동이 관계에 반영 될 것입니다.

entityManager.remove ()

CascadeType.ALL

위의 조치 중 하나가 JPA 또는 명령에 의해 호출 될 때,이 조치는 관계에 반영됩니다.

위에 설명 된 명령이나 행동.

쉽게 말하기 : 객체 상태 전이 타입  (보통 ALL을 사용한다)

1. FK지정

@Data
@Entity
public class User_OneToOne {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   Integer seq;
   String name;
   String password;
   @OneToOne(cascade = CascadeType.ALL)
   UserInfo info;
}

@Data

@Entity

  public class UserInfo {

   @Id

   @GeneratedValue(strategy = GenerationType.AUTO)

   Integer seq;

   String addr;

   double weight;

   double height;

  }

create table UserInfo (

        seq integer not null,

        addr varchar(255),

        height double not null,

        weight double not null,

        primary key (seq)

    create table User_OneToOne (

        seq integer generated by default as identity,

        name varchar(255),

        password varchar(255),

        info_seq integer,

        primary key (seq)

 alter table User_OneToOne

        add constraint FKmn264qa7ngjx89j3u9a2l7ql2

        foreign key (info_seq)

        references UserInfo

집고 넘어가기 : 자동으로 User_OneToOne Table(부모테이블)에 INFO_SEQ컬럼 생기고 FK를건다

▼실행

Session session = getSessionFactory().getCurrentSession();
session.beginTransaction();

UserInfo info = new UserInfo();
info.setAddr("addr");
info.setHeight(180);
info.setWeight(70);

User_OneToOne user = new User_OneToOne();
user.setName("name");
user.setPassword("pwd");
user.setInfo(info);

session.save(user);

session.getTransaction().commit();

insert

    into

        UserInfo

        (addr, height, weight, seq)

    values

        (?, ?, ?, ?)

binding parameter [1] as [VARCHAR] - [addr]

binding parameter [2] as [DOUBLE] - [180.0]

binding parameter [3] as [DOUBLE] - [70.0]

insert

    into

        User_OneToOne

        (seq, info_seq, name, password)

    values

        (null, ?, ?, ?)

binding parameter [1] as [INTEGER] - [1]

binding parameter [2] as [VARCHAR] - [name]

binding parameter [3] as [VARCHAR] - [pwd]

1. PK를 FK지정  (아주 중요함)

@Data
@Entity
@SequenceGenerator(name = User.SEQ_NAME, sequenceName = User.SEQ_NAME, initialValue = 100, allocationSize = 1)
public class User {
   public static final String SEQ_NAME = "SEQ_USER";
   @Id
   @GeneratedValue(strategy = GenerationType.SEQUENCE,generator = SEQ_NAME)
   @Column(name = "USER_SEQ")
   Integer seq;
   String name;
   String password;
   @OneToOne(cascade = CascadeType.ALL)
   @JoinColumn(name = "USER_SEQ", referencedColumnName="SEQ")
// @PrimaryKeyJoinColumn(name = "USER_SEQ", referencedColumnName="SEQ")
   UserInfo info;
}

@Data
@Entity
@GenericGenerator(name = "generator", strategy = "foreign", parameters = @Parameter(name = "property", value = "user"))
public class UserInfo {
   @Id
   @Column(name = "SEQ")
   @GeneratedValue(generator = "generator")
   Integer seq;
   String addr;
   double weight;
   double height;

   @OneToOne(cascade = CascadeType.ALL, mappedBy = "info")
   User user;

}

create table User (

        USER_SEQ integer not null,

        name varchar(255),

        password varchar(255),

        primary key (USER_SEQ)

    )

create table UserInfo (

        SEQ integer not null,

        addr varchar(255),

        height double not null,

        weight double not null,

        primary key (SEQ)

    )

▼ 실행

Session session = getSessionFactory().getCurrentSession();
      session.beginTransaction();

      UserInfo info = new UserInfo();
      info.setAddr("addr");
      info.setHeight(180);
      info.setWeight(70);

      User user = new User();
      user.setName("name");
      user.setPassword("pwd");
     
      //서로의 관계를 맺어준다.
      user.setInfo(info);
      info.setUser(user);   

      session.save(user);
      session.flush();
      session.clear();

      UserInfo userInfoBydb = session.get(UserInfo.class,100);
      if(null!=userInfoBydb && null!=userInfoBydb.getUser())
         log.debug("get(DB) Entity ---> "+userInfoBydb.getUser().getName());

      session.getTransaction().commit();

call next value for SEQ_USER

Sequence value obtained: 100

insert

    into

        User

        (name, password, USER_SEQ)

    values

        (?, ?, ?)

 [1] as [VARCHAR] - [name]

 [2] as [VARCHAR] - [pwd]

    insert

    into

        UserInfo

        (addr, height, weight, SEQ)

    values

        (?, ?, ?, ?)

 [1] as [VARCHAR] - [addr]

 [2] as [DOUBLE] - [180.0]

 [3] as [DOUBLE] - [70.0]

    select

        userinfo0_.SEQ as SEQ1_1_0_,

        userinfo0_.addr as addr2_1_0_,

        userinfo0_.height as height3_1_0_,

        userinfo0_.weight as weight4_1_0_,

        user1_.USER_SEQ as USER_SEQ1_0_1_,

        user1_.name as name2_0_1_,

        user1_.password as password3_0_1_

    from

        UserInfo userinfo0_

    left outer join

        User user1_

            on userinfo0_.SEQ=user1_.USER_SEQ

    where

        userinfo0_.SEQ=?

get(DB) Entity ---> name

자동으로 부모 테이블의 PK값을 가지고 자신의 FK쪽 값으로 사용한다

@GenericGenerator(name = "generator", strategy = "foreign", parameters = @Parameter(name = "property", value = "user"))

....

@GeneratedValue(generator = "generator")
Integer seq;

value값은 부모Entity객체 필드명

집고 넘어가기 : @JoinColumn(name = "USER_SEQ", referencedColumnName="SEQ")
name = 자기 자신 테이블의 FK대상 컬럼명

referencedColumnName = 자식테이블 컬럼명 (안적으면 자동으로 자식테이블 ID로 해준다.)

또한 PrimaryKeyJoinColumn을 쓸수도 있다

@PrimaryKeyJoinColumn(name = "USER_SEQ", referencedColumnName="SEQ")

@Data
@Entity
@SequenceGenerator(name = User.SEQ_NAME, sequenceName = User.SEQ_NAME, initialValue = 100, allocationSize = 1)
public class User {
   public static final String SEQ_NAME = "SEQ_USER";
   @Id
   @GeneratedValue(strategy = GenerationType.SEQUENCE,generator = SEQ_NAME)
   @Column(name = "USER_SEQ")
   Integer seq;
   String name;
   String password;
   @OneToOne(cascade = CascadeType.ALL)
   UserInfo info;
}

@Data
@Entity
@GenericGenerator(name = "generator", strategy = "foreign", parameters = @Parameter(name = "property", value = "user"))
public class UserInfo {
   @Id
   @Column(name = "SEQ")
   @GeneratedValue(generator = "generator")
   Integer seq;
   String addr;
   double weight;
   double height;

   @OneToOne(cascade = CascadeType.ALL, mappedBy = "info")
   User user;

}

UserInfo Entity (자식테이블) 에서 부모Entity에서 선언된 자식Entity의 필드명을 적으면된다

@OneToOne(mappedBy = “code feildName”)

집고 넘어가기 : insert했을때 Entity는 관계설정이 되어있지 않아 로그가 찍히지 않는다 하지만 다시 SELECT해온 Entity는 방향성 설정이 되어 넘어온다 여기서 알수 있는것은 insert했을때 사용했던 Entity와 get해온 Entity는 다르다는것을 알수 있다.

▼ OneToMany조인하기 맵핑 테이블 만들어 조인하기

@Data
@Entity
public class User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   Integer seq;
   String name;
   String password;

   @OneToMany(cascade = CascadeType.ALL)
   List<Auth> auths = null;
}

@Data

@Entity

  @SequenceGenerator(name = Auth.SEQUENCE_NAME, sequenceName = Auth.SEQUENCE_NAME, initialValue = 100)

  public class Auth implements Serializable {

   public static final String SEQUENCE_NAME = "AUTH_SEQ";

   @Id

   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = SEQUENCE_NAME)

   Integer seq;

   String auth;

   Date expiry;

  }

create table Auth (

        seq integer not null,

        auth varchar(255),

        expiry timestamp,

        primary key (seq)

    create table User (

        seq integer generated by default as identity,

        name varchar(255),

        password varchar(255),

        primary key (seq)

-- 새로운 맵핑 테이블이 생긴다

    create table User_Auth (

        User_seq integer not null,

        auths_seq integer not null

    alter table User_Auth

    alter table User_Auth

        add constraint FKmnns1wp8mo27pxkbbwjl8nuun

        foreign key (auths_seq)

    alter table User_Auth

        add constraint FKn1dj4srm089e409sq8vkhogug

        foreign key (User_seq)

        references User

▼맵핑 테이블 이름바꾸기

@Data
@Entity
public class User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   Integer seq;
   String name;
   String password;

   @OneToMany(cascade = CascadeType.ALL)
   @JoinTable(name = "USER_AUTH_MAPPING")
   List<Auth> auths = null;
}

▼실행

Session session = getSessionFactory().getCurrentSession();
      session.beginTransaction();

      Auth auth1 = new Auth();
      auth1.setAuth("ROLE_ADMIB");
      auth1.setExpiry(new Date());
      Auth auth2 = new Auth();
      auth2.setAuth("ROLE_USER");
      auth2.setExpiry(new Date());

      User user = new User();
      user.setAuths(Arrays.asList(auth1,auth2));
      user.setName("name");
      user.setPassword("pwd");

      session.save(user);
      session.getTransaction().commit();

insert

    into

        Auth

        (auth, expiry, seq)

    values

        (?, ?, ?)

binding parameter [1] as [VARCHAR] - [ROLE_ADMIB]

binding parameter [2] as [TIMESTAMP] - [Sat Dec 17 14:27:21 KST 2016]

    insert

    into

        Auth

        (auth, expiry, seq)

    values

        (?, ?, ?)

binding parameter [1] as [VARCHAR] - [ROLE_USER]

binding parameter [2] as [TIMESTAMP] - [Sat Dec 17 14:27:21 KST 2016]

    insert

    into

        User_Auth

        (User_seq, auths_seq)

    values

        (?, ?)

binding parameter [1] as [INTEGER] - [1]

    insert

    into

        User_Auth

        (User_seq, auths_seq)

    values

        (?, ?)

binding parameter [1] as [INTEGER] - [1]

binding parameter [2] as [INTEGER] - [101]

@Data
@Entity
@SequenceGenerator(name = User.SEQUENCE_NAME, sequenceName = User.SEQUENCE_NAME, initialValue = 100, allocationSize = 1)
public class User {
   public static final String SEQUENCE_NAME = "USER_SEQ";
   @Id
   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = SEQUENCE_NAME)
   @Column(name = "USER_SEQ")
   Integer seq;
   String name;
   String password;

   @OneToMany(cascade = CascadeType.ALL)
   @JoinColumn(name = "USER_SEQ", referencedColumnName = "USER_SEQ")
   @OrderColumn
   private AuthComposite[] auths;
}

user.setAuths(Stream.of(authc1,authc2).peek(it->{it.setUser(user);}).toArray(AuthComposite[]::new));

집고 넘어가기 : Array사용할때에는 @OrderColumn으로 선언해야된다.

@OrderColumn은 Index값이 들어가도록 하는것입니다.

@Data

@Entity

@SequenceGenerator(name = User.SEQUENCE_NAME, sequenceName = User.SEQUENCE_NAME, initialValue = 100, allocationSize = 1)

  public class User {

   public static final String SEQUENCE_NAME = "USER_SEQ";

   @Id

   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = SEQUENCE_NAME)

     @Column(name = "USER_SEQ")

   Integer seq;

   String name;

   String password;

  

   @OneToMany(cascade = CascadeType.ALL)

     @JoinColumn(name = "USER_SEQ", referencedColumnName = "USER_SEQ")

     private Set<AuthComposite> auths;

  }

user.setAuths(Stream.of(authc1,authc2).peek(it->{it.setUser(user);}).collect(Collectors.toSet()));

@Data

@Entity

@SequenceGenerator(name = User.SEQUENCE_NAME, sequenceName = User.SEQUENCE_NAME, initialValue = 100, allocationSize = 1)

  public class User {

   public static final String SEQUENCE_NAME = "USER_SEQ";

   @Id

   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = SEQUENCE_NAME)

     @Column(name = "USER_SEQ")

   Integer seq;

   String name;

   String password;

  

   @OneToMany(cascade = CascadeType.ALL)

     @JoinColumn(name = "USER_SEQ", referencedColumnName = "USER_SEQ")

     private Map<String,AuthComposite> auths;

}

user.setAuths(Stream.of(authc1,authc2).peek(it->{it.setUser(user);}).

collect(Collectors.toMap(c-> c.getAuth(),c->c)));

▼바로 OneToMany조인하기(맵핑테이블 없음) (자식테이블 인조식별자 + 유니크 인덱스)

@Data
@Entity
public class User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   Integer seq;
   String name;
   String password;

   @OneToMany(cascade = CascadeType.ALL)
   @JoinColumn
   List<Auth> auths = null;
}

@Data
@Entity
@SequenceGenerator(name = Auth.SEQUENCE_NAME, sequenceName = Auth.SEQUENCE_NAME, initialValue = 100)
public class Auth implements Serializable {
   public static final String SEQUENCE_NAME = "AUTH_SEQ";
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   Integer seq;
   String auth;
   Date expiry;
}

▼자식테이블 FK 컬럼 명바꾸기

Data

@Entity

  public class User {

   @Id

   @GeneratedValue(strategy = GenerationType.IDENTITY)

   Integer seq;

   String name;

   String password;

  

   @OneToMany(cascade = CascadeType.ALL)

   @JoinColumn(name = "USER_SEQ")

   List<Auth> auths = null;

  }

집고 넘어가기 : OneToOne에서는 자기자신 컬럼을 가르켰지만 OneToMany에서는 자식컬럼을 말한다.

▼PK를 FK지정 (맵핑 테이블 없음)

@Data
@Entity
@SequenceGenerator(name = User.SEQUENCE_NAME, sequenceName = User.SEQUENCE_NAME, initialValue = 100)
public class User {
   public static final String SEQUENCE_NAME = "USER_SEQ";
   @Id
   Integer seq;
   String name;
   String password;

   @OneToMany(cascade = CascadeType.ALL)
   @JoinColumn(name = "USER_SEQ", referencedColumnName = "SEQ")
   List<Auth> auths = null;
}

@Data
@Entity
@SequenceGenerator(name = Auth.SEQUENCE_NAME, sequenceName = Auth.SEQUENCE_NAME, initialValue = 100)
public class Auth implements Serializable {
   public static final String SEQUENCE_NAME = "AUTH_SEQ";
   @Id
   @Column(name = "USER_SEQ")
   Integer seq;
   @Id
   String auth;
   Date expiry;
}

▼실행

Session session = getSessionFactory().getCurrentSession();
session.beginTransaction();

Auth auth1 = new Auth();
auth1.setAuth("ROLE_ADMIB");
auth1.setExpiry(new Date());
Auth auth2 = new Auth();
auth2.setAuth("ROLE_USER");
auth2.setExpiry(new Date());

User user = new User();
user.setSeq(50);
user.setAuths(Stream.of(auth1,auth2).peek(it->it.setSeq(user.getSeq())).collect(Collectors.toList()));
user.setName("name");
user.setPassword("pwd");
session.save(user);
session.getTransaction().commit();

집고 넘어가기 : (PK를 FK지정) (맵핑 테이블 없음) 는 좀 문제가 있다. 수동으로 KEY값을 맵핑시켜줘다.

자동으로 맵핑할수 있는 방법도 있다. (아래에서 알아보자)

@GenericGenerator(name = "generator", strategy = "foreign", parameters = @Parameter(name = "property", value = "user"))

http://howtodoinjava.com/hibernate/hibernate-one-to-many-mapping-using-annotations/

https://en.wikibooks.org/wiki/Java_Persistence/OneToMany

http://www.beingjavaguys.com/2013/09/hibernate-one-to-many-mapping.html

http://levelup.lishman.com/hibernate/associations/one-to-many.php

▼PK를 FK지정 (맵핑 테이블 없음) GeneratedValue값으로 KEY값 처리시 문제.

@Data
@Entity
@SequenceGenerator(name = User.SEQUENCE_NAME, sequenceName = User.SEQUENCE_NAME, initialValue = 100)
public class User {
   public static final String SEQUENCE_NAME = "USER_SEQ";
   @Id
   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = SEQUENCE_NAME)
   @Column(name = "USER_SEQ")
   Integer seq;
   String name;
   String password;
   @OneToMany(cascade = CascadeType.ALL)
   @JoinColumn(name = "USER_SEQ", referencedColumnName = "USER_SEQ")
   private List<AuthComposite> auths;
}

@Data
@Entity
@SequenceGenerator(name = AuthComposite.SEQUENCE_NAME, sequenceName = AuthComposite.SEQUENCE_NAME, initialValue = 50)
public class AuthComposite implements Serializable{
   public static final String SEQUENCE_NAME = "AUTHCOMPOSITE_SEQ";

   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = SEQUENCE_NAME)
   @Id
   @Column(name = "USER_SEQ",nullable = false)
   Integer seq;
   @Id
   @Column(nullable = false)
   String auth;

   Date expiry;

}

insert

    into

        User

        (name, password, USER_SEQ)

    values

        (?, ?, ?)

12:08:37 TRACE : binding parameter [1] as [VARCHAR] - [name]

12:08:37 TRACE : binding parameter [2] as [VARCHAR] - [pwd]

    insert

    into

        AuthComposite

        (expiry, USER_SEQ, auth)

    values

        (?, ?, ?)

12:08:37 TRACE : binding parameter [1] as [TIMESTAMP] - [Sun Dec 18 12:08:36 KST 2016]

12:08:37 TRACE : binding parameter [2] as [INTEGER] - [50]

    insert

    into

        AuthComposite

        (expiry, USER_SEQ, auth)

    values

        (?, ?, ?)

12:08:37 TRACE : binding parameter [1] as [TIMESTAMP] - [Sun Dec 18 12:08:36 KST 2016]

12:08:37 TRACE : binding parameter [2] as [INTEGER] - [51]

12:08:37 TRACE : binding parameter [3] as [VARCHAR] - [ROLE_USER]

ERROR : HHH000315: Exception executing batch [org.h2.jdbc.JdbcBatchUpdateException: Referential integrity constraint violation: "FKOU1XVFC0SWVOFR46KFD8KHY1N: PUBLIC.AUTHCOMPOSITE FOREIGN KEY(USER_SEQ) REFERENCES PUBLIC.USER(USER_SEQ) (51)"; SQL statement:

AuthComposite authc1 = new AuthComposite();
      authc1.setAuth("ROLE_ADMIN");
      authc1.setExpiry(new Date());
      AuthComposite authc2 = new AuthComposite();
      authc2.setAuth("ROLE_USER");
      authc2.setExpiry(new Date());

      User user = new User();
      user.setAuths(Stream.of(authc1,authc2).collect(Collectors.toList()));
      user.setName("name");
      user.setPassword("pwd");
      log.debug("---->"+user.getSeq());
      session.save(user);

집고 넘어가기 : 부모Entity와 자식Entity에 관계가 맺어있지만 각각클래스의 ID값에 GeneratedValue 설정했기_문에 각각 시퀀스 값으로 들어간다 여기서 FK제약조건이 걸려 오류가 난것이다.

save 할때 어떻게 해야될까?

1. 이렇게 해보자

부모Entity는 ID는 GeneratedValue  자식Entity은 GeneratedValue사용하지 않고 자동으로 넘어가도록 기대해보자

@Data
@Entity
public class AuthComposite implements Serializable{
   @Id
   @Column(name = "USER_SEQ",nullable = false)
   Integer seq;
   @Id
   @Column(nullable = false)
   String auth;
   Date expiry;
}

insert

    into

        User

        (name, password, USER_SEQ)

    values

        (?, ?, ?)

parameter [1] as [VARCHAR] - [name]

parameter [2] as [VARCHAR] - [pwd]

    insert

    into

        AuthComposite

        (expiry, USER_SEQ, auth)

    values

        (?, ?, ?)

parameter [1] as [TIMESTAMP] - [Sun Dec 18 13:10:36 KST 2016]

parameter [2] as [INTEGER] - [null]

    insert

    into

        AuthComposite

        (expiry, USER_SEQ, auth)

    values

        (?, ?, ?)

parameter [1] as [TIMESTAMP] - [Sun Dec 18 13:10:36 KST 2016]

parameter [2] as [INTEGER] - [null]

parameter [3] as [VARCHAR] - [ROLE_USER]

기대는 했지만 자동으로 넘어가지 않는다.  그저 NULL값이 들어간다 정직하다.. 오류난다

2. 이렇게 해보자  (나눠서 save하자)

부모Entity만 save 선행후~ 부모Entity에서 추출된 ID (SEQUENCE) 값을 가지고

자식Entity ID값으로 지정  그뒤 자식Entity를 save해보자

AuthComposite authc1 = new AuthComposite();

      authc1.setAuth("ROLE_ADMIN");

      authc1.setExpiry(new Date());

      AuthComposite authc2 = new AuthComposite();

      authc2.setAuth("ROLE_USER");

      authc2.setExpiry(new Date());

      User user = new User();

user.setAuths(Stream.of(authc1,authc2).collect(Collectors.toList()));
      user.setName("name");
      user.setPassword("pwd");
      log.debug("---->"+user.getSeq());
      session.save(user);
      log.debug("---->"+user.getSeq());
      user.getAuths().forEach(it->it.setSeq(user.getSeq()));

---->null

    call next value for USER_SEQ

Sequence value obtained: 100

HHH000387: ResultSet's statement was not registered

Generated identifier: 100, using strategy: org.hibernate.id.enhanced.SequenceStyleGenerator

insert

    into

        User

        (name, password, USER_SEQ)

    values

        (?, ?, ?)

parameter [1] as [VARCHAR] - [name]

parameter [2] as [VARCHAR] - [pwd]

insert

    into

        AuthComposite

        (expiry, USER_SEQ, auth)

    values

        (?, ?, ?)

parameter [1] as [TIMESTAMP] - [Sun Dec 18 13:21:49 KST 2016]

parameter [2] as [INTEGER] - [100]

    insert

    into

        AuthComposite

        (expiry, USER_SEQ, auth)

    values

        (?, ?, ?)

parameter [1] as [TIMESTAMP] - [Sun Dec 18 13:21:49 KST 2016]

parameter [2] as [INTEGER] - [100]

parameter [3] as [VARCHAR] - [ROLE_USER]

집고 넘어가기 1 : 부모Entity만 save후 자식Entity List를 넣은뒤 다시 save했다

여기서 알수 있듯 save 를 타게되면 바로 시퀀스 값을 가져와 바인딩 시켜주니 그것을 가지고 자식 셋팅후 commit을 하면 그때 가서 자식 Entity에 바인딩된 ID값으로 insert된다.

집고 넘어가기 2 : PK를 PK복합키로만 구성하는 방법과, 인조식별자+유니크 인덱스로

구성하는것은 아직도 많은 논쟁있다.  하지만 어느정도 대세는 인조식별자+유니크 를 두는것으로

많이 기울었습니다. http://okky.kr/article/257331

3. 이렇게 해보자  (자식Entity에 ID값을 부모Entity의 ID값으로 자동 save하자) 베스트!

@Data
@Entity
@SequenceGenerator(name = User.SEQUENCE_NAME, sequenceName = User.SEQUENCE_NAME, initialValue = 100, allocationSize = 1)
public class User {
   public static final String SEQUENCE_NAME = "USER_SEQ";
   @Id
   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = SEQUENCE_NAME)
   @Column(name = "USER_SEQ")
   Integer seq;
   String name;
   String password;

   @OneToMany(cascade = CascadeType.ALL)
   @JoinColumn(name = "USER_SEQ", referencedColumnName = "USER_SEQ")
   private List<AuthComposite> auths;
}

@Data
@Entity
@GenericGenerator(name = "generator", strategy = "foreign", parameters = @Parameter(name = "property", value = "user"))
public class AuthComposite implements Serializable{
   @Id
   @Column(name = "USER_SEQ",nullable = false)
   @GeneratedValue(generator = "generator")
   Integer seq;
   @Id
   @Column(nullable = false)
   String auth;
  
   Date expiry;

   @ManyToOne(cascade = CascadeType.ALL)
   @JoinColumn(name="USER_SEQ", nullable=false,updatable=false,insertable=false)
   User user;

}

AuthComposite authc1 = new AuthComposite();
      authc1.setAuth("ROLE_ADMIN");
      authc1.setExpiry(new Date());
      AuthComposite authc2 = new AuthComposite();
      authc2.setAuth("ROLE_USER");
      authc2.setExpiry(new Date());

      User user = new User();
      user.setAuths(Stream.of(authc1,authc2).peek(it->{it.setUser(user);}).collect(Collectors.toList()));
      user.setName("name");
      user.setPassword("pwd");
      Serializable id = session.save(user);

insert

    into

        User

        (name, password, USER_SEQ)

    values

        (?, ?, ?)

10:44:27 TRACE : binding parameter [1] as [VARCHAR] - [name]

10:44:27 TRACE : binding parameter [2] as [VARCHAR] - [pwd]

10:44:27 TRACE : binding parameter [3] as [INTEGER] - [100]

10:44:27 DEBUG : Executing batch size: 1

10:44:27 DEBUG :

    insert

    into

        AuthComposite

        (expiry, USER_SEQ, auth)

    values

        (?, ?, ?)

10:44:27 TRACE : binding parameter [1] as [TIMESTAMP] - [Wed Dec 21 10:44:27 KST 2016]

10:44:27 TRACE : binding parameter [2] as [INTEGER] - [100]

10:44:27 TRACE : binding parameter [3] as [VARCHAR] - [ROLE_ADMIN]

10:44:27 DEBUG : Reusing batch statement

10:44:27 DEBUG :

    insert

    into

        AuthComposite

        (expiry, USER_SEQ, auth)

    values

        (?, ?, ?)

10:44:27 TRACE : binding parameter [1] as [TIMESTAMP] - [Wed Dec 21 10:44:27 KST 2016]

10:44:27 TRACE : binding parameter [2] as [INTEGER] - [100]

10:44:27 TRACE : binding parameter [3] as [VARCHAR] - [ROLE_USER]

객체간 관계만 맺어주면 (변수 값셋팅)

자동으로 부모Entity값을 가지고 자기자신ID값으로 사용하는걸 알수 있다.

https://www.mkyong.com/hibernate/hibernate-one-to-one-relationship-example-annotation/

http://www.codejava.net/frameworks/hibernate/hibernate-one-to-one-association-on-primary-key-annotations-example

집고 넘어가기 1 : @MonyToOne 쪽에 @JoinColums 를 사용하여  자기자신 테이블 컬럼명을 지정할수도있다.

@ManyToOne(cascade = CascadeType.ALL)
@JoinColumn(name="USER_SEQ", nullable=false,updatable=false,insertable=false)
User user;

지연로딩 FetchType.LAZY  (기본값)

@Data

@Entity

@SequenceGenerator(name = User.SEQUENCE_NAME, sequenceName = User.SEQUENCE_NAME, initialValue = 100)

  public class User {

   public static final String SEQUENCE_NAME = "USER_SEQ";

   @Id

   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = SEQUENCE_NAME)

   Integer seq;

   String name;

   String password;

  

   @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)

   @JoinColumn(name = "USER_SEQ")

   List<Auth> auths = null;

  }

Session session = getSessionFactory().getCurrentSession();
session.beginTransaction();

//////Fetch
User userBydb = session.get(User.class,100);      //부모테이블만 조회
try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}
//아래에서 사용할때 자식테이블 조회
userBydb.getAuths().forEach(it->log.info("get(DB)"+it.getUser().getName()));

session.getTransaction().commit();

18:04:14 DEBUG :

    select

        user0_.seq as seq1_1_0_,

        user0_.name as name2_1_0_,

        user0_.password as password3_1_0_

    from

        User user0_

    where

        user0_.seq=?

18:04:19 DEBUG :

    select

        auths0_.USER_SEQ as USER_SEQ4_0_0_,

        auths0_.AUTH_SEQ as AUTH_SEQ1_0_0_,

        auths0_.auth as auth2_0_0_,

        auths0_.AUTH_SEQ as AUTH_SEQ1_0_1_,

        auths0_.auth as auth2_0_1_,

        auths0_.expiry as expiry3_0_1_,

        auths0_.user_seq as user_seq4_0_1_,

        user1_.seq as seq1_1_2_,

        user1_.name as name2_1_2_,

        user1_.password as password3_1_2_

    from

        Auth auths0_

    left outer join

        User user1_

            on auths0_.user_seq=user1_.seq

    where

        auths0_.USER_SEQ=?

18:04:19 TRACE : binding parameter [1] as [INTEGER] - [100]

즉시로딩 FetchType.EAGER

@Data

@Entity

@SequenceGenerator(name = User.SEQUENCE_NAME, sequenceName = User.SEQUENCE_NAME, initialValue = 100)

  public class User {

   public static final String SEQUENCE_NAME = "USER_SEQ";

   @Id

   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = SEQUENCE_NAME)

   Integer seq;

   String name;

   String password;

  

   @OneToMany(cascade = CascadeType.ALL,fetch = FetchType.EAGER)

   @JoinColumn(name = "USER_SEQ")

   List<Auth> auths = null;

  }

즉시 조인 쿼리가 날라간다.

select

        user0_.seq as seq1_1_0_,

        user0_.name as name2_1_0_,

        user0_.password as password3_1_0_,

        auths1_.USER_SEQ as USER_SEQ4_0_1_,

        auths1_.AUTH_SEQ as AUTH_SEQ1_0_1_,

        auths1_.auth as auth2_0_1_,

        auths1_.AUTH_SEQ as AUTH_SEQ1_0_2_,

        auths1_.auth as auth2_0_2_,

        auths1_.expiry as expiry3_0_2_,

        auths1_.user_seq as user_seq4_0_2_,

        user2_.seq as seq1_1_3_,

        user2_.name as name2_1_3_,

        user2_.password as password3_1_3_

    from

        User user0_