hibernate映射配置Annotation方式

import java.util.HashSet;
import java.util.Set;
import javax.persistence.*;
import org.hibernate.annotations.GenericGenerator;

@Entity
@Table(name = "department", catalog = "db4myeclipse")
public class Department implements java.io.Serializable {

	private static final long serialVersionUID = 1L;
	private String id;
	private String deptName;
	private Department parentDept;
	private Set<User> users = new HashSet<User>(0);
	private Set<Department> childDepts = new HashSet<Department>(0);

	public Department() {
	}
	public Department(String id, String deptName) {
		this.id = id;
		this.deptName = deptName;
	}

	@GenericGenerator(name = "idGenerator", strategy = "assigned")
	@Id
	@GeneratedValue(generator = "idGenerator")
	@Column(name = "id", unique = true, nullable = false)
	public String getId() {
		return this.id;
	}

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

	@ManyToOne
	@JoinColumn(name = "parent_id")
	public Department getParentDept() {
		return this.parentDept;
	}

	public void setParentDept(Department parentDept) {
		this.parentDept = parentDept;
	}

	@Column(name = "deptName", nullable = false, length = 32)
	public String getDeptName() {
		return this.deptName;
	}

	public void setDeptName(String deptName) {
		this.deptName = deptName;
	}

	@OneToMany(mappedBy = "department")
	public Set<User> getUsers() {
		return this.users;
	}

	public void setUsers(Set<User> users) {
		this.users = users;
	}

	@OneToMany(mappedBy = "parentDept")
	public Set<Department> getChildDepts() {
		return this.childDepts;
	}

	public void setChildDepts(Set<Department> childDepts) {
		this.childDepts = childDepts;
	}

}

@Entity
@Table(name = "idcard", catalog = "db4myeclipse")
public class IdCard implements java.io.Serializable {

	private static final long serialVersionUID = 1L;
	private String id;
	private String cardNo;
	private Timestamp authDate;
	private User user;
	public IdCard() {
	}

	public IdCard(String cardNo, Timestamp authDate, User user) {
		this.cardNo = cardNo;
		this.authDate = authDate;
		this.user = user;
	}

	@GenericGenerator(name = "idGenerator", strategy = "uuid")
	@Id
	@GeneratedValue(generator = "idGenerator")
	@Column(name = "id", unique = true, nullable = false)
	public String getId() {
		return this.id;
	}

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

	@Column(name = "cardNo", nullable = false, length = 32)
	public String getCardNo() {
		return this.cardNo;
	}

	public void setCardNo(String cardNo) {
		this.cardNo = cardNo;
	}

	@Column(name = "authDate", nullable = false)
	public Timestamp getAuthDate() {
		return this.authDate;
	}

	public void setAuthDate(Timestamp authDate) {
		this.authDate = authDate;
	}
	
	@OneToOne(mappedBy = "idCard")
	public User getUser() {
		return this.user;
	}

	public void setUser(User user) {
		this.user = user;
	}
}

@Entity
@Table(name = "role", catalog = "db4myeclipse")
public class Role implements java.io.Serializable {

	private static final long serialVersionUID = 1L;
	private Integer id;
	private String roleName;
	private String roleDesc;
	private Set<User> users = new HashSet<User>(0);
	public Role() {
	}

	public Role(String roleName) {
		this.roleName = roleName;
	}
	public Role(String roleName, String roleDesc, Set<User> users) {
		this.roleName = roleName;
		this.roleDesc = roleDesc;
		this.users = users;
	}

	@GenericGenerator(name = "idGenerator", strategy = "native")
	@Id
	@GeneratedValue(generator = "idGenerator")
	@Column(name = "id", unique = true, nullable = false)
	public Integer getId() {
		return this.id;
	}

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

	@Column(name = "roleName", nullable = false, length = 32)
	public String getRoleName() {
		return this.roleName;
	}

	public void setRoleName(String roleName) {
		this.roleName = roleName;
	}

	@Column(name = "roleDesc", length = 128)
	public String getRoleDesc() {
		return this.roleDesc;
	}

	public void setRoleDesc(String roleDesc) {
		this.roleDesc = roleDesc;
	}

	@ManyToMany(
			targetEntity = com.jaeson.hibernatestudy.bean.User.class,
			mappedBy = "roles")
	public Set<User> getUsers() {
		return this.users;
	}

	public void setUsers(Set<User> users) {
		this.users = users;
	}
 
}

@Entity
@Table(name = "user", catalog = "db4myeclipse")
public class User implements java.io.Serializable {

	private static final long serialVersionUID = 1L;
	private String id;
	private IdCard idCard;
	private Department department;
	private String userName;
	private Address address;
	private Set<Role> roles = new HashSet<Role>(0);
	public User() {
	}

	public User(String userName, Address address) {
		this.userName = userName;
		this.address = address;
	}

	@GenericGenerator(name = "idGenerator", strategy = "uuid")
	@Id
	@GeneratedValue(generator = "idGenerator")
	@Column(name = "id", unique = true, nullable = false)
	public String getId() {
		return this.id;
	}

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

	@OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
	@JoinColumn(name="card_id", unique=true)
	public IdCard getIdCard() {
		return this.idCard;
	}

	public void setIdCard(IdCard idCard) {
		this.idCard = idCard;
	}

	@ManyToOne(fetch = FetchType.LAZY)
	@JoinColumn(name = "dept_id")
	public Department getDepartment() {
		return this.department;
	}

	public void setDepartment(Department department) {
		this.department = department;
	}

	@Column(name = "userName", nullable = false, length = 32)
	public String getUserName() {
		return this.userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	@Embedded
	@AttributeOverrides({
		@AttributeOverride(name="address",	column = @Column(name="address") ),
		@AttributeOverride(name="zipCode",	column = @Column(name="zipCode") ),
		@AttributeOverride(name="phone", 	column = @Column(name="phone") ),
		})
	public Address getAddress() {
		return this.address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}
 
	@ManyToMany(
			targetEntity=com.jaeson.hibernatestudy.bean.Role.class,
			cascade=CascadeType.ALL)
	@JoinTable(
			name="user_role",
			joinColumns=@JoinColumn(name="user_id"),
			inverseJoinColumns=@JoinColumn(name="role_id")
			)
	public Set<Role> getRoles() {
		return this.roles;
	}

	public void setRoles(Set<Role> roles) {
		this.roles = roles;
	}
}
@Embeddable
public class Address implements Serializable {
 
	private static final long serialVersionUID = 1L;
	private String address;
	private Integer zipCode;
	private String phone;
 
	public Address() {}
 
	public Address(String address, Integer zipCode, String phone) {
		this.address = address;
		this.zipCode = zipCode;
		this.phone = phone;
	}
 
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public Integer getZipCode() {
		return zipCode;
	}
	public void setZipCode(Integer zipCode) {
 		this.zipCode = zipCode;
	}
	public String getPhone() {
 		return phone;
	}
	public void setPhone(String phone) {
 		this.phone = phone;
	}
}

 * 默认情况下hbm文件中的声明比类中的注解元数据具有更高的优先级。

 * hibernate使用javax.persistence.*定义的持久化注解

 * @Entity注解将一个类声明为一个实体bean(即一个持久化POJO类)
 * @Id注解则声明了该实体bean的标识属性.
 * 其他的映射定义是隐式的.这种以隐式映射为主体,以显式映射为例外的配置方式在新的EJ3规范中处于非常

   重要的位置.
 * 在对一个类进行注解时,你可以选择对它的的属性或者方法进行注解,根据你的选择,Hibernate的访问类型

   分别为 field或property.

 * @Table是类一级的注解, 通过@Table注解可以为实体bean映射指定表(table),目录(catalog)和schema的

   名字.
   如果没有定义@Table,那么系统自动使用默认值：实体的短类名(不附带包名).
   @Table元素包括了一个schema 和一个 catalog属性,如果需要可以指定相应的值. 
 
 * @Id注解可以将实体bean中的某个属性定义为标识符(identifier). 该属性的值可以通过应用自身进行设置,

   也可以通过Hiberante生成(推荐).
   使用 @GeneratedValue注解可以定义该标识符的生成策略: 
    strategy 指定生成的策略,默认是GenerationType.AUTO
    generator 指定生成主键使用的生成器
    • AUTO  - 可以是identity column类型,或者sequence类型或者table类型,取决于不同的底层数据库.
    • TABLE  - 使用表保存id值 
    • IDENTITY - 主键由数据库自动生成,主要是自动增长类型
    • SEQUENCE - sequence
   @org.hibernate.annotations.GenericGenerator 允许你定义一个Hibernate特定的id生成器.
   @GenericGenerator(name="generator", strategy = "uuid")
   @Id
   @GeneratedValue(generator="generator")
   @Column(name = "id", unique = true, nullable = false)

 * @Basic所有没有定义注解的属性等价于在其上面添加了@Basic注解. 通过 @Basic注解可以声明属性的

   获取策略(fetch strategy),FetchType.LAZY 或者 FetchType.EAGER.
 
 * @Column 注解可将属性映射到列.
   @Column(
        name="columnName";
        boolean unique() default false; 
        boolean nullable() default true;
        int length() default 255)

 *  组件映射:
    组件类必须在类一级定义@Embeddable注解. 在特定的实体的关联属性上使用@Embedded和 

    @AttributeOverride注解可以覆盖该属性对应的嵌入式对象的列映射：
    @Embedded
    @AttributeOverrides( {
        @AttributeOverride(name="address", column = @Column(name="address") ),
        @AttributeOverride(name="zipCode", column = @Column(name="zipCode") ),
        @AttributeOverride(name="phone",  column = @Column(name="phone") ),
    })

 * cascade：级联,它可以有有五个值可选,分别是：
    CascadeType.PERSIST：级联新建

    CascadeType.MERGE  ：级联更新
    CascadeType.REMOVE : 级联删除
    CascadeType.REFRESH：级联刷新

    CascadeType.ALL：以上全部四项

 * @OneToOne唯一外键关联:一对一关联可能是双向的.在双向关联中, 有且仅有一端是作为主体(owner)端

    存在的：主体端负责维护联接列(即更新). 
    对于不需要维护这种关系的从表则通过mappedBy属性进行声明.mappedBy的值指向主体的关联属性. 
    注释五个属性：targetEntity、cascade、fetch、optional 和mappedBy，
    fetch属性默认值是FetchType.EAGER。
    optional = true设置外键属性可以为null
    targetEntity属性:Class类型的属性。定义关系类的类型，默认是该成员属性对应的类类型
    cascade属性：CascadeType[]类型。

    外键端：

    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @JoinColumn(name="card_id", unique=true)
    主键端：

    @OneToOne(mappedBy = "idCard")

 * @Many-to-one:@JoinColumn是可选的,关联字段默认值为：主体的关联属性名＋下划线＋被关联端的

    主键列名. 
    fetch属性默认值是FetchType.EAGER。
    多端：

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="dept_id")

 *  @One-to-many:在EJB3规范中多对一这端几乎总是双向关联中的主体(owner)端, 而一对多这端的关联

     注解为：

     @OneToMany(mappedBy="department")
     fetch属性默认值是FetchType.LAZY。

 *  @Many-to-many:通过@ManyToMany注解可定义的多对多关联. 同时,你也需要通过注解@JoinTable

     描述关联表和关联条件. 如果是双向关联,其中一段必须定义为owner,另一端必须定义为inverse
     fetch属性默认值是FetchType.LAZY。
     @ManyToMany(
          targetEntity=com.jaeson.hibernatestudy.bean.Role.class,
          cascade={CascadeType.PERSIST, CascadeType.MERGE})
     @JoinTable(
          name="user_role",
          joinColumns=@JoinColumn(name="user_id"),
          inverseJoinColumns=@JoinColumn(name="role_id"))
    

     @ManyToMany(
          mappedBy = "roles",
          targetEntity = com.jaeson.hibernatestudy.bean.User.class)