直接上代码,一目了然, User UserDetail
import java.sql.Timestamp;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import static javax.persistence.GenerationType.IDENTITY;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;
/**
* User entity. @author MyEclipse Persistence Tools
*/
@Entity
@Table(name = "user")
public class User implements java.io.Serializable {
private Integer uid;
private String username;
private String password;
private String realname;
private UserDetail userDetail;
public User() {
userDetail = new UserDetail();
}
@Id
@GeneratedValue(strategy = IDENTITY)
@Column(name = "uid", unique = true, nullable = false)
public Integer getUid() {
return this.uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
@Column(name = "username", length = 30)
public String getUsername() {
return this.username;
}
public void setUsername(String username) {
this.username = username;
}
@Column(name = "password", length = 30)
public String getPassword() {
return this.password;
}
public void setPassword(String password) {
this.password = password;
}
@Column(name = "realname", length = 10)
public String getRealname() {
return this.realname;
}
public void setRealname(String realname) {
this.realname = realname;
}
//========================= 注意这里 ====================================
@OneToOne(fetch = FetchType.LAZY, optional = false)
@PrimaryKeyJoinColumn
public UserDetail getUserDetail() {
return this.userDetail;
}
public void setUserDetail(UserDetail userDetail) {
this.userDetail = userDetail;
}
//=======================================================================
}
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import org.hibernate.annotations.Parameter;
import org.hibernate.annotations.GenericGenerator;
/**
* UserDetail entity. @author MyEclipse Persistence Tools
*/
@Entity
@Table(name = "user_detail")
public class UserDetail implements java.io.Serializable {
private Integer udid;
private User user;
private String description;
public UserDetail() {
}
@Id
@GeneratedValue(generator = "pkGenerator")
@GenericGenerator(
name = "pkGenerator",
strategy = "foreign",
parameters = @Parameter(name = "property", value = "user")
)
@Column(name="udid")
public Integer getUdid() {
return this.udid;
}
public void setUdid(Integer udid) {
this.udid = udid;
}
//========================= 注意这里 ====================================
@OneToOne(mappedBy="userDetail", fetch=FetchType.LAZY, optional=false)
public User getUser() {
return this.user;
}
public void setUser(User user) {
this.user = user;
}
//=======================================================================
@Column(name = "description", length = 400)
public String getDescription() {
return this.description;
}
public void setDescription(String description) {
this.description = description;
}
}
分享到:
相关推荐
2. **懒加载与立即加载**:使用`fetch`属性来决定关联对象是延迟加载(lazy)还是立即加载(eager)。 3. **非空性约束**:如果一方是必须的,可以通过`optional=false`来设置。 **七、总结** `hibernate_one_to_...
在深入探讨Hibernate中的一对一(One-to-One)主键双线关联机制之前,我们首先需要理解几个核心概念:Hibernate框架、实体关系映射以及主键关联的基本原理。Hibernate是Java平台下的一款开源对象关系映射(ORM)框架...
在`hibernate_one2one_ufk_1`示例中,我们学习了如何配置和管理一对一的关系。这种关系在数据库中通常通过主键外键关联实现,Hibernate提供了多种方式来建立和维护这种关系,例如使用`@OneToOne`注解。 **五、懒...
3. "hibernate_one2one_pk_2"可能是关于一对一关系映射的,特别是当两个实体共享主键时的配置。 4. "hibernate_lazy_for_class"可能涉及懒加载的概念,即延迟加载关联的对象,直到真正需要它们的时候才从数据库中...
在一对一(One-to-One)主键关联关系中,两个实体类之间存在唯一对应的关系,通常一个实体对应另一个实体的一个实例,这种关系可以通过共享主键来实现。 在Hibernate中,一对一的主键关联关系可以通过以下几种方式...
另一种方式是让双方实体共享同一个主键,这需要在双方的ID字段上都使用`@Id`和`@OneToOne`注解,并指定`@PrimaryKeyJoinColumn`。 **四、级联操作** `CascadeType.ALL`表示所有操作(包括保存、更新、删除等)...
8. **延迟加载(Lazy Loading)** - Hibernate的懒加载机制,只在真正需要时加载关联对象,提高性能。 9. **事务管理** - Hibernate支持JTA(Java Transaction API)和 JDBC 事务管理,通过Transaction接口进行...
12. **延迟加载(Lazy Loading)**:为了提高效率,Hibernate允许对关联对象进行延迟加载,只有在真正需要时才会从数据库加载。 13. **状态转换**:对象在Hibernate中有三种状态:瞬时态(Transient)、持久态...
12. **延迟加载(Lazy Loading)**:Hibernate的懒加载策略允许关联对象在真正需要时才加载,以减少数据库交互。 13. **级联操作(Cascading)**:设置级联属性后,对一个实体的操作会级联影响到与之关联的其他实体...
- **懒加载(Lazy Loading)**:默认情况下,Hibernate 会延迟加载关联的对象,直到真正需要时才去数据库查询,以提高性能。 - **即时加载(Eager Loading)**:如果希望关联的对象在获取主对象时一起加载,可以设置...
- `fetch`属性用于指定加载策略,`join`表示在查询时一起加载,`select`表示延迟加载。 - `property-ref`属性用于指定关联对象的属性名称。 - `access`属性定义了访问策略,可以是字段或属性访问。 - `formula`属性...
此外,Hibernate 支持延迟加载(Lazy Loading)和瞬时状态(Transient)、持久化状态(Persistent)、托管状态(Managed)以及脱管状态(Detached)等对象状态管理。 这些知识点覆盖了 Hibernate 的基础配置、映射...
- 使用`fetch`属性可以控制关联加载策略,如`EAGER`(立即加载)或`LAZY`(延迟加载)。 - `optional`属性默认为`true`,表示关联对象可以为`null`,设置为`false`则强制关联对象必须存在。 ### 示例代码 在给定的...
11. **懒加载(Lazy Loading)**:延迟加载策略,只在真正需要时加载关联的对象,以提高性能。 12. **二级缓存(Second Level Cache)**:全局共享的缓存,用于存储整个应用的实体数据,提高数据读取速度。 13. **...
2. **主键共享**:在一对一关联中,有时两个实体会共享同一个主键,这种情况下,可以使用`@PrimaryKeyJoinColumn`注解来指定主键字段。 3. **关联的懒加载和即时加载**:Hibernate支持懒加载和即时加载策略,决定...
13. **延迟加载(Lazy Loading)** 为避免内存占用过大,Hibernate 提供了懒加载机制。默认情况下,关联对象不会立即加载,只有在真正使用时才会执行数据库查询。 通过这个“hibernate学习”资料,你可以深入了解...
- `fetch`:决定如何加载关联数据,`FetchType.LAZY`表示延迟加载,`FetchType.EAGER`表示立即加载。 **多对一关系详解:** 与一对多相反,多对一关系是多个子类实例指向一个父类实例。在上面的用户和订单例子中,...
10. **延迟加载(Lazy Loading)**: Hibernate提供了懒加载机制,只有在真正需要访问关联对象时才执行数据库查询,避免了不必要的性能开销。 11. **级联操作(Cascading)**: 可以设置级联属性,使得对一个实体的...