개발관련/Spring 2015. 12. 4. 16:59

hibernate(4)

이번엔 두개의 클래스를 하나의 테이블로 만드는 법을 살펴 보자. 


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
package com.zest.hibernate.chapter3;
 
import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.SecondaryTable;
import javax.persistence.Table;
 
 
@Entity
public class School {
 
    
    @Id
    @GeneratedValue
    private int schoolId;
    private String schoolName;
    
    @Embedded
    private SchoolDetail schoolDetail;
    
    
    public SchoolDetail getSchoolDetail() {
        return schoolDetail;
    }
    public void setSchoolDetail(SchoolDetail schoolDetail) {
        this.schoolDetail = schoolDetail;
    }
    public int getSchoolId() {
        return schoolId;
    }
    public void setSchoolId(int schoolId) {
        this.schoolId = schoolId;
    }
    public String getSchoolName() {
        return schoolName;
    }
    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
    
    
    
    
}
 
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
 
package com.zest.hibernate.chapter3;
 
import javax.persistence.Embeddable;
 
@Embeddable
public class SchoolDetail {
 
    private String schoolAddress;
    private boolean isPublishSchool;
    private int studentCount;
    
    public String getSchoolAddress() {
        return schoolAddress;
    }
    public void setSchoolAddress(String schoolAddress) {
        this.schoolAddress = schoolAddress;
    }
    public boolean isPublishSchool() {
        return isPublishSchool;
    }
    public void setPublishSchool(boolean isPublishSchool) {
        this.isPublishSchool = isPublishSchool;
    }
    public int getStudentCount() {
        return studentCount;
    }
    public void setStudentCount(int studentCount) {
        this.studentCount = studentCount;
    }
    
    
}
 
cs


두개의 클래스가 있는데 새로운 어노테이션 발견....

부모가 되는 클래스는에는 @Embeded 라는 어노테이션을 쓰고 자식이 되는 클래스에는 @Embedable 어노테이션을 사용한다. 


나머진 기존과 다를게 없다. 그럼 테스트코드. ㄱㄱ

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
 
package com.zest.hibernate.chapter3;
 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.Test;
 
import com.zest.hibernate.chapter2.Customer;
 
public class SchoolTest {
 
    @Test
    public void school1() {
        AnnotationConfiguration config = new AnnotationConfiguration();
        config.addAnnotatedClass(School.class);
        config.configure("hibernate.cfg.xml");
 
        new SchemaExport(config).create(true, true);
 
        // 아래 두개의 구문은 객체를 트랜잭션을 컨트롤.
        SessionFactory factory = config.buildSessionFactory();
        Session session = factory.getCurrentSession();
 
        session.beginTransaction();
 
        SchoolDetail annsDetail= new SchoolDetail();
        annsDetail.setPublishSchool(false);
        annsDetail.setSchoolAddress("101 washington");
        annsDetail.setStudentCount(300);
        
        School stanns = new School();
        stanns.setSchoolName("st. anns school");
        stanns.setSchoolDetail(annsDetail);
        
        session.save(stanns);
        session.getTransaction().commit();
    }
}
 
cs


테스트 코드는 두개의 객체를 사용하여 트랜잰션에 묶어준다. 그럼 결과 sql문을 보자. 

1
2
 
Hibernate: insert into TESTSCHEMA.School (isPublishSchool, schoolAddress, studentCount, schoolName, schoolId) values (?, ?, ?, ?, ?)
cs


이런 문구가 나올것이다. 





저작자표시
posted by 제스트
:
개발관련/Spring 2015. 12. 4. 14:29

hibernate(3)

하나의 객체에 두개의 테이블 생성하기 를 해보자. 


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
package com.zest.hibernate.chapter2;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.SecondaryTable;
import javax.persistence.Table;
 
 
@Entity
@Table(name="Customer")
@SecondaryTable(name="CustomerDetail")
public class Customer {
 
    
    @Id
    @GeneratedValue
    private int customerId;
    private String customerName;
    
    @Column(table="CustomerDetail")
    private String customerAddress;
    
    @Column(table="CustomerDetail")
    private int creditScore;
    @Column(table="CustomerDetail")
    private int rewardPoints;
    
    public int getCustomerId() {
        return customerId;
    }
    public void setCustomerId(int customerId) {
        this.customerId = customerId;
    }
    public String getCustomerName() {
        return customerName;
    }
    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }
    public String getCustomerAddress() {
        return customerAddress;
    }
    public void setCustomerAddress(String customerAddress) {
        this.customerAddress = customerAddress;
    }
    public int getCreditScore() {
        return creditScore;
    }
    public void setCreditScore(int creditScore) {
        this.creditScore = creditScore;
    }
    public int getRewardPoints() {
        return rewardPoints;
    }
    public void setRewardPoints(int rewardPoints) {
        this.rewardPoints = rewardPoints;
    }
    
    
    
}
 
cs


처음 보는 어노테이션이 등장한다. @SecondaryTable 이라는 넘이다. 기존 customer 말고 cumstomerDetail 이라는 테이블로 선언이 되었다. 이 객체의 재미난 점은 기본키는 둘다 같은 column을 사용한다는 것이다. 그리고 detail의 경우 cumstomerId를 기본키로 하면서 외래키를 가진다.  그리고 sencondaryTable에 추가할 컬럼은 @Column 어노테이션을 사용하여 추가한다. 


아마도 1:1 대응 구조에 사용하면 좋을듯 보인다. 그럼 테스트 코드를 보자. 

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
 
package com.zest.hibernate.chapter2;
 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.Test;
 
public class CustomerTest {
 
    @Test
    public void customer1() {
        AnnotationConfiguration config = new AnnotationConfiguration();
        config.addAnnotatedClass(Customer.class);
        config.configure("hibernate.cfg.xml");
 
        new SchemaExport(config).create(true, true);
 
        // 아래 두개의 구문은 객체를 트랜잭션을 컨트롤.
        SessionFactory factory = config.buildSessionFactory();
        Session session = factory.getCurrentSession();
 
        session.beginTransaction();
 
        Customer alex = new Customer();
        alex.setCustomerName("Alex Rod");
        alex.setCustomerAddress("101 washington");
        alex.setCreditScore(780);
        alex.setRewardPoints(12000);
        
        session.save(alex);
        session.getTransaction().commit();
    }
}
 
cs



사용법은 앞서 보여준 방법과 동일한데 결과 로그는 두개의 테이블에 넣는다. 

1
2
3
 
Hibernate: insert into TESTSCHEMA.Customer (customerName, customerId) values (?, ?)
Hibernate: insert into TESTSCHEMA.CustomerDetail (creditScore, customerAddress, rewardPoints, customerId) values (?, ?, ?, ?)
cs




저작자표시
posted by 제스트
:
개발관련/Spring 2015. 12. 4. 13:59

hibernate(2)

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package com.zest.hibernate.chapter1;
 
import java.util.Calendar;
import java.util.Date;
 
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.TableGenerator;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;
 
@Entity
@Table(name = "EmployeeInfo")
public class Employee {
 
    @Id
    @Column(name = "EmployeeId", nullable = false)
    /**
     * sequence table을 생성.
     * name= sequence table의 alias 이름.
     * table은 sequence table의 이름.  
     * pkColumnName 은  sequence table의 column이름.
     * pkColumnValue은  sequence table 값을 저장하는 이름.. 
     * 
     */
    
    @TableGenerator(name = "empid", table = "emppktb", pkColumnName = "empkey"
    , pkColumnValue = "empvalue", allocationSize=1)
    @GeneratedValue(strategy = GenerationType.TABLE, generator = "empid")
    private int empId;
    private String empName;
 
    // db에 등록은 안되고 객체에서 db와 별도의 기능이 필요할 경우 사용되는 어노테이션.
    @Transient
    private String empPassword;
    @Column(nullable = false)
    private String empEmailAddress;
 
    @Basic
    private boolean isPermanent;
 
    @Temporal(TemporalType.DATE)
    private Calendar empJoinDate;
 
    // @Basic
    @Temporal(TemporalType.TIMESTAMP)
    private Date empLoginTime;
 
    public String getEmpPassword() {
        return empPassword;
    }
 
    public void setEmpPassword(String empPassword) {
        this.empPassword = empPassword;
    }
 
    public String getEmpEmailAddress() {
        return empEmailAddress;
    }
 
    public void setEmpEmailAddress(String empEmailAddress) {
        this.empEmailAddress = empEmailAddress;
    }
 
    //
    public boolean isPermanent() {
        return isPermanent;
    }
 
    public void setPermanent(boolean isPermanent) {
        this.isPermanent = isPermanent;
    }
 
    public Calendar getEmpJoinDate() {
        return empJoinDate;
    }
 
    public void setEmpJoinDate(Calendar empJoinDate) {
        this.empJoinDate = empJoinDate;
    }
 
    public Date getEmpLoginTime() {
        return empLoginTime;
    }
 
    public void setEmpLoginTime(Date empLoginTime) {
        this.empLoginTime = empLoginTime;
    }
 
    public int getEmpId() {
        return empId;
    }
 
    public void setEmpId(int empId) {
        this.empId = empId;
    }
 
    public String getEmpName() {
        return empName;
    }
 
    public void setEmpName(String empName) {
        this.empName = empName;
    }
 
}
 
cs


먼저 employee라는 클래스를 생성하자. 

@Entity 라는 어노테이션이 등장한다. 이넘은 db의 table을 지징하는넘이다. nosql에선 collection정도? 


@Table은 table의 이름을 바꾸고자 할 때 사용한다. 만약 이 어노테이션이 생략 되면 테이블 이름은 클래스 명과 동일하게 된다. 


@TableGenerator는 Sequence Table을 정의할 때 사용한다. 옵션은 다음과 같다. 

 name= sequence table의 alias 이름.

 table은 sequence table의 이름.  

 pkColumnName 은  sequence table의 column이름.

 pkColumnValue은  sequence table 값을 저장하는 이름.. 


@GenerartedValue는 auto increment 의 옵션이다. 이때 위의 예제는 segence table의 값을 사용할 때의 예제 이다. 


@Transient는 database의 table과 상관없이 employee 객체 안에서 다른 객체 또는 무언가 다른 작업을 하고 싶을 때 사용하는 옵션이다. 결국 db에 영향을 주지는 않는다. 


@Basic은 lazy 관련 옵션이다. 


@Temporal은 시간,날짜에 대한 옵션을 줄때 사용하는 어노테이션이다. 


이제 실행해보자..

1
2
3
4
5
6
7
8
9
10
11
 
    @Test
    public void entityTest1(){
        AnnotationConfiguration config = new AnnotationConfiguration();
        config.addAnnotatedClass(Employee.class);
        config.configure("hibernate.cfg.xml");
        
        new SchemaExport(config).create(true,true);
        
        
    }
cs


아주 간단한 소스이다. 여기서 중요한 것은 create의 옵션이다. 첫번째 두번째 파라미터의 설명은 

script print the DDL to the console, export export the script to the database 

해석하자면 첫번째 것은 니가 실행하고자 하는거 콘솔에 찍을까? 두번째 것은 스크립트 실행할래? 이다. 두번째 것이 false로 되어있음 table이 생성되지 않는다.  그럼 로그를 살펴보자. 

1
2
3
4
5
6
7
8
INFO : org.hibernate.connection.DriverManagerConnectionProvider - connection properties: {user=user, password=****}
drop table TESTSCHEMA.EmployeeInfo
drop table TESTSCHEMA.emppktb
create table TESTSCHEMA.EmployeeInfo (EmployeeId integer not null, empEmailAddress varchar(255) not null, empJoinDate date, empLoginTime timestamp, empName varchar(255), isPermanent smallint not null, primary key (EmployeeId))
create table TESTSCHEMA.emppktb ( empkey varchar(255),  sequence_next_hi_value integer ) 
INFO : org.hibernate.tool.hbm2ddl.SchemaExport - schema export complete
INFO : org.hibernate.connection.DriverManagerConnectionProvider - cleaning up connection pool: jdbc:derby://localhost:1527/hibernateDb
 
cs


create 함수를 콜을 하면 기존의 테이블을 삭제하고 생성하는것이 보일것이다. 


이제 데이터를 추가해보자. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    @Test
    public void entityTest2(){
        AnnotationConfiguration config = new AnnotationConfiguration();
        config.addAnnotatedClass(Employee.class);
        config.configure("hibernate.cfg.xml");
        
//        new SchemaExport(config).create(true,true);
        
        SessionFactory factory = config.buildSessionFactory();
        Session session = factory.getCurrentSession();
        
        session.beginTransaction();
        
        Employee alex = new Employee();
        alex.setEmpName("Alex Berry");
        alex.setEmpEmailAddress("aaa@aa.com");
        session.save(alex);
        
        session.getTransaction().commit();
    }
cs


세션을 한개 만들어서 트랜잭션을 시작하게 된다. 작업을 마치고 commit으로 종료를 하게 된다. 

굉장히 심플하다. 아마도 jpa에서 이부분이 조금 변경 될 것이다. session 관련은 bean으로 뺄 것이며, 트랜잭션은 어노테이션 기반으로 처리 할것이고 repository 에서 save등등 sql문을 처리 할 것이다. 어쨋든 하이버네이트에선 위와 같이 처리하게 된다. 


위의 junit테스트를 실행해보면 insert 구문이 나올 것이다. 

empId의 경우는 sequence table에서 가져오므로 그냥 추가가 될것이다. 


이번에는 create함수를 사용하고 모든 컬럼에 값을 넣어보자. 


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
    @Test
    public void entityTest3(){
        //hibernate의 persitst를 위한 클래스
        AnnotationConfiguration config = new AnnotationConfiguration();
        config.addAnnotatedClass(Employee.class);
        //db 접속 정보들을 저장.
        config.configure("hibernate.cfg.xml");
        
        //db 접속후 여러개의 테이블을 자동으로 제너레이트 해주는 객체.
        //<property name="hibernate.default_schema">TESTSCHEMA</property> 이구문역시 마찬가지임.
        new SchemaExport(config).create(true,true);
        
        //아래 두개의 구문은 객체를 트랜잭션을 컨트롤. 
        SessionFactory factory = config.buildSessionFactory();
        Session session = factory.getCurrentSession();
        
        session.beginTransaction();
        
        Employee alex = new Employee();
//        alex.setEmpId(2);
        alex.setEmpName("Alex Berry11");
        alex.setEmpEmailAddress("alex@hibernate.com");
        alex.setEmpPassword("alexpass");
        alex.setEmpJoinDate(new GregorianCalendar(2009,05,26));
        alex.setEmpLoginTime(Date.valueOf("2010-06-05"));
        session.save(alex);
        
        session.getTransaction().commit();
        session.close();
    }
cs


기존 데이터가 삭제되고 한개만 추가 될것이다. 


https://github.com/zest133/hibernateTest.git 소스는 다운받을 수 있다. 

저작자표시
posted by 제스트
:

티스토리툴바