hibernate 复习单向一对一的实现

endual

浏览: 3566769 次
性别:
来自: 杭州

最近访客更多访客>>

wrgjwrrjurhj

sindyqiu

kristy_yy

whzresponse

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

Hibernate

hibernate中单向一对一实现有三种方式：主键关联，外键关联，表关联（自己给的名字，下面会详细说的）。

场景设置：

学生和校服。

我记得我初中的时候，校服忘记在操作了，有人捡到了，但是不知道是谁的，就送到体育办公室，

于是我pdpd的跑去自己拿。

我想说的是：只能从学生来找到校服，而不能从校服去找到学生，这就是单向的关系。

上代码：

Student:

package com.iteye.endual.bean1;

public class Student {

	private int id ;
	private String name ;
	private int num ;
	
	private  XiaoFu xf = new XiaoFu() ;
	
	public Student() {
		
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public XiaoFu getXf() {
		return xf;
	}
	public void setXf(XiaoFu xf) {
		this.xf = xf;
	}
	
}

校服类：

package com.iteye.endual.bean1;

public class XiaoFu {

	private int id ;
	private String owername ;
	
	public XiaoFu() {}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getOwername() {
		return owername;
	}

	public void setOwername(String owername) {
		this.owername = owername;
	}
	
	
	
}

hibernate的主配置文件：

<?xml version='1.0' encoding='utf-8'?>

<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost/test</property>
        <property name="connection.username">root</property>
        <property name="connection.password">数据库密码</property>

        <!-- JDBC connection pool (use the built-in) 
        <property name="connection.pool_size">1</property>
        -->
        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Enable Hibernate's automatic session context management 
        <property name="current_session_context_class">thread</property>
        -->
        <!-- Disable the second-level cache 
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
        -->
        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <property name="format_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">create</property>


   <!-- 用谁只能放谁的，他们的名字一样，要冲突的
        <mapping resource="com/iteye/endual/bean1/Student.hbm.xml"/>
        <mapping resource="com/iteye/endual/bean1/XiaoFu.hbm.xml"/>
     -->                                                        
                                                              
        <mapping resource="com/iteye/endual/bean2/Student.hbm.xml"/>
        <mapping resource="com/iteye/endual/bean2/XiaoFu.hbm.xml"/>
 
        <mapping resource="com/iteye/endual/bean3/Student.hbm.xml"/>
        <mapping resource="com/iteye/endual/bean3/XiaoFu.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

sessionFactory 的类，创建这样要花很大大大大大大的资源的哦

package util;

import org.hibernate.*;
import org.hibernate.cfg.*;

public class HibernateUtil {

    private static final SessionFactory sessionFactory;

    static {
        try {
            // Create the SessionFactory from hibernate.cfg.xml
            sessionFactory = new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            // Make sure you log the exception, as it might be swallowed
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

}

以下三种方式的单向一对一的实体已经创建好了，配置文件，sessionFactory的类以及好了，这个是公用的。

---------------------------------------------------------------------

第一种，外键关联，也是我们通常在学习数据库设计的时候用到的。

什么是外键关联：

就是在学生表中，加个外键，这个外键的值就是校服表的主键的值。

我们要查询学生，通过学生的主键查询，查到学生的信息，然后就能查到这个外键的值，根据这个值那么可以到

校服表中去查询校服的信息了。

hibernate是面向对象的，所以在个外键是不需要我们在实体中去设置的，需要在配置文件中进行配置的。

看配置文件：

student

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping >

    <class name="com.iteye.endual.bean2.Student" table="t_stu2">
        <id name="id" column="stu_id"> <!-- 设置主键 -->
            <generator class="native"/>  <!-- 设置数据库主键的增长方式 -->
        </id>
        <property name="name" column="stu_name" />
        
      <!--  <one-to-one name="card" foreign-key="idx" class="endual.bean.Card" >
        </one-to-one>
     -->

        <many-to-one name="xf" class="com.iteye.endual.bean2.XiaoFu" column="fk_id" unique="true" cascade="all"></many-to-one>
    </class>


</hibernate-mapping>

<many-to-one name="xf" class="com.iteye.endual.bean2.XiaoFu" column="fk_id" unique="true" cascade="all">

一对一的单向关系中，就是多对一的特殊情况，所以用到了many to one 的标签。这个标签有个属性是

unique="true"，表示这个是一对一的关系。（为什么多开发一套标签来支持一对一呢，弄的这么麻烦要拿别人的修改下。）

cascade="all" 这是表示级联的意思，就是主如此更新的话，那么连接它的也更新，删除也一样，插入也一样。

column="fk_id" 这个是设置了外键的名字，会自动插入到student的表中的去，这个就是校服表的外键，这个值就是校服表主键的值。

校服表的配置文件：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping >

    <class name="com.iteye.endual.bean2.XiaoFu" table="t_xiaofu2">
        <id name="id" column="xiaofu_id"> <!-- 设置主键 -->
            <generator class="native"/>  <!-- 设置数据库主键的增长方式 -->
        </id>
        <property name="owername"  column="stu_name" />
       
    </class>


</hibernate-mapping>

junit测试：

package endual.bean2;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import com.iteye.endual.bean2.Student;
import com.iteye.endual.bean2.XiaoFu;

import util.HibernateUtil;
import junit.framework.TestCase;

public class TestHibernate extends TestCase {

	/**
	 * 对个实体bean的存储
	 */
	public void test1 () {
		
		SessionFactory sf = HibernateUtil.getSessionFactory() ;
		Session session = sf.openSession() ;
		
		XiaoFu xf = new XiaoFu() ;
		//xf.setId(id)
		xf.setOwername("chenwei");
		
		Student st = new Student() ;
		st.setName("chenwei");
		st.setNum(123456) ;
		st.setXf(xf) ;
		session.save(st) ;
	
		Transaction tr = session.beginTransaction() ;
		tr.commit() ;
		
		//System.out.println(pp.getCard().getIdnum());
		
	}
	
}

测试结果：

生成了两张表：（见插入，其他学生表中多了一个外键的字段）

1. session.save(st) ; //保存st，也保存了xf,他们的级联是all. 成功

2. session.save(xf) ;

session.save(st) ; //成功

3. session.save(st) ; //成功

session.save(xf) ;

4.session.save(xf) ; //只插入了校服

增加查找和删除修改和级联的设置有很大的关系

========================================================

第二种方式就是主键关联，我们知道主键的值是唯一的，那么我们将两个表的主键的值是一样的，就可以了嘛。

我们用学生表的主键的值用的是校服表的主键。

这样我们查询学生的时候，就能查到校服的主键，而根据校服的主键我们就能查到校服的信息了。

上代码：

学生表的主键的生成的不能是递增了，我们要用到forein的策略。两张表的字段没有多出来，也只生成两张表。

学生的配置文件：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping >

    <class name="com.iteye.endual.bean3.Student" table="t_stu3">
        <id name="id" column="stu_id"> <!-- 设置主键 -->
            <generator class="foreign">  <!-- 主键生成策略为foreign,根据关联类生成主键来产生主键的值 -->
              <param name="property">xf</param>
            </generator>
        </id>
        <property name="name" column="stu_name" />
        
      <!--  <one-to-one name="card" foreign-key="idx" class="endual.bean.Card" >
        
        </one-to-one>-->
        
        <one-to-one name="xf" cascade="all"  constrained="true"></one-to-one>

    </class>


</hibernate-mapping>

<id name="id" column="stu_id"> <!-- 设置主键 -->
            <generator class="foreign">  <!-- 主键生成策略为foreign,根据关联类生成主键来产生主键的值 -->
              <param name="property">xf</param>
            </generator>
        </id>

这个配置中就是告诉框架，学生表的主键的值要用的是外面来的，这个外面就是xf这个属性关联的那个表

测试代码：

package endual.bean3;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import com.iteye.endual.bean3.Student;
import com.iteye.endual.bean3.XiaoFu;
import util.HibernateUtil;
import junit.framework.TestCase;

public class TestHibernate extends TestCase {

	/**
	 * 对个实体bean的存储
	 */
	public void test1 () {
		
		SessionFactory sf = HibernateUtil.getSessionFactory() ;
		Session session = sf.openSession() ;
		
		XiaoFu xf = new XiaoFu() ;
		xf.setOwername("chenwei");
		//xf.setId(4) ;
		Student st = new Student() ;
		st.setName("chenwei");
		st.setNum(123456) ;
		st.setId(7);
		st.setXf(xf) ;
		
		session.save(st) ;
		Transaction tr = session.beginTransaction() ;
		tr.commit() ;
		
		
		
	}
	
}

测试结果：生成了两种张表（见插图）

测试：

1. session.save(st) ; //成功，两个表都插入了

2. session.save(xf) ; //很显然值插入了一个校服表

3. session.save(xf) ;

session.save(st) ; //两个表都插入了，而且值插入一条的

4. session.save(st) ;

session.save(xf) ; //两个表都插入了，而且只插入了一条的

居然的各自负责测试举例要看情况了

---------------------------------------------------------------------------------------

下面来到了我们的第三中方法，那就是再创建一张表，通过这个来创建单向的连接

我们这表是框架自动会建立的，我们在学生配置文件中设置改表的字段已经名字。

表中放的学生表的主键和校服表的主键，这样我们查找学生的时候，能查到主键，

查到主键，我们在这种表中能查找校服表的主键，这样就能通过校服表的主键，查到校服的信息了。

思路是这样的。

配置文件是：

student的配置文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping >

    <class name="com.iteye.endual.bean1.Student" table="t_stu1">
        <id name="id" column="stu_id"> <!-- 设置主键 -->
            <generator class="native"/>  <!-- 设置数据库主键的增长方式 -->
        </id>
        <property name="name" column="stu_name" />
        
      <!--  <one-to-one name="card" foreign-key="idx" class="endual.bean.Card" >
        
        </one-to-one>-->
        
        <join table="join_stu_xf1">
       
        <key column="xf_id"></key>
        <!-- 一对一 是 多对一的 一个特殊情况 -->
        <many-to-one name="xf" class="com.iteye.endual.bean1.XiaoFu"  unique="true" cascade="all"></many-to-one>
        </join>

    </class>


</hibernate-mapping>

 <join table="join_stu_xf1"> 校服表的名字，字段是自动生成，也可以自己设置的

测试类：

package endual.bean1;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import com.iteye.endual.bean1.Student;
import com.iteye.endual.bean1.XiaoFu;
import util.HibernateUtil;
import junit.framework.TestCase;

public class TestHibernate extends TestCase {

	/**
	 * 对个实体bean的存储
	 */
	public void test1 () {
		
		SessionFactory sf = HibernateUtil.getSessionFactory() ;
		Session session = sf.openSession() ;
		
		XiaoFu xf = new XiaoFu() ;
		xf.setOwername("chenwei");
		
		Student st = new Student() ;
		st.setName("chenwei");
		st.setNum(123456) ;
		
		st.setXf(xf) ;
		session.save(st) ;
		Transaction tr = session.beginTransaction() ;
		tr.commit() ;
		session.close() ;
		
	}
	
	

	public void test3 () {
		
		SessionFactory sf = HibernateUtil.getSessionFactory() ;
		Session session = sf.openSession() ;
		
        String hql = "from Student as stu where stu.id=?" ;
        
        Query query = session.createQuery(hql) ;
        query.setInteger(0, 1) ;
        
        List<Student> lists = query.list() ;
        Student stu = lists.get(0) ;
        
        System.out.println(stu.getName());
        //用到了才会去查询的
        System.out.println(stu.getXf().getOwername());
	//	Transaction tr = session.beginTransaction() ;
		
		//tr.commit() ;
		
		//System.out.println(pp.getCard().getIdnum());
		
	}
	
}

测试结果，生成了三张表：

1.session.save(stu); 成功插入三个表都有数据

2.session.save(xf) ; //失败

3. session.save(xf) ;

session.save(st) ; //成功

4. session.save(st) ;

session.save(xf) ; //成功

------------------------

以上是三个方法的代码？

有一个点我搞不清楚的是，单向连接啊，这箭头是指向的是学生呢还是校服呢？呵呵。