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)
相关推荐
2. **映射机制**： Hibernate支持XML映射文件（hbm.xml）和注解映射两种方式，让对象与数据库表之间建立映射关系。 3. **Session和Transaction**： Session是Hibernate的主要工作单元，负责保存、更新和检索对象。...
**标题：“Hibernate继承映射(Annotation)详解”** 在Java持久化框架Hibernate中，继承映射是一种关键特性，它允许开发者将对象模型的继承结构映射到数据库的表结构。在传统的面向对象编程中，继承是实现代码复用和...
本文将深入探讨Hibernate中的组件映射，包括使用注解（Annotation）和XML配置两种方式，以帮助开发者更好地理解和应用这一功能。 一、Hibernate组件映射基础 组件映射是Hibernate中的一种特性，允许我们将一个类的...
已经不用*.hbm.xml这种映射文件了，都是用Annotation（注解）方式来完成实体与表之间的映射关系，这样看起来比用xml文件来映射更具有可读性，自我感觉以后Hibernate Annotation的映射方式将代替hibernate 的*.hbm....
Spring提供了`LocalSessionFactoryBean`用于配置基于XML的Hibernate映射，而`AnnotationSessionFactoryBean`则用于处理基于注解的映射。这两个类分别处理不同的映射方式，所以默认情况下，它们不能直接共存于同一个...
在本篇文章中，我们将详细探讨如何将Spring MVC与Hibernate结合，并利用注解（Annotation）进行配置。 首先，让我们了解这两个框架的基本概念。Spring MVC是Spring框架的一部分，它是一个用于构建Web应用的模型-...
Hibernate Annotation则是Hibernate的一部分，它引入了Java注解，使得配置更加简洁，无需XML文件即可进行对象持久化。 **Hibernate API详解：** Hibernate API提供了对数据库操作的各种接口和类，包括Session、...
在Spring和Hibernate中，注解常用于配置和简化框架的使用，例如在类和方法上使用`@Transactional`进行事务管理，或使用`@Entity`、`@Table`等定义实体和表映射。 4. **声明式事务管理**：与编程式事务管理相比，...
在Hibernate 3.x版本中，引入了Annotation注解，这是一种元数据的方式，可以替代XML配置文件来描述对象与数据库表之间的映射关系。 **Hibernate Annotation注解** 在Hibernate 3.x之前，对象到数据库的映射通常...
### Struts2+Spring2+Hibernate3+Annotation所需JAR包详解 在Java Web开发领域，Struts2、Spring2和Hibernate3是三个非常重要的框架，它们分别负责Web层、业务逻辑层和服务持久化层的功能实现。为了更好地整合这三...
本篇将详细介绍如何在Spring 3和Hibernate 4中配置声明式事务管理，采用注解方式。 一、Spring的事务管理 Spring提供了两种事务管理方式：编程式事务管理和声明式事务管理。编程式事务管理需要在代码中显式地调用...
而Hibernate注解则是其在ORM（对象关系映射）领域的进一步进化，它允许开发者将元数据直接嵌入到Java类和属性的声明中，从而避免了XML配置文件的繁琐。本篇将详细阐述Hibernate注解的相关知识。 一、Hibernate注解...
Hibernate是Java领域最流行的ORM框架之一，它将Java对象与数据库表进行映射，通过对象的方式来操作数据库。Hibernate提供了一套强大的API，包括Session、SessionFactory、Query等，使得开发者可以进行CRUD（创建、...
随着技术的发展，Hibernate Annotation逐渐成为主流，因为它提供了更直观、更简洁的方式来映射对象关系模型（ORM）。这篇文档主要讨论的是Hibernate Annotation的使用方法，以及它如何替代传统的XML配置文件（*.hbm....
在Java开发领域，Hibernate作为一种强大的对象关系映射（ORM）框架，极大地简化了数据库操作。本篇将深入探讨Hibernate 3版本中的注解使用，帮助开发者理解如何利用注解进行数据持久化，提高开发效率。 一、...
**二、注解方式配置（Annotation）** 1. **主键关联** 使用注解配置主键关联，可以如下所示： ```java @Entity public class Person { @Id @GeneratedValue(strategy=GenerationType.AUTO) private Long id;...
**hibernate-annotation-helloworld** 是一个基于Hibernate框架，使用注解方式实现的Hello World示例项目。在Java世界中，Hibernate是一个流行的持久层框架，它极大地简化了数据库操作，尤其是在对象关系映射（ORM）...
3. **Hibernate Annotation**: Hibernate的注解是在Java类和属性上添加元数据的方式，它替代了传统的Hibernate XML配置文件。通过注解，可以在实体类和属性上直接定义数据库映射，如@Entity表示一个数据库表，@Table...