EJB Entity之间One-To-Many与Many-To-One

key

类A的其中一个属性是另一个类B的集合，则A与B就形成了一个One-To-Many的关系。
如果在类B中又有一个属性指回类A，即A和B的关系是双向的，则可以形成Many-To-One的关系。

虽然，从理论上可以建立单向的Many-To-One的对象关系，但这种单向的Many-To-One关系
似乎不多见，至少我们不会太显式地讨论这种关系。比如每一个子窗口都保存其父窗口的handle，
而父窗口并不需要保存子窗口的handle，这是一种Many-To-One的关系，但事实上我们并不会
太着重看代这种关系。

OK，这是程序上的modeling。在数据库中则刚好相关。由于关系型数据库不能保存数组、集合
这种模型（象PostgreSQL对象关系型数据库是有数组概念的），所以在数据库中都是通过
Many-To-One的形式来表示实体之间的关系。

所以，我们不难想象EJB Entity之间的One-To-Many与Many-To-One是通过数据库的这种
实质的Many-To-One的外键关联来实现的。

由于在数据库中不能直接表现One-To-Many的关系，而在程序中又基本上都需要One-To-Many，
这就形成了存贮与逻辑的差别了。为此，在目前的JPA/Entity实现方案里，并没有单向的One-To-Many
关系，只能双向表示。

One-To-Many

1.   1 package persistence2;
   
2.   2
   
3.   3 import javax.persistence.*;
   
4.   4 import java.util.*;
   
5.   5
   
6.   6 @Entity
   
7.   7 @Table(name="KeyBoard")
   
8.   8 public class MyBoard {
   
9.   9     private Long id;
   
10. 10     private Set<MyKey> keys;
    
11. 11     private String name;
    
12. 12
    
13. 13     @Id
    
14. 14     @GeneratedValue(strategy=GenerationType.AUTO)
    
15. 15     @Column(name="BOARD_ID")
    
16. 16     public Long getId() { return id; }
    
17. 17     public void setId(Long id) { this.id = id; }
    
18. 18
    
19. 19     @Column(name="BOARD_NAME")
    
20. 20     public String getName() { return name; }
    
21. 21     public void setName(String name) { this.name = name; }
    
22. 22
    
23. 23     @OneToMany(mappedBy="id")
    
24. 24     public Set<MyKey> getKeys() { return keys; }
    
25. 25     public void setKeys(Set<MyKey> keys) { this.keys = keys; }
    
26. 26 }

复制代码

Many-To-One

1.   1 package persistence2;
   
2.   2
   
3.   3 import javax.persistence.*;
   
4.   4
   
5.   5 @Entity
   
6.   6 @Table(name="KEY")
   
7.   7 public class MyKey {
   
8.   8     private Long id;
   
9.   9     private String keyName;
   
10. 10     private MyBoard board;
    
11. 11
    
12. 12     public MyKey() {}
    
13. 13     public MyKey(String keyName, MyBoard board) { this.keyName = keyName; this.board=board; }
    
14. 14
    
15. 15     @Id @GeneratedValue(strategy=GenerationType.AUTO)
    
16. 16     @Column(name="KEY_ID", insertable=false, updatable=false)
    
17. 17     public Long getId() { return id; }
    
18. 18     public void setId(Long id) { this.id = id; }
    
19. 19
    
20. 20     @Column(name="KEY_NAME", updatable=false)
    
21. 21     public String getKeyName() { return keyName; }
    
22. 22     public void setKeyName(String keyName) { this.keyName = keyName; }
    
23. 23
    
24. 24     @ManyToOne
    
25. 25     @JoinColumn(name="BOARD_ID", referencedColumnName="BOARD_ID")
    
26. 26     public MyBoard getBoard() { return board; }
    
27. 27     public void setBoard(MyBoard board) { this.board = board; }
    
28. 28 }

复制代码

操作

1. 70         MyBoard board = new MyBoard();
   
2. 71         Set<MyKey> keys = new HashSet<MyKey>();
   
3. 72
   
4. 73         keys.add(new MyKey("ESC", board));
   
5. 74         keys.add(new MyKey("ENTER", board));
   
6. 75         keys.add(new MyKey("TAB", board));
   
7. 76         keys.add(new MyKey("SHIFT", board));
   
8. 77         keys.add(new MyKey("CTRL", board));
   
9. 78         keys.add(new MyKey("ALT", board));
   
10. 79
    
11. 80
    
12. 81         board.setName("MyKeyBoard");
    
13. 82         board.setKeys(keys);
    
14. 83         manager.persist(board);
    
15. 84
    
16. 85         Iterator<MyKey> ki = keys.iterator();
    
17. 86         while(ki.hasNext()){ manager.persist(ki.next()); }

复制代码

这里要注意，必须先存贮One-To-Many那个类，建立了那个类的ID，以便在Many-To-One的类对应的
数据库表中做成外键。如果把存贮顺序返过来，则会出错。

key

One-To-Many类的Line-23
应该为：
@OneToMany(mappedBy="board")