- 浏览: 152302 次
文章分类
最新评论
-
Rannn:
我只是偶尔路过的。二叉树的深度为lg(n) 叶子为2^(L-1 ...
完全二叉树叶子节点个数计算问题 -
have_life:
按住Ctrl+Shift 然后 按 -> 这样的光标键, ...
eclipse快捷键 -
have_life:
启动chrome隐身模式 Ctrl + Shift + N ...
快速恢复刚刚关闭的Chrome标签页的方法 -
have_life:
Shift + Alt + A 光标会变成一个十字 ...
eclipse快捷键 -
have_life:
Ctrl + Shift + X 把所有选中字母变大写Ctrl ...
eclipse快捷键
Husband.java
package com.one2one.bean;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
@Entity
@Table(name="husband",catalog="Hibernate_One2One_fk")
public class Husband {
private int id;
private String name;
private Wife wife;
@Id
@Column(name="id")
@GeneratedValue(strategy=GenerationType.AUTO)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name="name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToOne(cascade=CascadeType.ALL,mappedBy="husband")
public Wife getWife() {
return wife;
}
public void setWife(Wife wife) {
this.wife = wife;
}
}
Wife.java
package com.one2one.bean;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
@Entity
@Table(name="wife",catalog="Hibernate_One2One_fk")
public class Wife {
private int id;
private String name;
private Husband husband;
@Id
@Column(name="id")
@GeneratedValue(strategy=GenerationType.AUTO)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name="name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToOne(cascade=CascadeType.ALL)
@JoinColumn(name="husband_id")
public Husband getHusband() {
return husband;
}
public void setHusband(Husband husband) {
this.husband = husband;
}
}
导出的sql
create table Hibernate_One2One_fk.husband (
id integer not null auto_increment,
name varchar(255),
primary key (id)
)
create table Hibernate_One2One_fk.wife (
id integer not null auto_increment,
name varchar(255),
husband_id integer,
primary key (id)
)
alter table Hibernate_One2One_fk.wife
add index FK37AF119039AEDD (husband_id),
add constraint FK37AF119039AEDD
foreign key (husband_id)
references Hibernate_One2One_fk.husband (id)
测试代码
@Test
public void save(){
Session session=HibernateSessionFactory.getSession();
Transaction transaction=session.beginTransaction();
try {
transaction.begin();
Husband husband=new Husband();
husband.setName("张三");
session.save(husband);
Wife wife=new Wife();
wife.setName("如花");
wife.setHusband(husband);
session.save(wife);
transaction.commit();
} catch (HibernateException e) {
e.printStackTrace();
}
}
@Test
public void select(){
Session session=HibernateSessionFactory.getSession();
Husband husband=(Husband) session.get(Husband.class, 1);
System.out.println(husband.getName());
System.out.println(husband.getWife().getName());
}
link:http://www.blogjava.net/sxyx2008/archive/2010/10/18/335456.html
package com.one2one.bean;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
@Entity
@Table(name="husband",catalog="Hibernate_One2One_fk")
public class Husband {
private int id;
private String name;
private Wife wife;
@Id
@Column(name="id")
@GeneratedValue(strategy=GenerationType.AUTO)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name="name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToOne(cascade=CascadeType.ALL,mappedBy="husband")
public Wife getWife() {
return wife;
}
public void setWife(Wife wife) {
this.wife = wife;
}
}
Wife.java
package com.one2one.bean;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
@Entity
@Table(name="wife",catalog="Hibernate_One2One_fk")
public class Wife {
private int id;
private String name;
private Husband husband;
@Id
@Column(name="id")
@GeneratedValue(strategy=GenerationType.AUTO)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name="name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToOne(cascade=CascadeType.ALL)
@JoinColumn(name="husband_id")
public Husband getHusband() {
return husband;
}
public void setHusband(Husband husband) {
this.husband = husband;
}
}
导出的sql
create table Hibernate_One2One_fk.husband (
id integer not null auto_increment,
name varchar(255),
primary key (id)
)
create table Hibernate_One2One_fk.wife (
id integer not null auto_increment,
name varchar(255),
husband_id integer,
primary key (id)
)
alter table Hibernate_One2One_fk.wife
add index FK37AF119039AEDD (husband_id),
add constraint FK37AF119039AEDD
foreign key (husband_id)
references Hibernate_One2One_fk.husband (id)
测试代码
@Test
public void save(){
Session session=HibernateSessionFactory.getSession();
Transaction transaction=session.beginTransaction();
try {
transaction.begin();
Husband husband=new Husband();
husband.setName("张三");
session.save(husband);
Wife wife=new Wife();
wife.setName("如花");
wife.setHusband(husband);
session.save(wife);
transaction.commit();
} catch (HibernateException e) {
e.printStackTrace();
}
}
@Test
public void select(){
Session session=HibernateSessionFactory.getSession();
Husband husband=(Husband) session.get(Husband.class, 1);
System.out.println(husband.getName());
System.out.println(husband.getWife().getName());
}
link:http://www.blogjava.net/sxyx2008/archive/2010/10/18/335456.html
发表评论
-
hibernate 原生sql查询的结果集处理
2013-05-29 13:00 1884主要是谈怎么拼装 转换结果 其中涉及的主要是怎么理解 Ob ... -
compareTo()
2013-04-04 21:01 1179整体的意思就是 CompareTo()方法如果返回的负数,就是 ... -
java中接口与抽象类的区别
2012-10-17 15:02 842http://dev.yesky.com/436/75819 ... -
Java 的Runnable接口和继承Thread的区别
2012-10-02 23:25 800link: http://developer.51cto.co ... -
transaction annotation
2012-10-02 09:45 1159在dao中写了一个save的方法,一开始试了几次都发现没有数据 ... -
hibernate annotation [未全验证]
2012-10-01 21:36 1128使用JPA的时候,如果A B两个实体间是一对多,多对一的关系, ... -
设置虚拟机内存大小
2012-08-16 19:25 1215-Xms256m -Xmx256m -XX:MaxNewSiz ... -
@Autowired 的成员变量,报空指针错误
2012-08-13 13:33 5262比如 你 class LoginService { @A ... -
如何去取ContextConfiguration
2012-08-13 11:25 6084我们平时写test去测试Spring一起的程序时,一般都要加载 ... -
Java转型(向上或向下转型)
2012-08-12 15:15 1595在Java编程中经常碰到类型转换,对象类型转换主要包括向上转型 ... -
java中的重写 (override)
2012-08-11 14:36 1465父类 public abstract class A { ... -
@Table
2012-08-08 16:12 1431pojo 里还是尽量explicitly写一下 @Entit ... -
@Component 与 @Repository、@Service、@Controller
2012-08-08 15:54 939@Component是通用的 @Repository、@S ... -
<base href="<%=basePath%>">
2012-08-08 14:10 1233遇到这样的问题,在地址栏上这样访问。 http://local ... -
数据库中类型与java类型的对应关系
2012-08-03 00:57 971mysql: datatime, java:java.ut ... -
Quartz 使用的相关资源
2012-07-16 17:12 9151. 很简单详实的manual,和我第一次读那个mysql的感 ... -
深度遍历目录
2012-05-25 16:27 965深度遍历目录,读取properties文件 import ... -
java 中的static 和final连用
2012-05-21 19:57 1370下面的代码正确 public class Test { ... -
java 静态代码
2012-05-17 19:08 780具体的其中原因,还没弄明白,所以暂时先留着。 publi ... -
Java相关资源
2012-05-14 17:23 850poi: 将jsp页面导成word文件。
相关推荐
本文将深入探讨如何使用Hibernate注解实现基于外键的一对多双向关联。我们将通过具体实例来解析这个主题,并结合源码分析其工作原理。 首先,我们要明白一对多关联意味着一个实体可以拥有多个关联的实体。在数据库...
通过阅读《Hibernate_annotation_1to1_foreignKey》文档或博客,你可以更详细地了解如何配置和使用这种关联,包括示例代码、注意事项以及可能遇到的问题和解决方案。理解并熟练运用这些知识,能帮助你在使用...
本篇文章将深入探讨如何使用Hibernate Annotation来实现基于外键的单向多对一关联。 在关系型数据库中,多对一关联是一种常见的关系类型,意味着一个实体(如表)可以与另一个实体有多条记录关联,而另一个实体只能...
**Hibernate Annotation 中文文档** 在Java的持久化框架中,Hibernate是一个非常重要的工具,它极大地简化了数据库操作。随着技术的发展,Hibernate Annotation逐渐成为主流,因为它提供了更直观、更简洁的方式来...
《Hibernate Annotation API详解》 Hibernate是一个流行的Java持久化框架,它简化了数据库操作,使得开发者可以更专注于业务逻辑而不是底层的数据访问细节。在Hibernate 3.3版本中,引入了Annotation API,这是一种...
本篇将详细讲解如何使用Hibernate进行一对一单向外键关联,并且该关联涉及到联合主键的注解配置。 首先,一对一关联可以分为两种类型:单向和双向。在单向一对一关联中,只有一个实体知道另一个实体的存在,而另一...
### HibernateAnnotation 技术概述 在Java开发领域中,Hibernate框架是进行对象关系映射(Object-Relational Mapping,简称ORM)的一种非常流行的工具。它能够帮助开发者将面向对象的模型与关系型数据库进行桥接,...
### Hibernate Annotation 中文文档知识点概览 #### 一、创建注解项目 ##### 1.1 系统需求 在创建一个使用 Hibernate 注解的项目之前,需要满足一定的系统环境需求,例如支持 Java 的开发环境、JDK 版本、支持 ...
### Hibernate Annotation 学习知识点详解 #### 一、概述 Hibernate 是一款开源的对象关系映射 (ORM) 巨具,它极大地简化了 Java 应用程序与数据库之间的交互过程。Hibernate 支持多种注解(Annotation),使得...
**Hibernate Annotation 学习笔记** Hibernate 是一个流行的Java ORM(对象关系映射)框架,它允许开发者使用面向对象的方式操作数据库。Annotation 在 Hibernate 中扮演着关键角色,它们为数据库对象提供了元数据...
本文将详细讲解“Hibernate Annotation 中的共享主键一对一双向关联”。 首先,我们需要理解什么是共享主键(Shared Primary Key)。在一对一的关联关系中,如果两个实体共享同一个主键,那么这种关联被称为共享...
《Hibernate Annotation详解》 在Java世界中,Hibernate作为一种流行的ORM(对象关系映射)框架,极大地简化了数据库操作,使得开发者可以使用面向对象的方式处理数据。而Hibernate Annotation是Hibernate的一个...
### Hibernate Annotation 帮助文档知识点总结 #### 1. 创建注解项目 - **系统需求**:在开始创建一个支持 Hibernate 注解的项目之前,需要确保满足以下系统需求: - Java 开发环境(例如 JDK 1.8 或更高版本)。...
《Hibernate Annotation 中文版详解》 Hibernate 是一个广泛使用的开源对象关系映射(ORM)框架,它极大地简化了Java应用程序对数据库的操作。而Hibernate Annotation则是Hibernate框架中的一个重要组成部分,它...
在Java的持久化框架Hibernate中,注解是用于对象关系映射(ORM)的重要工具,它简化了数据库交互的工作。本篇文章将详细讲解如何利用Hibernate的注解实现基于连接表的单向一对多关联。 首先,理解一对多关联:在...
Hibernate Annotation几种关联映射 一对一(One-To-One) 使用@OneToOne注解建立实体Bean之间的一对一关联。一对一关联有三种情况:(1).关联的实体都共享同样的主键,(2).其中一个实体通过外键关联到另一个实体的主键...
根据给定文件的信息,本文将详细介绍Hibernate ORM(Object Relational Mapping)中关于不同类型的关联映射方式,并结合Annotation和XML两种配置方式来进行说明。 ### 一、一对一单向外键关联 在一对一单向外键...
- `@ManyToOne`: 表示多对一关联,通常配合`@JoinColumn`定义外键。 - `@OneToMany`: 表示一对多关联,可以设置`mappedBy`来指定拥有者。 - `@ManyToMany`: 表示多对多关联,需要通过中间表实现,可以使用`@Join...
本篇将深入探讨Hibernate中的一对一单向外键关联,通过注解和XML配置两种方式进行实现。这种关联允许一个实体类与另一个实体类之间存在一对一的关系,并且只在其中一个实体类中维护这种关系。 首先,我们来理解一对...
在Java的持久化框架Hibernate中,一对一双向外键关联是一种常见的关系映射方式,用于表示两个实体类之间一对一的关联关系。在这个场景下,每个实体都有一个引用指向另一个实体,形成双向关联。本篇文章将深入探讨...