建表语句:

DROP TABLE IF EXISTS `t_company`;
CREATE TABLE `t_company` (
`companyId` int(10) unsigned NOT NULL AUTO_INCREMENT,
`companyName` varchar(30) NOT NULL,
PRIMARY KEY (`companyId`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=gb2312; INSERT INTO `t_company` VALUES ('', 'Sun');
INSERT INTO `t_company` VALUES ('', 'Apache'); DROP TABLE IF EXISTS `t_employee`;
CREATE TABLE `t_employee` (
`employeeId` int(10) unsigned NOT NULL AUTO_INCREMENT,
`employeeName` varchar(15) NOT NULL,
`cid` int(10) unsigned NOT NULL,
PRIMARY KEY (`employeeId`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=gb2312; INSERT INTO `t_employee` VALUES ('', 'Tom', '');
INSERT INTO `t_employee` VALUES ('', 'Summ', '');
INSERT INTO `t_employee` VALUES ('', 'Cat', '');
INSERT INTO `t_employee` VALUES ('', 'Vinylon', '');
INSERT INTO `t_employee` VALUES ('', 'Dog', '');

Employee.java

package com.fancy.po;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table; @Entity
@Table(name = "t_employee")
public class Employee { private Integer employeeId;
private String employeeName;
private Company company; @Id
@GeneratedValue(strategy = GenerationType.AUTO)
public Integer getEmployeeId() {
return employeeId;
}
/**
* @ManyToOne:多对一,cascade:级联,请参考上一篇
* fetch = FetchType.LAZY,延迟加载策略,如果不想延迟加载可以用FetchType.EAGER
*/
@ManyToOne(cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH},fetch = FetchType.LAZY)
@JoinColumn(name = "cid")
public Company getCompany() {
return company;
}
public String getEmployeeName() {
return employeeName;
}
public void setEmployeeId(Integer employeeId) {
this.employeeId = employeeId;
}
public void setEmployeeName(String employeeName) {
this.employeeName = employeeName;
}
public void setCompany(Company company) {
this.company = company;
}
}

Company.java

package com.fancy.po;

import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table; @Entity
@Table(name = "t_company")
public class Company { private Integer companyId;
private String companyName;
private Set<Employee> employees; @Id
@GeneratedValue(strategy = GenerationType.AUTO)
public Integer getCompanyId() {
return companyId;
}
/**
* @OneToMany 与 OneToOne相似的也用mappedBy,参考了Employee
*/
@OneToMany(mappedBy = "company")
public Set<Employee> getEmployees() {
return employees;
}
public String getCompanyName() {
return companyName;
}
public void setCompanyId(Integer companyId) {
this.companyId = companyId;
}
public void setCompanyName(String companyName) {
this.companyName = companyName;
}
public void setEmployees(Set<Employee> employees) {
this.employees = employees;
}
}

Test.java

package com.fancy.test;

import java.util.Iterator;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
import com.fancy.po.Company;
import com.fancy.po.Employee; public class Test { public static void main(String[] args) {
//读取hibernate配置,默认读取classpath下的hibernate.cfg.xml
Configuration conf = new AnnotationConfiguration();
//构建session工厂
SessionFactory sessionFactory = conf.configure().buildSessionFactory();
//打开session
Session session = sessionFactory.openSession();
//开始事务
session.beginTransaction();
// * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//test1(session); //测试 1
//test2(session); //测试 2
test3(session); //测试 3
// * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//提交事务
session.getTransaction().commit();
//关闭session工厂
sessionFactory.close();
//关闭session
session.close();
}
public static void test1(Session session){
Company company = (Company)session.get(Company.class, 1); //发出Company的select语句
Set<Employee> employee = company.getEmployees(); //不发出Employee的select语句
System.out.println("Company :" + company.getCompanyName());
System.out.println("CountSum:" + employee.size()); //Employee初次被使用,发出select语句
Iterator<Employee> it = employee.iterator(); //Employee不再发出select语句
while(it.hasNext()){
System.out.println("EmployeeName:" + it.next().getEmployeeName());
}
}
public static void test2(Session session){
Company company = (Company)session.get(Company.class, 2);//发出Company的select语句
Set<Employee> employee = company.getEmployees(); //不发出Employee的select语句
Iterator<Employee> it = employee.iterator(); //发出Employee的select语句
Employee e = null;
Boolean first = false;
while(it.hasNext()){
e = it.next();
if(!first){
System.out.println("EmployeeId:[" + e.getEmployeeId() + "] information will be change");
e.setEmployeeName("fancy"); //更改雇员名字
// session.save(e); //发出Employee的update语句,不发出Company的update语句
session.save(company); //发出Employee的update语句,不发出Company的update语句
first = true;
}
System.out.println("EmployeeName:" + e.getEmployeeName());
}
}
public static void test3(Session session){
Employee employee = (Employee)session.get(Employee.class, 1);//发出Employee的select语句
Company company = (Company)session.get(Company.class, 1);//发出Company的select语句
company.setCompanyName("Oracle"); //更改公司名字
// session.save(company);//发出Company的update语句,不发出Employee的update语句
session.save(employee);//发出Company的update语句,不发出Employee的update语句
}
}

原文地址:hibernate one-to-many many-to-one 双向注解参考:

hibernate annotation 之 注解声明

hibernate annotation 之 主键生成策略

hibernate annotation 之 一对一 单/双 向外键关联

hibernate annotation 之 一对多单向外键关联

hibernate annotation 之 多对一单向外键关联

hibernate annotation 之 一对多、多对一双向外键关联

hibernate one-to-many many-to-one 双向注解的更多相关文章

  1. Hibernate 注解(Annotations 四)多对多双向注解

    注解(Annotation),也叫元数据.一种代码级别的说明.它是JDK1.5及以后版本引入的一个特性,与类.接口.枚举是在同一个层次.它可以声明在包.类.字段.方法.局部变量.方法参数等的前面,用来 ...

  2. Hibernate 注解 (Annotations 三)多对一双向注解

    注解(Annotation),也叫元数据.一种代码级别的说明.它是JDK1.5及以后版本引入的一个特性,与类.接口.枚举是在同一个层次.它可以声明在包.类.字段.方法.局部变量.方法参数等的前面,用来 ...

  3. 【Hibernate步步为营】--(一对多映射)之双向关联

    上篇文章讨论了单向关联的一对多映射,在一的一端维护双向的关系这样的做法尽管能实现可是存在非常多缺陷,首先生成非常多多余的SQL语句,由于多的一端不维护关系,仅仅有一的一端维护,在进行操作时一的一端会发 ...

  4. hibernate 2 一对多、多对一 双向映射

    多对一或一对多中,在多的一方维护关系效率高 一:java实体类 1.Classes.java package cn.gs.ly.school.entity; import java.util.Set; ...

  5. hibernate之实体@onetomany和@manytoone双向注解(转)

    下面是User类: @onetomany @Entity @Table(name="user") public class User implements Serializable ...

  6. Hibernate(12)_基于主键的双向1对1

    一.基于主键的双向1对1 1.介绍: 基于主键的映射策略:指一端的主键生成器使用 foreign 策略,表明根据"对方"的主键来生成自己的主键,自己并不能独立生成主键. <p ...

  7. Hibernate(11)_基于外键的双向1对1

    一.基于外键的双向1对1 对于基于外键的1-1关联,其外键可以存放在任意一边,在需要存放外键一端,增加many-to-one元素.为many-to-one元素增加unique="true&q ...

  8. Hibernate 注解(Annotations 二)一对一双向注解

    注解(Annotation),也叫元数据.一种代码级别的说明.它是JDK1.5及以后版本引入的一个特性,与类.接口.枚举是在同一个层次.它可以声明在包.类.字段.方法.局部变量.方法参数等的前面,用来 ...

  9. Hibernate入门(2)- 不用配置用注解

    在上一个例子里面,我用的配置文件的方式,这次改成注解. pom.xml 增加了hibernate-commons-annotations和hibernate-annotations <proje ...

随机推荐

  1. CentOS6.4系统启动失败故障排查

    转:http://www.centoscn.com/CentosBug/osbug/2014/1028/4011.html 操作系统启动失败如下图报错: 故障现象: 从图中可以看到,操作系统启动的过程 ...

  2. Mysql 索引 转载

    转自 :http://blog.csdn.net/wud_jiyanhui/article/details/7403375 什么是索引 索引时一种特殊的文件,他们包涵着对数据表里所有记录的引用指针. ...

  3. Readonly和Disabled的区别

    readonly 把输入的字段设为只读,但是没有禁用 readonly=” readonly”; disabled 禁用一个input元素. disabled="disabled" ...

  4. ContentProvider 使用示例(转载)

    ContentProvider 使用示例(转载) 当数据需要在应用程序间共享时,我们就可以利用ContentProvider为数据定义一个URI.之后其他应用程序对数据进行查询或者修改时,只需要从当前 ...

  5. get utc+8 当时时间

    /// <summary> /// get utc+8 当时时间 /// </summary> /// <returns></returns> publ ...

  6. 回到顶部缓动效果代码 --- tween动画函数库

    function animateGoTop() { var top = $(document).scrollTop(); var end = 0; var dur = 500; var t = 0; ...

  7. (WPF) 再议binding:点击User Control时,User Control变换颜色或做其他的处理。

    Binding 是前台UI(显示层)和后台代码(数据层)的桥梁.理论上当后台的数据变动时,显示的数据或样式应该随之而变.这些是动态的. 对于Binding的设置可以在前台Xaml,也可以在后台Code ...

  8. C#学习笔记二: C#类型详解

    前言 这次分享的主要内容有五个, 分别是值类型和引用类型, 装箱与拆箱,常量与变量,运算符重载,static字段和static构造函数. 后期的分享会针对于C#2.0 3.0 4.0 等新特性进行. ...

  9. ASP.NET 中的 authentication(验证)与authorization(授权)

    这两个东西很绕口,也绕脑袋. 一般来说,了解authentication(验证)的用法即可,用于自定义的用户验证. authorization(授权)主要通过计算机信息来控制. “*”:所有用户: “ ...

  10. IGS_学习笔记03_Integrated SOA Gateway设定配置(案例)

    20150506 Created By BaoXinjian