注解映射必须满足两大条件：Hibernate3.2以上版本和JSEE 5。
@Entity
类注释，所有要持久化的类都要有
@Entity
public class
Org implements java.io.Serializable {
}
@Id
主键
@Id
@GeneratedValue
private
String orgId;
private String
orgName;
@Column(name="...")
该属性对应表中的字段是什么，没有name表示一样
@Table 对象与表映射
@UniqueConstraint
唯一约束
@Version 方法和字段级，乐观锁用法，返回数字和timestamp，数字为首选
@Transient
暂态属性，表示不需要处理
@Basic
最基本的注释。有两个属性：fetch是否延迟加载，optional是否允许null
@Enumerated
枚举类型
@Temporal 日期转换。默认转换Timestamp
@Lob
通常与@Basic同时使用，提高访问速度。
@Embeddable 类级，表可嵌入的
@Embedded
方法字段级，表被嵌入的对象和@Embeddable一起使用
@AttributeOverrides
属性重写
@AttributeOverride
属性重写的内容和@AttributeOverrides一起嵌套使用
@SecondaryTables
多个表格映射
@SecondaryTable
定义辅助表格映射和@SecondaryTables一起嵌套使用
@GeneratedValue
标识符生成策略，默认Auto
表与表关系映射
@OneToOne：一对一映射。它包含五个属性：
targetEntity:关联的目标类
Cascade:持久化时的级联操作，默认没有
fetch:获取对象的方式，默认EAGER
Optional:目标对象是否允许为null，默认允许
mappedBy:定义双向关联中的从属类。
单向：
@JoinColumn:定义外键(主表会多一字段，做外键)
@OneToMany：一对多映射；@ManyToOne：多对一映射
单向一对多：
@OneToMany(cascade=CascadeType.ALL)
@JoinColumn(name="book_oid")/**book：表；oid：book表的主键；无name会按此规则自动生成*/
单向多对一：
@ManyToOne(cascade=CascadeType.ALL)
@JoinColumn(name="author_oid")
关联表格一对多：
@OneToMany(cascade=CascadeType.ALL)
@JoinTable(joinColumn={@JoinColumn(name="BOOK_OBJECT_OID")},inverseJoinColumns={@JoinColumn(name="AUTHER_OBJECT_OID")})
双向一对多或多对一：
不需要多一张表，只是使用mappedBy:使用在One一方，值为One方类名表示Many的从属类。
@Entity
Java代码 
@Entity
public
class Org implements java.io.Serializable {
//
Fields
@Id
@GeneratedValue
private
String orgId;
private String
orgName;
@OneToMany(mappedBy
= "org")
private
List<Department> departments;
//
Constructors
...
// Property accessors
...
}
@Entity public class Org implements java.io.Serializable { // Fields @Id @GeneratedValue private String orgId; private String orgName; @OneToMany(mappedBy = "org") private List<Department> departments; // Constructors ... // Property accessors ... }
@Entity
public class Department implements
java.io.Serializable {
//
Fields
@Id
@GeneratedValue
private String id;
private String
name;
@ManyToOne(fetch=FetchType.EAGER)
@JoinColumn(name="org_orgId")
private
Org org;
@OneToMany(mappedBy =
"department")
private
List<Employee> employees;
//
Constructors
public List<Employee>
getEmployees() {
return
employees;
}
public void
setEmployees(List<Employee> employees) {
this.employees =
employees;
}
public Org getOrg()
{
return org;
}
public void
setOrg(Org org) {
this.org =
org;
}
/** default constructor
*/
.
.
.
}
Java代码
@Entity
public
class Employee implements java.io.Serializable {
//
Fields
@Id
@GeneratedValue
private
String employeeId;
private String
employeeName;
private String
passWord;
private Integer
age;
private
Integer sex;
@ManyToOne(fetch=FetchType.EAGER)
@JoinColumn(name="department_id")
private
Department department;
public Department
getDepartment() {
return
department;
}
public
void setDepartment(Department department) {
this.department
= department;
}
/**
default constructor
*/
...
// Property accessors
...
}
@Entity public class Employee implements java.io.Serializable { // Fields @Id @GeneratedValue private String employeeId; private String employeeName; private String passWord; private Integer age; private Integer sex; @ManyToOne(fetch=FetchType.EAGER) @JoinColumn(name="department_id") private Department department; public Department getDepartment() { return department; } public void setDepartment(Department department) { this.department = department; } /** default constructor */ ... // Property accessors ... }
双向多对多：@ManyToMany.单向多对多这里不在赘述（没有太多实际意义）
这个比较简单，看下代码就明白了：
@Entity
public
class Book implements java.io.Serializable
{
@Id
private int id;
private
String name;
private float
money;
@ManyToMany(cascade =
CascadeType.ALL)
private List<Author>
authors;
public List<Author> getAuthors()
{
return authors;
}
public void
setAuthors(List<Author> authors) {
this.authors =
authors;
}
...
}
@Entity
public class
Author implements java.io.Serializable
{
@Id
private int id;
private
String name;
private int
age;
@ManyToMany(mappedBy="authors")
private
List<Book> books;
public List<Book> getBooks()
{
return books;
}
public void
setBooks(List<Book> books) {
this.books =
books;
}
...
}
基于注解的hibernate主键设置：@Id.
那么它的生成规则是什么呢？是由@GeneratedValue来规定的。
我们先来看看它是如何定义的：
Java代码
@Target({METHOD,FIELD})
@Retention(RUNTIME)
public @interface
GeneratedValue{
GenerationType strategy() default AUTO;
String generator() default "";
}
@Target({METHOD,FIELD}) @Retention(RUNTIME) public @interface GeneratedValue{ GenerationType strategy() default AUTO; String generator() default ""; }
Java代码
public
enum GenerationType{
TABLE,
SEQUENCE,
IDENTITY,
AUTO
}
public enum GenerationType{ TABLE, SEQUENCE, IDENTITY, AUTO }
现在我们看到了，它提供了4种生成策略：
TABLE：使用一个特定的数据库表格来保存标识符序列。
SEQUENCE：生成序列化标识符。
IDENTITY：标识符有数据库自动生成（主要是自动增长型）
AUTO：标识符生成工作由hibernate自动处理。实际项目开发不建议使用。
注意：当主键为int，而数据库中又不是自动增长型时，使用@GeneratedValue是无法正常工作的。
我们也可以使用下面的方式来自己指定我们的主键值：
Java代码
@GeneratedValue(generator
= "c-assigned")
@GenericGenerator(name
= "c-assigned", strategy = "assigned")
private String
employeeId;
@GeneratedValue(generator = "c-assigned") @GenericGenerator(name = "c-assigned", strategy = "assigned") private String employeeId;
或者直接不要定义@GeneratedValue，只定义@Id效果也是一样的。