java技术

一对一(One-To-One)
使用@OneToOne注解建立实体Bean之间的一对一关联。一对一关联有三种情况：(1).关联的实体都共享同样的主键，(2).其中一个实体通过外键关联到另一个实体的主键(注意要模拟一对一关联必须在外键列上添加唯一约束)，(3).通过关联表来保存两个实体之间的连接关系(要模拟一对一关联必须在每一个外键上添加唯一约束)。
1.共享主键的一对一关联映射：
@Entity
@Table(name="Test_Body")
public class Body {
   private Integer id;
   private Heart heart;
  
   @Id
   public Integer getId() {
      return id;
   }
  
   public void setId(Integer id) {
      this.id = id;
   }

   @OneToOne
   @PrimaryKeyJoinColumn
   public Heart getHeart() {
      return heart;
   }

   public void setHeart(Heart heart) {
      this.heart = heart;
   }
}

@Entity
@Table(name="Test_Heart")
public class Heart {
   private Integer id;
   @Id
   public Integer getId() {
      return id;
   }

   public void setId(Integer id) {
      this.id = id;
   }
}

通过@PrimaryKeyJoinColumn批注定义了一对一关联

2.使用外键进行实体一对一关联：
@Entity
@Table(name="Test_Trousers")
public class Trousers {
   @Id
   public Integer id;
   @OneToOne
   @JoinColumn(name = "zip_id")
   public TrousersZip zip;
}

@Entity
@Table(name="Test_TrousersZip")
public class TrousersZip {
   @Id
   public Integer id;
   @OneToOne(mappedBy = "zip")
   public Trousers trousers;
}

上面的例子是指Trousers通过Trousers的外键列zip_id和TrousersZip关联，@JoinColumn批注定义了联接列，该批注和@Column批注有点类似，但是多了一个名为referencedColumnName的参数。该参数定义了所关联目标实体中的联接列，注意，当referencedColumnName关联到非主键列的时候，关联的目标类必须实现Serializable，还要注意的是所映像的属性对应单个列（否则映射无效）
一对一关联可能是双向的，在双向关联中，有且仅有一端作为主体（owner）端存在：主体端负责维护联接列（即更新），对于不需要维护这种关系的从表则通过mappedNy属性进行声明。mappedBy的值指向主体的关联属性。例子中，mappedBy的值为zip。最后，不必也不能再在被关联端（ownedside）定义联接列了，因为已经在主体端声明了。
如果在主体没有声明@JoinColumn，系统自动进行处理：在主表（owner table）中将创建联接列，列名为：主体的关联属性名+下划线+被关联端的主键列名。上面的例子中是zip_id,因为Trousers中的关联属性名为zip，TrousersZip的主键是id。

3.通过关联表定义一对一关联
@Entity
@Table(name="Test_People")
public class People {
   @Id
   public Integer id;
   @OneToOne
   @JoinTable(name ="TestPeoplePassports",
     joinColumns = @JoinColumn(name="perple_fk"),
     inverseJoinColumns = @JoinColumn(name="passport_fk")
   )
   public Passport passport;
}

@Entity
@Table(name="Test_Passport")
public class Passport {
   @Id
   public Integer id;
   @OneToOne(mappedBy = "passport")
   public People people;
}
People通过名为TestPeoplePassports的关联表和Passport关联。该关联表拥有名为passport_fk的外键列，该外键指向Passport表，该信息定义为inverseJoinColoumns的属性值，而people_fk外键列指向People表，该信息定义为joinColumns的属性值。
这种关联可能是双向的，在双向关联中，有且仅有一端作为主体（owner）端存在：主体端负责维护联接列（即更新），对于不需要维护这种关系的从表则通过mappedNy属性进行声明。mappedBy的值指向主体的关联属性。例子中，mappedBy的值为passport。最后，不必也不能再在被关联端（ownedside）定义联接列了，因为已经在主体端声明了。

多对一(Many-to-One)
使用@ManyToOne批注来实现多对一关联。
@ManyToOne批注有一个名为targetEntity的参数，该参数定义了目标实体名，通常不需要定义该参数，因为在大部分情况下默认值(表示关联关系的属性类型)就可以很好的满足需求了。不过下面这种情况下这个参数就显得有意义了：使用接口作为返回值而不是常见的实体。
@ManyToOne(targetEntity=CompanyImpl.class)
@JoinColoumn(name=”COPM_ID”)
Public Company getCompany(){
   return company;
}

多对一的配置方式有两种：(1)通过@JoinColoumn映像(2)通过关联表的方式来映像
(1)通过@JoinColoumn映射
SRD Framework中Company,Category例子：
Company：
@ManyToOne
   @JoinColumn(name = "CATEGORY_OPTION_ID")
   private Category category = null;
   Category：
@DiscriminatorValue("Category")
public class Category extends Option {
}
(2)通过关联表映射
通过@JoinTable批注定义关联表，该关联表包含了指回实体表的外键(通过@JoinTable.joinColoumns)以及指向目标实体表的外键(通过@JoinTable.inverseJoinColoumns)
@Entity
@Table(name="Test_TreeType")
public class TreeType {
   private Integer id;
   private String name;
   private ForestType forestType;
   @ManyToOne(fetch = FetchType.LAZY)
   @JoinTable(name="Test_Tree_Forest",
      joinColumns = @JoinColumn(name="tree_id"),
      inverseJoinColumns = @JoinColumn(name="forest_id") )
   public ForestType getForestType() {// forestType的getter，setter方法必须在这里，否则会出错
      return forestType;
   }
   public void setForestType(ForestType forestType) {
      this.forestType = forestType;
   }

   @Id
   @GeneratedValue
   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;
   }
}

@Entity
@Table(name="Test_ForestType")
public class ForestType {
   private Integer id;
   private String name;
   private Set<TreeType> trees;
   @OneToMany(mappedBy="forestType")
   public Set<TreeType> getTrees() {// trees的getter，setter方法必须在这里，否则会出错
      return trees;
   }
   public void setTrees(Set<TreeType> trees) {
      this.trees = trees;
   }
  
   @Id @GeneratedValue
   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;
   }
}

一对多(One-to-Many)
使用@OneToMany批注可定义一对多关联，一对多关联可以是双向关联。
在EJB3规范中多对一这端几乎总是双向关联中的主体(owner)端，而一对多这端关联批注为@OneToMany(mappedBy...)
@Entity
Public class Troop{
   @OneToMany(mappedBy=”troop”)
Public Set<Soldier> getSoldiers(){
......
}

@Entity
Public class Soldier{
   @ManyToOne
   @JoinColumn(name=”troop_fk”)
Public Troop getTroop(){
......
}

Troop通过troop属性和Soldier建立一对多的双向关联，在mappedBy端不必也不能再定义任何物理映射。
对于一对多的双向映射，如果要一对多这一端维护关联关系，你需要删除mappedBy元素并将多对一这端的@JoinColoumn的insertable和updatabel设置为false。这种方案不会得到什么明显的优化，而且还会增加一些附加的UPDATE语句。

单向：
通过在被拥有的实体端(owned entity)增加一个外键列来实现一对多单向关联是很少见的，也是不推荐的，建议通过一个联接表来实现这种关联(下面会讲到)。
@JoinColoumn批注来描述这种单向关联关系
@Entity
Public class Customer{
   @OneToMany
@JoinColoumn(name=”CUST_ID”)
Public Set<ticket> getTickets() {
.....
}
@Entity
Public class Ticket{
   ...
}
Customer通过CUST_ID列和Ticket建立了单向关联关系
通过关联表处理单向关联：
通过联接表处理单向一对多关联是首选方式，这种关联通过@JoinTable批注进行描述
@Entity
Public class Trainer{
@OneToMany
@JoinTable(
   name = "TrainedMonkeys",
  jonColumns = {@JoinColumn(name="trainer_id"},
   inverseJoinColumns = @JoinColumn(name = "monkey_id")
   )
public Set<Monkey> getTrainedMonkeys() {
      return trainedMonkeys;
   }
......
}

@Entity
public class Monkey {
...//no bidir
}

上面这个例子中，Trainer通过TrainedMonkeys表和Monkey建立了单向关联，其中外键trainer_id关联到Trainer(joinColoumn),而外键monkey_id关联到Monkey(inversejionColoumns)
默认处理机制：
通过联接表来建立单向一对多关联不需要描述任何物理映像，表名由以下三个部分组成：主表(ownertable)表名+从表(the other side table)表名，指向主表的外键名：主表表名+下划线+主表主键列名，指向从表的外键名：主表所对应实体的属性名+下划线+从表主键列名，指向从表的外键定义为唯一约束，用来表示一对多的关联关系。
@Entity
public class Trainer{
   @OneToMany
   Public Set<Tiger> getTrainedTigers(){
... ...
}

@Entity
public class Tiger{
.. ..//no bidir
}
上面这个例子中，Trainer和Tiger通过联接表Trainer_Tiger建立单向关联关系，其中外键trainer_id关联到Trainer,而外键trainedTigers_id关联到Tiger

5.1    一对一映射
双向一对一关系需要在关系维护端（owner side）的one2one Annotition定义mappedBy属性。建表时在关系被维护端（inverse side）建立外键列指向关系维护端的主键列。
假设Country 和 Capital 是双向一对一的关系，具体元数据声明如下:

public class Country {       
@OneToOne(optional = true,cascade = CascadeType.ALL, mappedBy = "country")       
private Capital capital;
}

public class Capital {       
@OneToOne(optional = false, cascade = CascadeType.ALL)       
@JoinColumn(name = "COUNTRY_ID", referencedColumnName = "id")       
private Country country;                                      

代码中元数据的说明：
元数据描述:
@OneToOne(optional = true,cascade = CascadeType.ALL, mappedBy = "country")
optional声明关系是否是必须存在的，即是否允许其中一端为null。
cascade声明级联操作。
@JoinColumn(name = "COUNTRY_ID", referencedColumnName = "id")
name声明外键列的名字，referencedColumnName声明外键指向列的列名。

5.2   一对多映射
双向一对多关系，一是关系维护端（owner side），多是关系被维护端（inverse side）。 建表时在关系被维护端建立外键列指向关系维护端的主键列。
假设Father 和 Child 是双向一对多的关系，具体元数据声明如下:
public class Father {       
@OneToMany(targetEntity = Child.class, cascade = CascadeType.ALL, mappedBy = "father")       
public List<Child> getChildren() {              
return children;        }
}

public class Child {       
@ManyToOne       
@JoinColumn(name = "FATHER_ID", referencedColumnName = "id")       
public Father getFather() {              
return father;       
}
}
 
代码中元数据的说明：元数据描述:
@OneToMany(targetEntity = Child.class, cascade = CascadeType.ALL, mappedBy = "father")
targetEntity = Child.class表明关系另一端的实体类型
cascade声明级联操作。
mappedBy声明关系维护端的字段（field）名。
@ManyToOne
@JoinColumn(name = "FATHER_ID", referencedColumnName = "id")
name声明外键列的名字，referencedColumnName声明外键指向列的列名。

5.3     多对多映射
多对多映射采取中间表连接的映射策略，建立的中间表将分别引入两边的主键作为外键。
EJB3对于中间表的元数据提供了可配置的方式，用户可以自定义中间表的表名，列名。
假设Teacher 和 Student是多对多的关系，具体元数据声明如下:
pubic class Teacher{       
@ManyToMany(targetEntity = Student.class, cascade = CascadeType.PERSIST)       
@JoinTable(table = @Table(name = "M2M_TEACHER_STUDENT"),       
joinColumns = @JoinColumn(name = "TEACHER_ID", referencedColumnName = "ID"), 
inverseJoinColumns = @JoinColumn(name = "STUDENT_ID", referencedColumnName = "ID"))       
public List<Student> getStudents() {
return students;
}                                     
}

public class Student{       
@ManyToMany(targetEntity = Teacher.class, mappedBy = "students")       
public List<Teacher> getTeachers() {              
return teachers;        }
}

代码中元数据的说明：
元数据描述:
@ManyToMany(targetEntity = Student.class, cascade = CascadeType.PERSIST)
targetEntity = Student.class表明关系另一端的实体类型。cascade声明级联操作。
@JoinTable(table = @Table(name = "M2M_TEACHER_STUDENT"),
joinColumns = @JoinColumn(name = "TEACHER_ID", referencedColumnName = "ID"),
inverseJoinColumns = @JoinColumn(name = "STUDENT_ID", referencedColumnName = "ID"))
JoinTable配置中间表信息，它由3个部分组成:
1) table = @Table(name = "M2M_TEACHER_STUDENT") ,声明中间表的名字
2） joinColumns ，定义中间表与关系维护端的外键关系。
3） inverseJoinColumns，定义中间表与inverse端的外键关系.

本文来自CSDN博客，出处：http://blog.csdn.net/senton/archive/2007/03/15/1529969.aspx

1.设置Pojo为实体

01.@Entity //标识这个pojo是一个jpa实体   
02.public class Users implements Serializable {   
03.}  

2.设置表名

01.@Entity   
02.@Table(name = "users") //指定表名为users   
03.public class Users implements Serializable {   
04.}  

3.设置主键

01.public class Users implements Serializable {   
02.@Id   
03.private String userCode;  

4. 设置字段类型
通过@Column注解设置，包含的设置如下
.name：字段名
.unique：是否唯一
.nullable：是否可以为空
.inserttable：是否可以插入
.updateable：是否可以更新
.columnDefinition: 定义建表时创建此列的DDL
.secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字。

01.@Column(name = "user_code", nullable = false, length=32)//设置属性userCode对应的字段为user_code，长度为32，非空   
02.private String userCode;   
03.@Column(name = "user_wages", nullable = true, precision=12, scale=2)//设置属性wages对应的字段为user_wages，12位数字可保留两位小数，可以为空   
04.private double wages;   
05.@Temporal(TemporalType.DATE)//设置为时间类型   
06.private Date joinDate;  

5.字段排序
在加载数据的时候可以为其指定顺序，使用@OrderBy注解实现

01.@Table(name = "USERS")   
02.public class User {   
03.@OrderBy(name = "group_name ASC, name DESC")   
04.private List books = new ArrayList();   
05.}  

6.主键生成策略

01.public class Users implements Serializable {   
02.@Id   
03.@GeneratedValue(strategy=GenerationType.IDENTITY)//主键自增，注意，这种方式依赖于具体的数据库，如果数据库不支持自增主键，那么这个类型是没法用的   
04.@Column(name = "user_id", nullable = false)   
05.private int userId;   
06. 
07. 
08.public class Users implements Serializable {   
09.@Id   
10.@GeneratedValue(strategy=GenerationType.TABLE)//通过一个表来实现主键id的自增，这种方式不依赖于具体的数据库，可以解决数据迁移的问题   
11.@Column(name = "user_code", nullable = false)   
12.private String userCode;   
13. 
14. 
15.public class Users implements Serializable {   
16.@Id   
17.@GeneratedValue(strategy=GenerationType.SEQUENCE)//通过Sequence来实现表主键自增，这种方式依赖于数据库是否有SEQUENCE，如果没有就不能用   
18.@SequenceGenerator(name="seq_user")   
19.@Column(name = "user_id", nullable = false)   
20.private int userId;  

7.一对多映射关系
有T_One和T_Many两个表，他们是一对多的关系，注解范例如下
主Pojo

01.@Entity   
02.@Table(name = "T_ONE")   
03.public class One implements Serializable {   
04.private static final long serialVersionUID = 1L;   
05.@Id   
06.@Column(name = "ONE_ID", nullable = false)   
07.private String oneId;   
08.@Column(name = "DESCRIPTION")   
09.private String description;   
10.@OneToMany(cascade = CascadeType.ALL, mappedBy = "oneId")//指向多的那方的pojo的关联外键字段   
11.private Collection<Many> manyCollection;   

子Pojo

01.@Entity   
02.@Table(name = "T_MANY")   
03.public class Many implements Serializable {   
04.private static final long serialVersionUID = 1L;   
05.@Id   
06.@Column(name = "MANY_ID", nullable = false)   
07.private String manyId;   
08.@Column(name = "DESCRIPTION")   
09.private String description;   
10. 
11.@JoinColumn(name = "ONE_ID", referencedColumnName = "ONE_ID")//设置对应数据表的列名和引用的数据表的列名   
12.@ManyToOne//设置在“一方”pojo的外键字段上   
13.private One oneId;   

8.多对多映射关系
貌似多对多关系不需要设置级联，以前用hibernate的时候着实为多对多的级联头疼了一阵子，JPA的多对多还需要实际的尝试一下才能有所体会。
估计JPA的多对多也是可以转换成两个一对多的。

第一个Pojo

01.@Entity   
02.@Table(name = "T_MANYA")   
03.public class ManyA implements Serializable {   
04.private static final long serialVersionUID = 1L;   
05.@Id   
06.@Column(name = "MANYA_ID", nullable = false)   
07.private String manyaId;   
08.@Column(name = "DESCRIPTION")   
09.private String description;   
10.@ManyToMany   
11.@JoinTable(name = "TMANY1_TMANY2", joinColumns = {@JoinColumn(name = "MANYA_ID", referencedColumnName = "MANYA_ID")}, inverseJoinColumns = {@JoinColumn(name = "MANYB_ID", referencedColumnName = "MANYB_ID")})   
12.private Collection<ManyB> manybIdCollection;   

第二个Pojo

01.@Entity   
02.@Table(name = "T_MANYB")   
03.public class ManyB implements Serializable {   
04.private static final long serialVersionUID = 1L;   
05.@Id   
06.@Column(name = "MANYB_ID", nullable = false)   
07.private String manybId;   
08.@Column(name = "DESCRIPTION")   
09.private String description;   
10.@ManyToMany(mappedBy = "manybIdCollection")   
11.private Collection<ManyA> manyaIdCollection;   

9.一对一映射关系
主Pojo

01.@Entity   
02.@Table(name = "T_ONEA")   
03.public class OneA implements Serializable {   
04.private static final long serialVersionUID = 1L;   
05.@Id   
06.@Column(name = "ONEA_ID", nullable = false)   
07.private String oneaId;   
08.@Column(name = "DESCRIPTION")   
09.private String description;   
10.@OneToOne(cascade = CascadeType.ALL, mappedBy = "oneA")//主Pojo这方的设置比较简单，只要设置好级联和映射到从Pojo的外键就可以了。   
11.private OneB oneB;  
从Pojo

01.@Entity   
02.@Table(name = "T_ONEB")   
03.public class OneB implements Serializable {   
04.private static final long serialVersionUID = 1L;   
05.@Id   
06.@Column(name = "ONEA_ID", nullable = false)   
07.private String oneaId;   
08.@Column(name = "DESCRIPTION")   
09.private String description;   
10.@JoinColumn(name = "ONEA_ID", referencedColumnName = "ONEA_ID", insertable = false, updatable = false)//设置从方指向主方的关联外键，这个ONEA_ID其实是表T_ONEA的主键   
11.@OneToOne   
12.private OneA oneA;   

10 大字段

01.@Lob //对应Blob字段类型   
02.@Column(name = "PHOTO")   
03.private Serializable photo;   
04.@Lob //对应Clob字段类型   
05.@Column(name = "DESCRIPTION")   
06.private String description;  

11.瞬时字段
不需要与数据库映射的字段，在保存的时候不需要保存倒数据库

01.@Transient   
02.private int tempValue;   
03. 
04.public int getTempValue(){   
05.get tempValue;   
06.}   
07. 
08.public void setTempValue(int value){   
09.this.tempValue = value;   
10.}