hibernate双向一对一

package com.bjsxt.hibernate.oneToOne;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;

import com.bjsxt.hibernate.oneToOne.PersonInfo;
@Entity
public class Person {
    private int id;
    private String name;
    private String password;
    private PersonInfo personInfo;
    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }
    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", password=" + password
                + ", PersonInfo=" + personInfo + "]";
    }
    public Person(int id, String name, String password,
            com.bjsxt.hibernate.oneToOne.PersonInfo personInfo) {
        super();
        this.id = id;
        this.name = name;
        this.password = password;
        this.personInfo = personInfo;
    }
    public Person( String name, String password,
            com.bjsxt.hibernate.oneToOne.PersonInfo personInfo) {
        super();
        this.name = name;
        this.password = password;
        this.personInfo = personInfo;
    }
    public void setId(int id) {
        this.id = id;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    
    public String getName() {
        return name;
    }
    @OneToOne(cascade=CascadeType.ALL,fetch=FetchType.EAGER)
    @JoinColumn(name="personInfo")
    public PersonInfo getPersonInfo() {
        return personInfo;
    }
    public void setPersonInfo(PersonInfo personInfo) {
        this.personInfo = personInfo;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}
package com.bjsxt.hibernate.oneToOne;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class PersonInfo {
    private int id;
    private String name;
    private int age;
    private Person person;
    @OneToOne(mappedBy="personInfo",cascade=CascadeType.ALL)
    public Person getPerson() {
        return person;
    }
    public void setPerson(Person person) {
        this.person = person;
    }
    public PersonInfo( String name, int age) {
        super();
        
        this.name = name;
        this.age = age;
    }
    public PersonInfo(int id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public PersonInfo() {
        super();
        // TODO Auto-generated constructor stub
    }
    public int getAge() {
        return age;
    }
    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "PersonInfo [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
}
package com.bjsxt.hibernate;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.BeforeClass;

import com.bjsxt.hibernate.oneToOne.Person;
import com.bjsxt.hibernate.oneToOne.PersonInfo;

public class OneToOneTest {

private static SessionFactory sessionFactory;
    
    @BeforeClass
    public static void beforeClass() {
        new SchemaExport(new AnnotationConfiguration().configure()).create(false, true);
        sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
    }
    public static void main(String[] args) {
        //AddPerson();
        //getPerson();
        //delPerson();
        updatePerson();
        
    }

    
    public static  void getPerson(){
        sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory();
        Session session=sessionFactory.getCurrentSession();
        session.beginTransaction();
        Person person=(Person) session.get(Person.class, 1);
        System.out.println(person.toString());
        session.getTransaction().commit();
    }
    public static  void delPerson(){
        sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory();
        Session session=sessionFactory.getCurrentSession();
        session.beginTransaction();
        Person person=(Person) session.get(Person.class, 1);
        session.delete(person);
        System.out.println(person.toString());
        session.getTransaction().commit();
    }
    public static  void updatePerson(){
        sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory();
        Session session=sessionFactory.getCurrentSession();
        session.beginTransaction();
        Person person=(Person) session.get(Person.class, 2);
        //先get数据,不写session.update(person)数据库也更新了记录
        person.setName("王五"); 
        //级联的数据直接修改,也不用update,hibernate自动完成修改
        PersonInfo personInfo=person.getPersonInfo();
        personInfo.setName("王五");
        System.out.println(person.toString());
        session.getTransaction().commit();
    }
    public static  void AddPerson(){
        sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory();
        Session session=sessionFactory.getCurrentSession();
        session.beginTransaction();
        PersonInfo personInfo=new PersonInfo( "张三", 23);
        Person person=new Person("张三", "2", personInfo);
        personInfo.setPerson(person);
        //session.save(personInfo);
        session.save(person);
        session.getTransaction().commit();
    }
    public static  void delPersonByPersonInfo(){
                sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory();
                Session session=sessionFactory.getCurrentSession();
                session.beginTransaction();
                Person person=(Person) session.get(Person.class, 2);
                session.delete(person.getPersonInfo());
                System.out.println(person.toString());
                session.getTransaction().commit();
        }
        public static  void AddPersonByPersonInfo(){
                sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory();
                Session session=sessionFactory.getCurrentSession();
                session.beginTransaction();
                PersonInfo personInfo=new PersonInfo( "张三", 23);
                Person person=new Person("张三", "2", personInfo);
                personInfo.setPerson(person);
                session.save(personInfo);
                //session.save(person);
                session.getTransaction().commit();
        }

}
时间: 2024-10-18 21:45:47

hibernate双向一对一的相关文章

Hibernate关系映射(二) 基于外键的双向一对一

基于外键的双向一对一关联映射 需要在一端添加<one-to-one>标签,用property-ref来指定反向属性引用. 还是通过刚才用户和地址来演示双向一对一关联. 代码演示 一.实体类 Account.cs,需要添加被控端的引用 package com.lxit.entity; import java.io.Serializable; public class Account implements Serializable{ public Account(){ } private int

【SSH进阶之路】Hibernate映射——一对一双向关联映射(六)

上篇博文[SSH进阶之路]Hibernate映射--一对一单向关联映射(五),我们介绍了一对一的单向关联映射,单向是指只能从人(Person)这端加载身份证端(IdCard),但是反过来,不能从身份证端加载人得信息.如图所示: 关键原因在于对象模型具有方向性: 单向:一端只能加载另一端,不能反过来. 双向:两端都可以加载另一端. 问题来了:如何我们想从身份证端(IdCard)加载人(Person),怎么办呢? 下面我们开始介绍一对一的双向关联映射. 映射原理 双向关联映射与单向关联映射的原理是一

java之hibernate之基于外键的双向一对一关联映射

这篇讲解 基于外键的双向一对一关联映射 1.考察如下信息,人和身份证之间是一个一对一的关系.表的设计 2.类结构 Person.java public class Person implements Serializable{ private int id; private String name; private IdCard idCard; public Person() { } public Person(String name) { super(); this.name = name;

hibernate 双向 OneToOne fetchType lazy 问题

hibernate 双向 OneToOne fetchType lazy 问题 分类: hibernate2013-06-26 14:54 932人阅读 评论(2) 收藏 举报 转载于:http://mshijie.javaeye.com/admin/blogs/440057 今天使用JPA(Hibernate)实现一个一对一关联的时候,发现无法使用延迟加载.Person关联一个Picture.在读取Person的时候,显示的记载了对于的Picture.读取10个Person发生了11次数据库查

【Hibernate】——一对一关联映射

两个对象之间如果是一对一的关系,如Person-IdCard.在Hibernate中有两种策略可以实现一对一的关联映射: 主键关联:即让两个对象具有相同的主键值,以表明它们之间的一一对应的关系:数据库表不会有额外的字段来维护它们之间的关系,仅通过表得主键来关联. 唯一外键关联:外键关联,本来是用于多对一的配置,但是如果加上唯一的限制之后,也可以用来表示一对一关联关系: 而每种策略又分为两种方向的对应关系,即单向一对一关系和双向一对一关系.分类的原因一般是由需求决定的,单双向是站在不同的角度去看人

hibernate 双向n-n

域模型: 关系数据模型 双向 n-n 关联需要两端都使用集合属性 双向n-n关联必须使用连接表 集合属性应增加 key 子元素用以映射外键列, 集合元素里还应增加many-to-many子元素关联实体类 在双向 n-n 关联的两边都需指定连接表的表名及外键列的列名. 两个集合元素 set 的table 元素的值必须指定,而且必须相同.set元素的两个子元素:key 和 many-to-many 都必须指定 column 属性,其中,key 和 many-to-many 分别指定本持久化类和关联类

9.hibernate的一对一映射

一.hibernate的一对一按照外键映射 1.创建如下sql脚本: 1 --员工账号表 2 create table USERS1 3 ( 4 USERID NUMBER(6) not null, 5 USERNAME VARCHAR2(20), 6 USERPASS VARCHAR2(20) 7 ) 8 ; 9 10 11 12 --档案表 13 create table RESUME1 14 ( 15 RESID NUMBER(6) not null, 16 RESUSERID NUMBE

hibernate 双向 1-n(详细分析)

双向 1-n 与 双向 n-1 是完全相同的两种情形 双向 1-n 需要在 1 的一端可以访问 n 的一端, 反之依然. 域模型:从 Order 到 Customer 的多对一双向关联需要在Order 类中定义一个 Customer 属性, 而在 Customer 类中需定义存放 Order 对象的集合属性 关系数据模型:ORDERS 表中的 CUSTOMER_ID 参照 CUSTOMER 表的主键 注意: 当 Session 从数据库中加载 Java 集合时, 创建的是 Hibernate 内

Hibernate中一对一关联映射/组件映射

Hibernate映射:一对一关联 1.按照外键映射 2.按照主键映射 组件映射 下面以员工账号表和员工档案表(员工账号和档案表之间是一对一的关系)为例,介绍这两种映射关系,并使用这两种 映射方式分别完成以下持久化操作 (1)保存员工档案的同时分配给员工一个账号 (2)加载员工档案的同时加载账号信息 一:按照外键映射