JPA学习笔记-EJB-04JPA关联映射总结--5

1.       1 VS N 和N VS 1

说完了最复杂的多对多关系后，剩下的骨头就好啃了。我们就先来看一对多和多对一。

假设目前项目有这样一个需求：建立一个类似足球俱乐部转会的管理系统球员可以转会到其他的俱乐部，而俱乐部看队员不顺眼也可以开除队员，一个队员在一个时刻只能从属于一家俱乐部，一个俱乐部在一个时刻内可以有多个运动员。由此，我们不难得出以下模型。

 

多个动员从属于一个俱乐部管辖，而一个俱乐部下面可以有多个运动员。比如说一提到巴塞罗那，可以知道它有梅西、哈维、伊涅斯塔………………，一提到C罗可以知道他在皇家马德里踢球，一提到厄齐尔也知道他在皇家马德里。

由此我们得到了类图

PlayersVO（运动员）

 

说明：咱们暂且只关心TeamVO，看出运动员里面有俱乐部实体。

那咱们来看俱乐部类图

TeamVO（俱乐部）

 

 

俱乐部里面有Set<PlayersVO>,由此可以得出结论，运动员和俱乐部是双向1对多的关系，在运动员这边来看就是多对1（多个人员对应一个俱乐部嘛），从俱乐部这边来看就是1对多关系（1个俱乐部有多个运动员）。

下面是两个类的代码：

PlayersVO

package mangerTeam.vo;

 

import java.io.Serializable;

import java.util.Set;

 

import javax.persistence.Basic;

import javax.persistence.CascadeType;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.FetchType;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import javax.persistence.JoinColumn;

import javax.persistence.JoinTable;

import javax.persistence.Lob;

import javax.persistence.ManyToMany;

import javax.persistence.ManyToOne;

import javax.persistence.Table;

 

/**

 * 运动员实体

 *

 * @author 刘岩

 */

@Entity

@Table(name = "player")

public class PlayersVO implements Serializable {

 

         @Id

         @GeneratedValue(strategy = GenerationType.AUTO)

         @Column(name = "id", unique = true, nullable = false)

         private Integer id;

 

         @Column(name = "name")

         private String name;

 

         @ManyToOne(optional=true, fetch = FetchType.LAZY)

         @JoinColumn(name = "teamId")

         private TeamVO teamVO;

 

         @ManyToOne(fetch = FetchType.LAZY)

         @JoinColumn(nullable=false,name = "nationalityId")

         private NationalityVO nationalityVO;

 

         @Lob

         @Basic(fetch = FetchType.LAZY)

         @Column(name = "pic")

         private byte[] pic;

 

         @Lob

         @Basic(fetch = FetchType.LAZY)

         @Column(name = "mess")

         private String mess;

 

         @ManyToMany(cascade = CascadeType.REFRESH, fetch = FetchType.LAZY)

         @JoinTable(name = "plays_position", joinColumns = { @JoinColumn(name = "playerId") }, inverseJoinColumns = { @JoinColumn(name = "positionId") })

         private Set<PositionVO> positions;

 

         public Integer getId() {

                   return id;

         }

 

         public void setId(Integer id) {

                   this.id = id;

         }

        

         public String getName() {

                   return name;

         }

 

         public void setName(String name) {

                   this.name = name;

         }

 

         public Set<PositionVO> getPositions() {

                   return positions;

         }

 

         public void setPositions(Set<PositionVO> positions) {

                   this.positions = positions;

         }

 

         public TeamVO getTeamVO() {

                   return teamVO;

         }

 

         public void setTeamVO(TeamVO teamVO) {

                   this.teamVO = teamVO;

         }

 

         public NationalityVO getNationalityVO() {

                   return nationalityVO;

         }

 

         public void setNationalityVO(NationalityVO nationalityVO) {

                   this.nationalityVO = nationalityVO;

         }

 

         public byte[] getPic() {

                   return pic;

         }

 

         public void setPic(byte[] pic) {

                   this.pic = pic;

         }

 

         public String getMess() {

                   return mess;

         }

 

         public void setMess(String mess) {

                   this.mess = mess;

         }

 

}

在此我们和上面一样只理会如下片段

         @ManyToOne(optional=true, fetch = FetchType.LAZY)

         @JoinColumn(name = "teamId")

         private TeamVO teamVO;

说明：@ManyToOne声明和TeamVO是多对1关系，

Optional：是否允许该字段为null。（运动员可以没有俱乐部，原拜仁门将——伦辛曾失业半年多呢）。

fetch = FetchType.LAZY：抓取策略为懒加载。