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 主表对象 }