`

Hibernate关联映射-one to one单向外键关联

 
阅读更多

Hibernate的关联关系很多,也非常的复杂.

常见的有 one to one ,one to many ,many to one, many to many等等.

 

学习这些,关联关系.这个基本上占据了Hibernate学习的七成时间。熟悉这些映射模型,需要大量的实践才能掌握。

 

 

以下,就先拿最简单关联关系讲起..one to one 关联的实例, 比如1个人只有一个居住地址, 1个人只有一张唯一的身份证。

这里就拿,人和地址作为1对1的关联关系。

 

做这些实例采用 有如下开发工具:

eclipse 3.3

mysql 5.4 数据库.

tomcat 6.0

 

本实例,将通过Mapping 映射文件自动生成数据库表;

建立两个Pojo类,一个Person,一个Address类.

 

具体代码如下:

package pack.java.model;

import java.io.Serializable;
/**
 * 一个人只有一个地址;
 * 1对1,单向关联
 * @author Administrator
 *
 */
public class Person implements Serializable{
	
	private static final long serialVersionUID = -6313867775683964530L;
	private Integer id;
	private String name;
	private Integer age;
	private Address address;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
	
}

 

 

Address类代码: 应为是单向关联,则address类不需要关联到person类.

package pack.java.model;
import java.io.Serializable;
/**
 * 
 * 一对一的关系;
 * @author Administrator
 *
 */
public class Address implements Serializable{
	
	private static final long serialVersionUID = 3635140598485086087L;
	private Integer addressID;
	private String addressDetail;
	
	public Integer getAddressID() {
		return addressID;
	}
	public void setAddressID(Integer addressID) {
		this.addressID = addressID;
	}
	public String getAddressDetail() {
		return addressDetail;
	}
	public void setAddressDetail(String addressDetail) {
		this.addressDetail = addressDetail;
	}
	
	
}

 

 

接下来,手动建立Person.hbm.xml文件,或者也可以通过myEclipse工具直接生成.

 

Person.hbm.xml 代码如下:

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

<hibernate-mapping>
	<class name="pack.java.model.Person" table="ZHT_PERSON">
		<id name="id" type="java.lang.Integer" column="ID">
			<generator class="identity"></generator>
		</id>
		
		<property name="name" type="java.lang.String"></property>
		<property name="age" type="java.lang.Integer"></property>
		
		<!-- 
			在Person里面的many-to-one里面的unique='true'是代表,唯一的,也就是一对一的关系.
			column 是address 对象里面的属性名称、
			name   是person 对象里面的对象名称。
		 -->
		<many-to-one 
			name="address" 
			class="pack.java.model.Address" 
			column="addressID"
			unique="true" 
			cascade="save-update,persist"
			>
		</many-to-one>
	</class>
</hibernate-mapping>

 

建立Address.hbm.xml文件:

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

<hibernate-mapping>
	<class name="pack.java.model.Address" table="ZHT_ADDRESS">
		<id name="addressID" column="addressID" type="java.lang.Integer">
			<generator class="identity"></generator>
		</id>
		
		<!-- 属性映射 -->
		<property name="addressDetail" type="java.lang.String"></property>
	</class>
</hibernate-mapping>

 

 

建立好之后,然后建立一个Hibernate的配置文件,添加连接数据库的一些基本信息.以及Mapping文件的映射地址.

Hibernate.cfg.xml文件:

<?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>
		<property name="connection.username">root</property>
		<property name="connection.password">mysql</property>
		<property name="connection.url">jdbc:mysql://localhost/test</property>
		<property name="connection.dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<!--自动创建sql脚本--> 
		<property name="hbm2ddl.auto">create</property>
		<property name="connection.show_sql">true</property>
		<property name="connection.format_sql">true</property>
		
		<!-- Mapping映射文档; -->
		<mapping resource="pack/java/model/Address_one_to_one.hbm.xml"/>
		<mapping resource="pack/java/model/Person_one_to_one.hbm.xml"/>
	</session-factory>
</hibernate-configuration>          

 

最后,我们在建立一个HibernateSessionFactory文件,这个文件可以自动生成..

具体代码如下:

package pack.java.hibernate;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;

/**
 * Configures and provides access to Hibernate sessions, tied to the
 * current thread of execution.  Follows the Thread Local Session
 * pattern, see {@link http://hibernate.org/42.html }.
 */
public class HibernateSessionFactory {

    /** 
     * Location of hibernate.cfg.xml file.
     * Location should be on the classpath as Hibernate uses  
     * #resourceAsStream style lookup for its configuration file. 
     * The default classpath location of the hibernate config file is 
     * in the default package. Use #setConfigFile() to update 
     * the location of the configuration file for the current session.   
     */
    private static String CONFIG_FILE_LOCATION = "pack/java/hibernate/hibernate.cfg.xml";
    private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
    private static Configuration configuration = new Configuration();    
    private static org.hibernate.SessionFactory sessionFactory;
    private static String configFile = CONFIG_FILE_LOCATION;

	static {
    	try {
			configuration.configure(configFile);
			sessionFactory = configuration.buildSessionFactory();
		} catch (Exception e) {
			System.err
					.println("%%%% Error Creating SessionFactory %%%%");
			e.printStackTrace();
		}
    }
    private HibernateSessionFactory() {
    }
	
	/**
     * Returns the ThreadLocal Session instance.  Lazy initialize
     * the <code>SessionFactory</code> if needed.
     *
     *  @return Session
     *  @throws HibernateException
     */
    public static Session getSession() throws HibernateException {
        Session session = (Session) threadLocal.get();

		if (session == null || !session.isOpen()) {
			if (sessionFactory == null) {
				rebuildSessionFactory();
			}
			session = (sessionFactory != null) ? sessionFactory.openSession()
					: null;
			threadLocal.set(session);
		}

        return session;
    }

	/**
     *  Rebuild hibernate session factory
     *
     */
	public static void rebuildSessionFactory() {
		try {
			configuration.configure(configFile);
			sessionFactory = configuration.buildSessionFactory();
		} catch (Exception e) {
			System.err
					.println("%%%% Error Creating SessionFactory %%%%");
			e.printStackTrace();
		}
	}

	/**
     *  Close the single hibernate session instance.
     *
     *  @throws HibernateException
     */
    public static void closeSession() throws HibernateException {
        Session session = (Session) threadLocal.get();
        threadLocal.set(null);

        if (session != null) {
            session.close();
        }
    }

	/**
     *  return session factory
     *
     */
	public static org.hibernate.SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	/**
     *  return session factory
     *
     *	session factory will be rebuilded in the next call
     */
	public static void setConfigFile(String configFile) {
		HibernateSessionFactory.configFile = configFile;
		sessionFactory = null;
	}

	/**
     *  return hibernate configuration
     *
     */
	public static Configuration getConfiguration() {
		return configuration;
	}

}

 

 

最后,我们可以在新建一个Test类来测试,这些Hibernate映射关系了.

package pack.java.test;

import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import pack.java.hibernate.HibernateSessionFactory;
import pack.java.model.Address;
import pack.java.model.Person;

/**
 * 测试;
 * @author Administrator
 *
 */
public class HibernateDaoDemo {
	/**
	 * 测试主方法;
	 * @param args
	 */
	public static void main(String[] args) {
		Session session = getSession();
		HibernateDaoDemo hibernateDaoDemo = new HibernateDaoDemo();
		//保存person对象;
		hibernateDaoDemo.savePerson(session);
		
		//查询;
		List<Person> personList = hibernateDaoDemo.queryPerson(session);
		for(Person person:personList){
			System.out.println(person.getId()+","+person.getName()+","+person.getAge()+","+person.getAddress());
		}
	}
	
	/**
	 * 创建session;
	 * @return
	 */
	private static Session getSession(){
		return HibernateSessionFactory.getSession();
	}
	
	/**
	 * 保存Person;
	 * @param session
	 */
	private void savePerson(Session session){
		Person person = new Person();
		person.setAge(23);
		person.setName("周海涛");
		Address address = new Address();
		address.setAddressDetail("中国湖南株洲市");
		person.setAddress(address);
		session.beginTransaction().begin();
		
		//保存;
		session.save(person);
		session.beginTransaction().commit();
		System.out.println("保存成功!");
	}
	
	/**
	 * 查询Person;
	 * @param session
	 * @return
	 */
	private List<Person> queryPerson(Session session){
		Query query = session.createQuery("from Person p where p.name=:name");
		query.setParameter("name", "ZhouHaiTao");
		List<Person> list = query.list();
		return list;
	}
	
}

 

 

 

 

分享到:
评论

相关推荐

    hibernate one-to-one 一对一唯一外键关联映射_单向 and 双向

    在Hibernate中,一对一唯一外键关联映射可以通过 `&lt;many-to-one&gt;` 标签来配置。例如,以下是Person实体与IdCard实体的一对一唯一外键关联映射配置: ```xml &lt;many-to-one name="idCard" column="card_id...

    Hibernate一对一唯一外键关联映射(单向关联)

    在Java的持久化框架Hibernate中,一对一(One-to-One)关联映射是常见的关系数据库模型在对象模型中的体现。这种关联通常用于表示两个实体之间非常特殊的联系,比如一个人只有一个身份证,或者一个公司只有一个总部...

    hibernate 关联映射(二) one to one(单向)

    本篇文章将深入探讨Hibernate中的关联映射,特别是One-to-One(一对一)关联,这是一种表示两个实体之间一对一关系的映射方式。我们将通过源码分析和实际例子来理解其工作原理。 ### 一、One-to-One关联概述 在...

    hibernate 全面学习->hibernate 关联映射学习

    接下来是“多对一”(Many-to-One)映射,与一对多相反,一个子实体可以关联到多个父实体。例如,多个订单可以属于同一个客户。`hibernate_many2one`的案例可能展示了如何在子类中使用`@ManyToOne`注解来指定与父类...

    Hibernate关联映射

    在 Hibernate 映射中,需要使用 `one-to-one` 元素,并设置 `constrained="true"`,表明该类的主键由关联类生成。 3. Hibernate 一对一连接表单向关联: 这种关联方式是通过额外的连接表来实现一对一关系的。连接...

    hibernate的关联映射

    关联映射主要包括四种类型:一对一(One-to-One)、一对多(One-to-Many)、多对一(Many-to-One)和多对多(Many-to-Many)。下面我们将逐一探讨这些关联映射的配置方法。 1. **一对一关联映射** - **主键关联**...

    hibernate一对一唯一外键关联映射(单项关联)

    在Java的持久化框架Hibernate中,一对一(One-to-One)关联映射是常见的关系映射方式之一,尤其在处理数据库中的唯一外键关联时。这种映射方式允许在一个实体类中引用另一个实体类的唯一实例,形成一对一的关系。在...

    hibernate中基于外键的one2one

    总之,Hibernate中的基于外键的One-to-One映射是一种常用的数据关联技术,理解和熟练应用这一概念对于Java开发者来说至关重要。通过细致的配置和合理的实体设计,我们可以构建出高效、稳定的数据库应用程序。

    Hibernate教程04_关系映射之一对一单向外键关联

    本教程重点讲解了一对一(One-to-One)单向外键关联的实现方法。在数据库设计中,一对一关系意味着两个实体之间存在唯一对应的关系,比如一个人只有一个身份证,或者一个房间只有一扇门。在Hibernate中,这种关系...

    hibernate实体关联关系映射

    2. **一对多关联**(One-to-Many / Many-to-One) - 外键单向关联 - 连接表单向关联 - 外键双向关联 - 连接表双向关联 3. **多对多关联**(Many-to-Many) - 单向关联 - 双向关联 每种关联类型都有其特定的...

    Hibernate_实体关联关系映射--学习总结

    实体关联关系映射涉及一对一、一对多、多对多等多种形式,而这些映射方式又可以分为单向和双向,依据使用的是主键还是外键,以及是否使用连接表。接下来,我们详细介绍这些知识点。 ###Hibernate实体关联关系映射...

    hibernate one-to-many 单/双向关联映射配置心得

    本文主要关注Hibernate中的一个核心概念——一对一(One-to-One)、一对多(One-to-Many)和多对一(Many-to-One)关联映射,特别是关于“一到多”单向和双向关联映射的配置心得。 首先,让我们了解“一到多”关联...

    Hibernate基于外键的一对多单向关联

    “Hibernate基于外键的一对多单向关联”这个标题指的是在Java持久化框架Hibernate中,如何通过外键实现一个实体类(如订单)与另一个实体类(如商品)之间的一对多关系,并且这种关联是单向的,即从订单端可以访问到...

    Hibernate关联关系映射目录

    -- 用来映射关联PO,必须为one-to-one元素增加constrained="true"属性 --&gt; &lt;one-to-one name="address" constrained="true"/&gt; &lt;/hibernate-mapping&gt; ``` --- ##### 3. 一对一连接表单向关联 在一对一连接表单...

    hibernate 关联映射(三) one to one(双向)

    本篇将深入探讨一种特殊的关联映射方式——一对一(One to One)映射,特别是在双向关联的情况下的实现。在这个案例中,我们将详细解析`hibernate_one2onepk2`的压缩包文件,了解如何设置和操作这种关联。 一对一...

    Hibernate 一对多外键单向关联

    在配置Hibernate映射文件时,对于Person实体,可能不会有任何关于Address的配置,因为关联是单向的,所有关于Address的信息都在Address实体的映射中。在Address的映射文件中,会有一个`many-to-one`元素,指定它与...

Global site tag (gtag.js) - Google Analytics