Hibernate 注解(Annotation) 的配置

一：映射简单属性：
实例1：

@Entity                                     (@Entity 注解将该类声明为持久类)
@Table(name="FRUITS_PATENT",catalog="",schema="",uniqueConstraints= {@UniqueConstraint(columnNames={"name","pwd"})})
(@Table 为实体Bean指定对应数据库表，目录和schema的名字,uniqueConstraints为表添加约束)
public class Patent implements Serializable
{
// 主键 唯一标示 id
@Id                             (@Id 注解声明了该实体Bean的标识符(OID))
@GeneratedValue(generator="paymentableGenerator")
(generator:表示主键生成器的名称,这个属性通常和ORM框架相关,例如,Hibernate可以指定uuid等主键生成方式)
@GenericGenerator(strategy="uuid",name="paymentableGenerator")
(strategy------表示主键生成策略: 
     GenerationType.AUTO   默认值。表示让ORM框架自动选择,对应hibernate中的native；
     GenerationType.TABLE  使用表一保存ID的值；
     GenerationType.IDENTITY  根据数据库的Identity字段生成；
     GenerationType.SEQUENCE  根据数据库表的Sequence字段生成；)
@Column(length=32)
private String id;

//名称
@Column(length=400)
(声明列属性：@Column
   name="列名",
   unique=false | true   唯一性，
   nullable= true | false  是否允许为空，
   insertable= true | false  是否允许插入数据，
   updateable=true | false  是否允许修改数据，
   length= 255  字段的长度设置，
   precision= 0   精度，
   scale=0    数值范围  )
private String name;
private String pwd;

//相关产品
@Transient                     (@Transient,忽略属性。该字段将不被持久化)
private List relateProduces;

// 申请日
@Temporal(TemporalType.DATE)
(日期时间属性:
   TemporalType.DATE   取值如：2012-06-06
   TemporalType.TIME   取值如：22:50:30
   TemporalType.TIMESTAMP 默认选项，取值如：2012-06-06  22:50:30)
private Date appDate;
  
     //说明书摘要
@Lob         
(@Lob 大对象属性，注解属性将被持久化为 Blog 或 Clob 类型：
具体的java.sql.Clob, Character[], char[] 和 java.lang.String 将被持久化为 Clob 类型.               java.sql.Blob, Byte[], byte[] 和 serializable type 将被持久化为 Blob 类型。)
@Basic(fetch=FetchType.LAZY,optional=true)

(@Basic表示一个简单的属性到数据库表的字段的映射;
   fetch: 表示该属性的读取策略,有EAGER和LAZY两种,分别表示立即加载(即加载数据的时候是一次性加载所有的数据，可能会造成不必要的性能浪费，使用是应该慎重考虑。)和延迟加载(即只有当你真正访问关联关系的时候，才会执行所需要的select语句),默认为EAGER;optional:表示该属性是否允许为null,默认为true)
@Column(name="DtaContent", columnDefinition="CLOB", nullable=true)
private String abs;

}
二：关联映射关系：
(1).  对于单向关联关系来说：关系写哪方，就由哪方来管理；
     而对于双向关联关系来说：一般情况由多方管理，
     Xml:inverse="true"同注解中的
     @OneToMany(@mappedBy="对方") //反向配置，交由对方管理

(2). 单向多对一映射，是把一方的id做为多方的一个外键使用注解                    @JoinColumn(name="外键名")配置在多方；
而单向一对多的映射中，是把一方的id做为多方的一个外键使用注解 @JoinColumn(name="外键名")配置在一方。

1.单向多对一关联映射：(多方有一方的引用，一方没有多方的引用)
订单Order和用户User是一个ManyToOne的关系，实例如下：
@Entity
public class Order{
  @Id
  @GeneratedValue
  private Long id;
  private String name;
 
  @ManyToOne(cascade={CascadeType.PERSIST, CascadeType.MERGE})
  @JoinColumn(name="user_id")                                 (@JoinColumn(name="外键"))
  private User  user;
}
(@ManyToOne表示一个多对一的映射,该注解标注的属性通常是数据库表的外键;
optional:是否允许该字段为null,该属性应该根据数据库表的外键约束来确定,默认为true
fetch:表示抓取策略,默认为FetchType.EAGER(即使加载)，或者FetchType.LAZY(即延迟加载)
cascade:指定级联操作的行为(可多选)，默认为无级联操作：
CascadeType.PERSIST：级联新增
CascadeType.MERGE：级联修改
CascadeType.REMOVE：级联删除
CascadeType.REFRESH：级联刷新
CascadeType.ALL：以上4种方法都适用
targetEntity:表示该属性关联的实体类型.该属性通常不必指定,ORM框架根据属性类型自动判断targetEntity.)



@Entity
public class User{
  @Id
  @GeneratedValue
  private Long id;
  private String name;
}

2.单向一对多关联映射(一方有集合属性，包含多个多方，而多方没有一方的引用)：
种类Category 和产品Product 是OneToMany的关联关系，实例如下：
@Entity
public class Category {
  @Id
  @GeneratedValue
  private Long id;
  private String name;

  @OneToMany(cascade=CascadeType.ALL)
  @JoinColumn(name="cate_id")                                 (@JoinColumn(name="外键"))
  private List<Product> productList;
}

@Entity
public class Product {
  @Id
  @GeneratedValue
  private Long id;
  private String name;
}

3.双向一对多关联映射(两边都有对方的引用，方便查询)：
种类Category 和产品Product 是OneToMany的关联关系，实例如下：
@Entity
public class Category {
  @Id  @GeneratedValue
  private Long id;
  private String name;

  @OneToMany(cascade=CascadeType.ALL,mappedBy="cate")
  private List<Product> productList;
}
(@OneToMany 设置一对多关联。
cascade属性指定关联级别,cascade属性有五个值，分别是
CascadeType.PERSIST(级联新建)，
CascadeType.REMOVE（级联删除），
CascadeType.REFRESH（级联刷新），
CascadeType.MERGE（级联更新），
CascadeType.ALL（全部四项）；
fetch指定是否延迟加载，值为FetchType.LAZY表示延迟，为FetchType.EAGER表示立即加载。
(mappedBy="多段的属性"：用在双向关联中，把关系的维护权反转)  )
@Entity
public class Product {
  @Id  @GeneratedValue
  private Long id;
  private String name;

  @ManyToOne(cascade=
     {CascadeType.PERSIST,CascadeType.MERGE,CascadeType.REFRESH})
  @JoinColumn(name="cate_id")
  private Category cate;
}
双向一对多关联映射配置方法：
"一端"配置:
@OneToMany(cascade=CascadeType.ALL,mappedBy="“多端”的属性")
Public List<“多端”类> get“多端”列表()  { return “多端”列表 }
“多端”配置:
  方法一：
@ManyToOne(cascade={CasCadeType.PERSIST,CascadeType.MERGE})
@JoinColumn(name="外键")
public 主表类 get主表类()   { return 主表对象 }
  方法二：
@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.MERGE})
@JoinTable(name="关联表名"，
joinColumns = @JoinColumn(name="主表外键"),
     inverseJoinColumns = @JoinColumns(name="从表外键")  )

4.一对一基于外键关联：
用户 User(主表)和省份证号 IdCard (从表)是一对一的关联关系，实例如下：
@Entity
public class User{
  @Id
  @GeneratedValue
  private Long id;
  private String loginName;

  @OneToOne(cascade=CascadeType.ALL,fetch=FetchType.LAZY)
  @JoinColumn(name="card_id")
  private IdCard  idCard;
}
(@OneToOne 设置一对一的关联关系。
cascade属性指定关联级别，
fetch：指定数据的加载策略，
      (@JoinColumn(name="外键"))   )

@Entity
public class IdCard {
  @Id
  @GeneratedValue
  private Long id;
  private String idCardNo;
  @OneToOne(mappedBy="idCard") 
                   (mappedBy="主表类中的从表属性"：用在双向关联中，把关系的维护权反转)
  private User user;
}

一对一基于外键的关联配置方法：
方法一：
  主表配置：
@OneToOne(cascade = CascadeType.ALL,fetch=FetchType.LAZY/EAGER)
@JoinColumn(name="主表外键")  //这里指定的是数据库中的外键字段名。
public 从表类 get从表类()  {return 从表类 }
  从表配置：
@OneToOne(mappedBy ="主表类中的从表属性")
//例主表User中有一个从表属性是IdCard  类型的idCard  ，这里就填idCard 
public 主表类 get主表类() { return 主表对象 }
注意：@JoinColumn是可选的。
      默认值是从表变量名+"_"+从表的主键（注意，这里加的是主键。而不是主键对应的变量）。  

方法二：
  主表配置：
@OneToOne(cascade=CascadeType.ALL,fetch=FetchType.LAZY/EAGER)
@JoinTable( name="关联表名",
            joinColumns = @JoinColumn(name="主表外键"),
            inverseJoinColumns = @JoinColumns(name="从表外键")  )
  从表配置：
     @OneToOne(mappedBy ="主表类中的从表属性")
//例主表User中有一个从表属性是IdCard  类型的idCard  ，这里就填idCard public 主表类 get主表类(){return 主表对象}

5.单向多对多关联映射：
学生Student和课程Course是多对多的关联关系，实例如下：
@Entity
public class Student{
  @Id @GeneratedValue
  private Long id;
  private String name;
  private String grade;

  @ManyToMany(cascade=CascadeType.PERSIST)
  @JoinTable(name="student_course",
       joinColumns={@JoinColumn(name="student_id")},
       inverseJoinColumns={@JoinColumn(name="course_id")})
  private Set<Course> courses;
}

@Entity
public class Course {
  @Id @GeneratedValue
  private Long id;
  private String name;
}
6.双向多对多关联映射：
  学生Student和课程Course是多对多的关联关系，实例如下：
@Entity
public class Student{
  @Id
  @GeneratedValue
  private Long id;
  private String name;
  private String grade;

  @ManyToMany(cascade=CascadeType.PERSIST)
  @JoinTable(name="student_course",
       joinColumns={@JoinColumn(name="student_id")},
       inverseJoinColumns={@JoinColumn(name="course_id")})
  private Set<Course> courses;
}

@Entity
public class Course {
  @Id
  @GeneratedValue
  private Long id;
  private String name;

  @ManyToMany(mappedBy="courses")
  private Set<Student> students;
}

7.多对多拆成两个一对多(1-->*<--1) 关联映射：
学生Student和课程Course是多对多的关联关系，由于多对多关系不能保存两个实体之间共有的属性，所以用一个中间实体类来记录两个多对多实体之间共有的关系；可以用一个StudentCourse实体来表示两者多对多中的众多关系中的一个关系。即Student与StudentCourse，Course与StudentCourse之间的关系都为一对多的关系。

@Entity
public class Student{
  @Id
  @GeneratedValue
  private Long id;
  private String name;
  private String grade;

  @OneToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},mappedBy="stu")
  @JoinColumn(name="student_id")
  private List<StudentCourse> scs;
}
@OneToMany(cascade=CascadeType.ALL,mappedBy="“多端”的属性名称")
@JoinColumn(name="外键")
Public List<“多端”类> get“多端”列表()  { return “多端”列表 }

@Entity
public class Course{
  @Id
  @GeneratedValue
  private Long id;
  private String name;

  @OneToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},mappedBy="cou")
  @JoinColumn(name="course_id")
  private List<StudentCourse> scs;
}

@Entity
public class StudentCourse {
  @Id
  @GeneratedValue
  private Long id;

  @ManyToOne(cascade={CascadeType.PERSIST,CascadeType.MERGE})
  @JoinColumn(name="student_id",nullable=false)
  private Student  stu;

  @ManyToOne(cascade={CascadeType.PERSIST,CascadeType.MERGE})
  @JoinColumn(name="course_id", nullable=false)
  private Course  cou;
  private Double score;

}
@ManyToOne(cascade={CasCadeType.PERSIST,CascadeType.MERGE})
@JoinColumn(name="外键")
public 主表类 get主表类()   { return 主表对象 }