`

hibernate一对一之唯一外键关联(单向关联)

阅读更多

新新一个java项目,并新建javabean。如下:

 

TUser.java

package cn.ehoo.bean;
/**
 *@author whp
 *@Email whp@ehoo.cn
 *@Nov 8, 2011
 *
 */
public class TUser {
	private Long id;
	private String name;
	private Integer age;
	private Group group;
	public Group getGroup() {
		return group;
	}
	public void setGroup(Group group) {
		this.group = group;
	}
	public Long getId() {
		return id;
	}
	public void setId(Long 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;
	}
	

}

 

Group.java

package cn.ehoo.bean;
/**
 *@author whp
 *@Email whp@ehoo.cn
 *@Nov 8, 2011
 *
 */
public class Group {
	private Long id;
	private String groupName;
	
	
	
	public Group(String groupName) {
		super();
		this.groupName = groupName;
	}
	public Group() {
	}
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getGroupName() {
		return groupName;
	}
	public void setGroupName(String groupName) {
		this.groupName = groupName;
	}
}

 

2 TUser与Group类的配置文件

 

TUser.hbm.xml

<?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="cn.ehoo.bean.TUser" table="t_user" >
		<id name="id" type="long">
			<generator class="native" />
		</id>
		<property name="name" />
		<property name="age"/>
		<many-to-one name="group" class="cn.ehoo.bean.Group" unique="true" column="group_id"/>
	</class>
</hibernate-mapping>

  

 

Group.hbm.xml

 

<?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="cn.ehoo.bean.Group" table="group1"><!--这里不能把table名字命名为group,如果是group的话会出错-->
		<id name="id" type="long" column="group_id">
			<generator class="native" />
		</id>
		<property name="groupName"/>
	</class>
</hibernate-mapping>

  

3、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>

	<!-- Database connection settings -->
	<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
	<property name="connection.url">jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=UTF-8</property>
	<property name="connection.username">root</property>
	<property name="connection.password">123</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>
	<property name="hbm2ddl.auto">update</property>
	<mapping resource="cn/ehoo/bean/TUser.hbm.xml" />
	<mapping resource="cn/ehoo/bean/Group.hbm.xml" />
</session-factory>

</hibernate-configuration>

 

4、hibernate Util类

package en.choo.util;


import java.io.Serializable;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public final class HibernateUtil {
	private static SessionFactory sessionFactory;
	private static ThreadLocal session = new ThreadLocal();

	private HibernateUtil() {
	}

	static {
		try {
			Configuration cfg = new Configuration();
			cfg.configure();
			sessionFactory = cfg.buildSessionFactory();
		} catch (Exception e) {
			e.printStackTrace();
			// TODO: handle exception
		}
	}

	public static Session getThreadLocalSession() {
		Session s = (Session) session.get();
		if (s == null) {
			s = getSession();
			session.set(s);
		}
		return s;
	}

	public static void closeSession() {
		Session s = (Session) session.get();
		if (s != null) {
			s.close();
			session.set(null);
		}
	}

	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	public static Session getSession() {
		return sessionFactory.openSession();
	}

	public static void add(Object entity) {
		Session s = null;
		Transaction tx = null;
		try {
			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			s.save(entity);
			tx.commit();
		} finally {
			if (s != null)
				s.close();
		}
	}

	public static void update(Object entity) {
		Session s = null;
		Transaction tx = null;
		try {
			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			s.update(entity);
			tx.commit();
		} finally {
			if (s != null)
				s.close();
		}
	}

	public static void delete(Object entity) {
		Session s = null;
		Transaction tx = null;
		try {
			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			s.delete(entity);
			tx.commit();
		} finally {
			if (s != null)
				s.close();
		}
	}

	public static Object get(Class clazz, Serializable id) {

		Session s = null;
		try {
			s = HibernateUtil.getSession();
			Object obj = s.get(clazz, id);
			return obj;
		} finally {
			if (s != null)
				s.close();
		}
	}

	public static void main(String[] args) {
		Session session = null;
		session = getSession();
		System.out.println(session);
	}

}

 

 

 

5、hibernate相应的测试类

 

package cn.ehoo.test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import cn.ehoo.bean.Group;
import cn.ehoo.bean.TUser;

import en.choo.util.HibernateUtil;

/**
 * @author whp
 * @Email whp@ehoo.cn
 * @Nov 8, 2011
 * 
 */
public class TUserTest {
	static Session session = null;
	static Transaction tr = null;

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		session = HibernateUtil.getSession();
		tr = session.beginTransaction();
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
		tr.commit();
	}

	@Test
	public static  void saveUser() {
		TUser user = new TUser();
		user.setAge(12);
		user.setName("Wang Haipeng");
		Group group = new Group("系统权限");
		user.setGroup(group);
		HibernateUtil.add(group);
		HibernateUtil.add(user);
	}
	
	
	public static void main(String[] args) {
		saveUser();
	}

}

 

 

 

分享到:
评论

相关推荐

    hibernate一对一之唯一外键关联(双向关联)

    本篇主要探讨的是Hibernate中的一对一(OneToOne)关系映射,特别是唯一外键关联(UniDirectional and Bidirectional Association)的情况。我们将深入理解这种关联方式的配置、实现以及它在实际应用中的价值。 1. ...

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

    在本文中,我们将详细介绍Hibernate一对一唯一外键关联映射的概念、配置方法和实践应用。 一对一唯一外键关联映射的概念 在Hibernate中,一对一唯一外键关联映射是指两个实体之间的关联关系,其中一个实体作为外键...

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

    在Java的持久化框架Hibernate中,一对一(One-to-One)关联映射是常见的...以上就是关于Hibernate一对一唯一外键关联映射(单向关联)的详细说明。通过这种方式,我们可以轻松地在Java应用中处理数据库的一对一关系。

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

    在本案例中,我们将详细探讨“hibernate一对一唯一外键关联映射(单项关联)”。 首先,一对一关联分为两种类型:单向关联和双向关联。单向关联意味着在一个实体类中存在对另一实体的引用,而另一实体类中没有相应...

    Hibernate一对一单向外键关联 (联合主键annotation)

    本篇将详细讲解如何使用Hibernate进行一对一单向外键关联,并且该关联涉及到联合主键的注解配置。 首先,一对一关联可以分为两种类型:单向和双向。在单向一对一关联中,只有一个实体知道另一个实体的存在,而另一...

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

    本话题主要探讨的是Hibernate中的一种关联映射方式——一对一(One-to-One)单向外键关联。这种关联模式通常用于两个实体之间存在唯一对应的关系,例如一个用户对应一个唯一的账户。 在Hibernate中,一对一关联可以...

    Hibernate 一对一外键单向关联

    首先,一对一外键关联指的是一个实体通过外键直接引用另一个实体的主键。在单向关联中,只有其中一个实体知道另一个实体的存在,而另一个实体则无感知。这种关联通常体现在数据库设计中,比如一个用户只有一个账户,...

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

    **标题详解:**“Hibernate教程04_关系映射之一对一单向外键关联” 在Hibernate框架中,关系映射是数据库表之间的关联在对象模型中的体现。本教程重点讲解了一对一(One-to-One)单向外键关联的实现方法。在数据库...

    Hibernate一对一单向外键关联(annotation/xml)

    本篇将深入探讨Hibernate中的一对一单向外键关联,通过注解和XML配置两种方式进行实现。这种关联允许一个实体类与另一个实体类之间存在一对一的关系,并且只在其中一个实体类中维护这种关系。 首先,我们来理解一对...

    Hibernate 一对多外键单向关联

    在Java持久化框架Hibernate中,一对多外键单向关联是一种常见的关系映射方式,它描述了一对多的关系,其中一个实体(例如Person)可以与多个其他实体(例如Address)相关联,而关联的方向只从多方(Address)指向...

    hibernate外键实现一对一单向关联关系源码

    以上就是关于Hibernate外键实现一对一单向关联关系的详细说明。这个知识点涉及到数据库设计、ORM框架的使用,以及Java编程实践,对于理解和使用Hibernate进行数据库操作具有重要意义。在实践中,应结合具体业务场景...

    Hibernate Annotation 唯一外键一对一双向关联

    在Java的持久化框架Hibernate中,`@OneToOne`注解用于表示一对一的关联关系,而唯一外键一对一双向关联则是这种关系的一种具体实现方式。这篇文章将深入探讨这一概念,帮助你理解如何在实际开发中应用。 首先,我们...

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

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

    详解Hibernate一对一映射配置

    在Java持久化框架Hibernate中,一对一(One-to-One)映射是对象关系映射的一种常见方式,用于表示两个实体之间一对一的关系。这种关系通常出现在一个实体的实例只能与另一个实体的单个实例相关联的情况。下面我们将...

    hibernate主键实现一对一单向关联关系源码

    - 一对一关联通常需要在数据库层面建立唯一约束,以确保两个表的主键/外键关联是唯一的。 - 当使用`cascade`属性时,需谨慎处理级联操作,避免不必要的数据删除或更新。 - 如果不希望在`Person`类中暴露`Address`...

    hibernate多对一单向关联关系实现源码

    以上就是关于Hibernate中实现多对一单向关联关系的基本知识,包括如何在实体类中定义关联、如何进行数据库操作以及如何查询关联对象。这个源代码示例应该提供了更具体的实现细节,你可以通过查看和运行它来深入理解...

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

    本篇文章将深入探讨如何使用Hibernate Annotation来实现基于外键的单向多对一关联。 在关系型数据库中,多对一关联是一种常见的关系类型,意味着一个实体(如表)可以与另一个实体有多条记录关联,而另一个实体只能...

    hibernate一对一关联关系

    本资源主要探讨的是“hibernate一对一关联关系”。 一对一关联关系在现实世界中很常见,比如一个人只有一个身份证,或者一个公司的总部只有一个。在Hibernate中,设置一对一关联关系可以帮助我们更好地管理和操作...

Global site tag (gtag.js) - Google Analytics