前一段时间一直在忙于一个演示项目，近日完工了，就回过看来看了看hibernate，hibernate中一对多的关联最为常见，就简单的谈谈这个，言语不对，忘指点：
下面我以Father 和 Child为例为说明：
先来看看两个实体类
1）Father.java
package com.syp.pojo;
import java.util.HashSet;
import java.util.Set;
/**
* Father entity.
*
* @author MyEclipse Persistence Tools
*/
public class Father implements java.io.Serializable {
// Fields
private Integer id;
private String name;
private Set childs = new HashSet(0);
// Constructors
/** default constructor */
public Father() {
}
/** full constructor */
public Father(String name, Set childs) {
this.name = name;
this.childs = childs;
}
// Property accessors
public Integer getId() {
return this.id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public Set getChilds() {
return this.childs;
}
public void setChilds(Set childs) {
this.childs = childs;
}
}
对应的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">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="com.syp.pojo.Father" table="father" catalog="test">
<id name="id" type="java.lang.Integer">
<column name="id" />
</id>
<property name="name" type="java.lang.String">
<column name="name" length="30" />
</property>
<set name="childs" inverse="true" cascade="all">
<key>
<column name="father_id" />
</key>
<one-to-many class="com.syp.pojo.Child" />
</set>
</class>
</hibernate-mapping>
2）Child.java
package com.syp.pojo;
/**
* Child entity.
*
* @author MyEclipse Persistence Tools
*/
public class Child implements java.io.Serializable {
// Fields
private Integer id;
private Father father;
private String name;
// Constructors
/** default constructor */
public Child() {
}
/** full constructor */
public Child(Father father, String name) {
this.father = father;
this.name = name;
}
// Property accessors
public Integer getId() {
return this.id;
}
public void setId(Integer id) {
this.id = id;
}
public Father getFather() {
return this.father;
}
public void setFather(Father father) {
this.father = father;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
}
对应的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">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="com.syp.pojo.Child" table="child" catalog="test">
<id name="id" type="java.lang.Integer">
<column name="id" />
</id>
<many-to-one name="father" class="com.syp.pojo.Father" fetch="select">
<column name="father_id" />
</many-to-one>
<property name="name" type="java.lang.String">
<column name="name" length="30" />
</property>
</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">
<!-- Generated by MyEclipse Hibernate Tools. -->
<hibernate-configuration>
<session-factory>
<property name="dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name="connection.url">
jdbc:mysql://localhost:3306/test
</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<property name="connection.driver_class">
com.mysql.jdbc.Driver
</property>
<property name="myeclipse.connection.profile">
mysqltest
</property>
<property name="show_sql">true</property>
<mapping resource="com/syp/pojo/Father.hbm.xml" />
<mapping resource="com/syp/pojo/Child.hbm.xml" />
</session-factory>
</hibernate-configuration>
4） HibernateSessionFactory.java如下，小弟是用E直接生成的，对E不齿的就请原谅了
package com.syp.hib;
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 = "/com/syp/hib/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);
configuration.configure();
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);
// configuration.configure();
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;
}
}
5）以下测试的类：Test.java
package com.syp.test;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import com.syp.hib.HibernateSessionFactory;
import com.syp.pojo.Child;
import com.syp.pojo.Father;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Session session;
Father f = new Father();
f.setId(1);
f.setName("likui");
Child c = new Child();
c.setName("c");
c.setId(1);
c.setFather(f);
f.getChilds().add(c);
session = HibernateSessionFactory.getSession();
session.beginTransaction();
session.save(f);
session.getTransaction().commit();
// Father f2 = (Father) session.get(Father.class, 1);
//
// System.out.println(f2.getName());
Query query = session.createQuery("from Father");
List l = query.list();
for (int i = 0; i < l.size(); i++) {
Father f3 = (Father) l.get(i);
System.out.println(f3.getName());
}
}
}
在hibernate 中一对多关键点于对"inverse", "cascade"的设置，首先来说明一下这两个属性有什么作用，"inverse"的中文意思是：adj.
倒转的, 反转的
n.
反面
v.
倒转
是一个多属性的词，我想你已经明白了，它表示与此类关联的关系由谁来维护，通俗的讲就是，此类及与与此类关联的类，这两个类之间的关系由哪一方来维护。它的取值只有两个“true"or"false"，默认值为"false".
其次是"cascade",这个是一个很重要的属性，如果你想体会hibernate的强大，你一定要注意它了，因它它会给你带来意想不到的惊喜。
它的取值：
none：在保存，删除或修改当前对象时，不对其附属对象（关联对象）进行级联
操作。它是默认值。
save-update：在保存，更新当前对象时，级联保存，更新附属对象(临时对象，
游离对象)。
delete：在删除当前对象时，级联删除附属对象。
all：所有情况下均进行级联操作，即包含save-update和delete操作。
delete-orphan：删除和当前对象解除关系的附属对象。
，请各位注意一下Father.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">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="com.syp.pojo.Father" table="father" catalog="test">
<id name="id" type="java.lang.Integer">
<column name="id" />
</id>
<property name="name" type="java.lang.String">
<column name="name" length="30" />
</property>
<set name="childs" inverse="true" cascade="all">
在这里设置了“inverse=true"，它表里当在操作Father与Child时，再者之间的关系由对方去管理，
就是由Chil来管理，“casCade=all",就是我们在对此对象进行有的操作时，与此关联的附属对象均会被级联操作，如果是保存的话，
附属对象也会被保存，其它操作也是如此。
<key>
<column name="father_id" />
</key>
<one-to-many class="com.syp.pojo.Child" />
</set>
</class>
</hibernate-mapping>
在测试的代码中我们看到只保存了Father ,没有保存Child，Child也会被保存，就是CasCade的作用。
在说到这，欢迎各位大牛指点。
源码可下载：
分享到：
相关推荐
以上就是关于Hibernate中实现多对一单向关联关系的基本知识，包括如何在实体类中定义关联、如何进行数据库操作以及如何查询关联对象。这个源代码示例应该提供了更具体的实现细节，你可以通过查看和运行它来深入理解...
**标题：“Hibernate一对多单向关联映射”** 在Java持久化框架Hibernate中，一对多关系是常见的数据关联模式，它表示一个实体可以与多个其他实体相关联。在这个主题中，我们将深入探讨如何在Hibernate中实现一对多...
“Hibernate基于外键的一对多单向关联”这个标题指的是在Java持久化框架Hibernate中，如何通过外键实现一个实体类（如订单）与另一个实体类（如商品）之间的一对多关系，并且这种关联是单向的，即从订单端可以访问到...
在Java编程语言中，特别是在开发基于JPA（Java Persistence API）和ORM（对象关系映射）框架如Hibernate的应用时，一对多单向关联关系是一种常见的数据模型设计。这种关系表示一个实体可以与多个其他实体相关联，而...
标题 "Hibernate基于连接表的一对多单向关联" 涉及的是数据库对象关系映射（ORM）框架Hibernate中的一个重要概念。在Java开发中，Hibernate是广泛使用的工具，它允许开发者将Java类与数据库表进行映射，简化了数据...
总结来说，Hibernate中的多对多单向关联是一种高效的数据映射方式，它允许我们在不增加复杂性的情况下处理两个实体之间的复杂关系。通过学习和实践，开发者能够更好地掌握这种关联类型，从而在实际项目中灵活运用。
在本教程中，我们将探讨如何使用注解和XML配置实现Hibernate的一对多单向关联。 首先，让我们理解一对多关联的概念。在数据库中，一对多关联意味着在一个表（父表）中的一个记录可以对应另一个表（子表）中的多个...
这篇博客文章“hibernate一对多关联映射（单向关联）”将深入讲解如何配置和使用这种映射关系。 在单向关联中，只有一个实体知道另一个实体的存在，也就是说，只有父实体（"一"的一端）有对子实体（"多"的一端）的...
在Java的持久化框架Hibernate中，单向一对多关联映射是常见的数据关系处理方式，尤其是在处理数据库中的实体类和表之间的关系时。本主题主要关注如何使用注解来实现这种映射。Hibernate通过注解使得对象关系映射...
在Java持久化框架Hibernate中，一对多外键单向关联是一种常见的关系映射方式，它描述了一对多的关系，其中一个实体（例如Person）可以与多个其他实体（例如Address）相关联，而关联的方向只从多方（Address）指向...
在实体类之间，Hibernate支持多种关联关系，包括一对一（One-to-One）、一对多（One-to-Many）和多对多（Many-to-Many）。本资源主要探讨的是“hibernate一对一关联关系”。 一对一关联关系在现实世界中很常见，...
本教程主要探讨的是Hibernate中的一种重要关系映射类型：一对多单向关联。在关系型数据库中，一对多关联是最常见的关系类型，一个实体可以与多个其他实体相关联。在Hibernate中，这种关系可以通过配置XML映射文件或...
总结，Hibernate的多对多单向关联是通过注解或XML配置来定义的，可以方便地处理实体之间的复杂关系。理解并熟练掌握这种关联方式对于开发复杂的Java企业级应用至关重要。通过上述步骤，开发者可以有效地在数据库中...
本练习主要关注的是Hibernate中的单向多对多关联映射，这是一种常见的关系数据库设计模式，用于表示两个实体间复杂的关系。 在多对多关联中，两个实体类可以相互拥有多个实例，但只在一个方向上建立关联。例如，...
本教程主要聚焦于Hibernate中的一个关键概念——关系映射，特别是多对一单向关联的实现。这种关联类型常出现在数据库设计中，比如一个部门可以有多名员工，但一个员工只属于一个部门。 首先，我们要理解多对一关系...
本项目“Hibernate学习：单向多对一关联 工程”专注于讲解Hibernate中的单向多对一关联映射，这是数据库设计中常见的关系类型，尤其在处理具有层次结构的数据时。 单向多对一关联指的是在一个实体类中有一个引用，...