hibenate (10) 양 방향 관련 관계 의 CRUD

본문 링크:http://www.orlion.ml/28/
저장
1、
하나의 group 에 여러 개의 user 가 있다 고 가정 하면 한 user 는 하나의 group 에 만 속 합 니 다. user 대상 을 데이터베이스 에 저장 할 때 가능 합 니 다.

User u = new User();
u.setName("u1");
Group g = new Group();
g.setName("g1");
u.setGroup(g);
Session s = sessionFactory.getCurrentSession();
s.beginTransaction();
s.save(g);//   hibernate       
s.save(u);
s.getTransaction().commit();

hibenate 는 기본적으로 group 대상 을 저장 하지 않 습 니 다. 설정 해 야 합 니 다.
@ Many ToOne 에는 속성 캐 스 케 이 드 (직렬 연결) 가 있 습 니 다. 캐 스 케 이 드 타 입 은
(1) ALL: 모든 작업 시 현재 대상 에 대한 모든 연결 대상 은 hibenate 에서 작 동 합 니 다.
(2) MERGE: merge () 방법 을 호출 할 때 (통합 할 때) 직렬 연결 (MERGE = save + update)
(3) PERSIST: persist () 방법 을 호출 할 때 (저 장 된 경우) 직렬 연결
(4) PEFRESH: 하나의 session 이 데이터베이스 에서 대상 과 연 결 된 대상 을 메모리 로 로드 하고 다른 session 이 데이터베이스 에서 이 대상 을 수정 하면 hibenate 는 첫 번 째 sesson load 의 대상 을 연결 하 는 대상 에 게 리 셋 작업 을 합 니 다 (A 안쪽 은 B 개 선 된 데 이 터 를 읽 어야 합 니 다)
(5) REMOVE: 삭제 시 직렬 연결
(캐 스 케 이 드 의 속성 은 어떤 조작 을 할 때 관련 대상 이 연결 되 어 있 는 지 를 가리킨다)
테스트: User 클래스 의 getGroup () 방법 에 있 는 @ ManyToOne 주 해 를 @ ManyToOne (cascade = (Cascade Type. ALL) 으로 수정 한 다음 위 코드 블록 에 있 는 s. save (g) 를 주석 하면 실행 프로그램 에서 group 이 hibenate 에 의 해 자동 으로 데이터베이스 에 저 장 됩 니 다.
2、
위 에 user 를 저장 합 니 다. 연 결 된 group hibenate 는 저장 해 줍 니 다. 만약 에 우리 가 group 을 저장 하면 연 결 된 user 가 저장 해 줄 수 있 습 니까?

User u1 = new User();
u1.setName("u1");
User u2 = new User();
u1.setName("u2");
User u3 = new User();
u1.setName("u3");

Group g = new Group();
g.setName("g1");
g.getUsers().add(u1);
g.getUsers().add(u2);
g.getUsers().add(u3);

Session s = sessionFactory.getCurrentSession();
s.beginTransaction();
s.save(g);//         ，u1,u2,u3          
s.getTransaction.commit()；

 
히 베 네 이 트 가 group 에 저 장 된 관련 대상 을 설정 하려 면 Group 클래스 의 getUsers () 방법 에 대한 설명 @ OneToMany (mappedby = "group") 를 @ OneToMany (mappedby = "group", cascade = (Cascade Type. ALL) 로 변경 해 야 합 니 다.주: 이렇게 만 설정 하면 u1, u2, u3 이 데이터베이스 에 저 장 된 후 group id 는 모두 NULL 입 니 다. u1, u2, u3 대상 의 group 속성 은 null 이기 때문에 코드 블록 에 u1. setGroup (g), u2. setGroup (g), u3. setGroup (g) 을 추가 해 야 합 니 다.
규칙: (1) 다 대 일 관 계 는 여러 측 에서 조작 하 는 것 이 비교적 간단 하 다. (2) 관련 관계 가 양 방향 이면 네 비게 이 션 (mappedBy) 을 잘 설정 해 야 한다. (3) 양 방향 관 계 는 프로그램 에서 양 방향 관 계 를 설정 해 야 한다.
 
읽다
1. get 방식
데이터베이스 에서 사용자 한 명 을 먼저 나 오 겠 습 니 다.

Session s = sessionFactory.getCurrentSession();
s.beginTransaction();
//                         cascade      Group     
User u = (User)s.get(User.class , 1);
s.getTransaction().commit;

 
저 희 는 데이터베이스 에서 get Group 을 나 옵 니 다. 캐 스 케 이 드 를 설정 하 든 말 든 관련 user 를 꺼 내지 않 습 니 다. 캐 스 케 이 드 는 저장 할 때 만 유효 합 니 다. 읽 기 위해 서 는 따로 설정 해 야 합 니 다.
Group 클래스 의 getUsers () 방법 에 @ OneToMany (mappedBy = "group", cascade = (Cascade Type. ALL) 를 @ OneToMany (mappedby = "group", cascade = (Cascade Type. ALL), fetch = FetchType. EAGER) 로 수정 한 다음 코드 블록 에 쓸 수 있 습 니 다.

Group g = (Group)s.get(Group.class,1);//      fetch       User   
for(User u : g.getUsers()) {
    System.out.println(u.getName());  
}

 
User 클래스 에서 getGroup () 방법 에 주석 @ ManyToOne 기본 FetchType 은 EAGER 이기 때 문 입 니 다.

           user             cascade      Group     

User 클래스 에서 @ ManyToOne 에 속성 fetch = FetchType. LAZY 를 추가 할 때 user 와 연 결 된 group 을 사용 할 때 만 꺼 냅 니 다.

Session s = sessionFactory.getCurrentSession();
s.beginTransaction();

User u = (User)s.get(User.class , 1);//       group
System.out.println(u.getGroup().getName());//      group

s.getTransaction().commit;

//System.out.println(u.getGroup().getName());     no session，   session     。     EAGER     。

 
FetchType 은 매 거 진 형식 입 니 다. 다음 과 같 습 니 다.
(1) EAGER: (갈망) 데 이 터 를 열심히 가 져 와 야 한다 고 정의
(2) 레이 지: (게 으 름) 데 이 터 를 게 으 르 게 가 져 올 수 있 음 을 정의 합 니 다.
 
2. load 방식
 
업데이트

Session s = sessionFactory.getCurrentSession();
s.beginTransactio();
User u = (User)s.load(User.class , 1);
u.setName("user");
u.getGroup().setName("g");
s.getTransaction().commit();//     update  

 이렇게 쓰 면 되 지만 저 희 는 보통 유리 상태 에 있 는 대상 을 업데이트 합 니 다. user 가 유리 상태 에 있 을 때 session 이 닫 혀 저장 할 수 없습니다.

Session s = sessionFactory.getCurrentSession();
s.beginTransaction();
User u = (User)s.get(User.class,1);

s.getTransaction().commit();

u.setName("user");
u.getGroup().setName("group");

Session s2 = sessionFactory.getCurrentSession();
s2.beginTransaction();
s2.update(u);
//  User   getGroup()    @ManyToOne    cascade=CascadeType.ALL ，   group，     update     update Group
s2.getTransaction().commit();

 
삭제
1. 사용자 삭제

Session s = sessionFactory.getCurrentSession();
s.beginTransaction();
User u = (User)s.load(User.class,1);
s.delete(u);
//      u  ，    u   group       user  
s.getTransaction().commit();

그룹 을 삭제 하지 않 으 려 면:

u.setGroup(null);
s.delete(u);

HQL 도 사용 가능:

Session s = sessionFactory.getCurrentSession();
s.beginTransaction();
s.createQuery("delete from User u where u.id=1");
s.getTransaction().commit();

 
2. 그룹 삭제

Session s = sessionFactory.getCurrentSession();
s.beginTransaction();
Group g = (Group)s.load(Group.class,1);
s.delete(g);
//      g    g       user  (       cascade=all)
s.getTransaction().commit();

모든 user 를 삭제 하지 않 으 려 면 user 의 group id 를 null 로 설정 할 수 있 습 니 다.