`
paladin1988
  • 浏览: 330018 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

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

 
阅读更多

一对多,一个分类Category下有多个Product,从Cateogry角度去保存数据。

 

创建数据库脚本如下:(参看附件)

 

-- MySQL dump 10.13  Distrib 5.1.55, for Win32 (ia32)
--
-- Host: localhost    Database: hibernate_demo
-- ------------------------------------------------------
-- Server version	5.1.55-community

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+00:00' */;
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;

--
-- Table structure for table `category`
--

DROP TABLE IF EXISTS `category`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `category` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(30) NOT NULL,
  `description` varchar(30) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=3 DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `category`
--

LOCK TABLES `category` WRITE;
/*!40000 ALTER TABLE `category` DISABLE KEYS */;
INSERT INTO `category` VALUES (1,'fruit','fruit category');
/*!40000 ALTER TABLE `category` ENABLE KEYS */;
UNLOCK TABLES;

--
-- Table structure for table `product`
--

DROP TABLE IF EXISTS `product`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `product` (
  `id` int(11) NOT NULL,
  `name` varchar(30) NOT NULL,
  `price` int(11) NOT NULL,
  `description` varchar(30) NOT NULL,
  `category_id` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `product_fk` (`category_id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `product`
--

LOCK TABLES `product` WRITE;
/*!40000 ALTER TABLE `product` DISABLE KEYS */;
INSERT INTO `product` VALUES (1,'orige',20,'orige',1),(2,'apple',10,'apple',1);
/*!40000 ALTER TABLE `product` ENABLE KEYS */;
UNLOCK TABLES;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

-- Dump completed on 2012-08-09 21:40:19
 

 

 

这是一个非常不错的例子,呵呵,至少整个过程大家可以很清楚的明白。。


//Category.java

public class Category implements java.io.Serializable {

	// Fields

	private Integer id;
	private String name;
	private String description;
	private Set<Product> products = new HashSet<Product>();
 

 

//Product.java

public class Product implements java.io.Serializable {

	// Fields

	private Integer id;
	private String name;
	private Integer price;
	private String description;
 


//Category.hbm.xml

 

        <!-- 基于外键的单向一对多关联 -->
        <!-- 单向一对多在一端进行配置 -->
        <!-- set的name代表一端的set属性,table指向多端的关联表-->
        <!-- key的column属性代表外键 -->
        <!-- cascade="save-update" ,使用保存数据的级联操作-->
        <set name="products" table="product" cascade="save-update">
        <key column="category_id"  not-null="true" />
        <one-to-many class="com.v512.examples.Product"/>
        </set>
 

 

 

//HibernateTest.java

//保存数据

	public static void addProduct()
	{
		Product product = new Product();
		product.setDescription("apple");
		product.setName("apple");
		product.setPrice(10);
		
		
		Product product1 = new Product();
		product1.setDescription("orige");
		product1.setName("orige");
		product1.setPrice(20);
		
		Category category = new Category();
		category.setDescription("fruit category");
		category.setName("fruit");
		
		
		Set<Product> products = new HashSet<Product>();
		products.add(product);
		products.add(product1);
		
		category.setProducts(products);
		
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction tx = session.beginTransaction();
		session.save(category);
		//启用级联操作
//		session.save(product);
//		session.save(product1);
		tx.commit();
		session.close();
		HibernateUtil.shutdown();
		
	}

 

 

输入信息如下:

 

21:15:48,906 DEBUG JDBCTransaction:87 - current autocommit status: false
21:15:48,906 DEBUG IncrementGenerator:104 - fetching initial value: select max(id) from category
21:15:48,906 DEBUG AbstractBatcher:410 - about to open PreparedStatement (open PreparedStatements: 0, globally: 0)
21:15:48,937 DEBUG SQL:111 - 
    select
        max(id) 
    from
        category
Hibernate: 
    select
        max(id) 
    from
        category
21:15:48,953 DEBUG IncrementGenerator:119 - first free id: 1
21:15:48,953 DEBUG AbstractBatcher:418 - about to close PreparedStatement (open PreparedStatements: 1, globally: 1)
21:15:48,953 DEBUG AbstractSaveEventListener:135 - generated identifier: 1, using strategy: org.hibernate.id.IncrementGenerator
21:15:48,968 DEBUG IncrementGenerator:104 - fetching initial value: select max(id) from product
21:15:48,968 DEBUG AbstractBatcher:410 - about to open PreparedStatement (open PreparedStatements: 0, globally: 0)
21:15:48,968 DEBUG SQL:111 - 
    select
        max(id) 
    from
        product
Hibernate: 
    select
        max(id) 
    from
        product
21:15:48,968 DEBUG IncrementGenerator:119 - first free id: 1
21:15:48,968 DEBUG AbstractBatcher:418 - about to close PreparedStatement (open PreparedStatements: 1, globally: 1)
21:15:48,968 DEBUG AbstractSaveEventListener:135 - generated identifier: 1, using strategy: org.hibernate.id.IncrementGenerator
21:15:48,968 DEBUG AbstractSaveEventListener:135 - generated identifier: 2, using strategy: org.hibernate.id.IncrementGenerator
21:15:48,968 DEBUG JDBCTransaction:134 - commit
21:15:48,968 DEBUG AbstractFlushingEventListener:134 - processing flush-time cascades
21:15:48,968 DEBUG AbstractFlushingEventListener:177 - dirty checking collections
21:15:48,968 DEBUG Collections:199 - Collection found: [com.v512.examples.Category.products#1], was: [<unreferenced>] (initialized)
21:15:48,984 DEBUG AbstractFlushingEventListener:108 - Flushed: 3 insertions, 0 updates, 0 deletions to 3 objects
21:15:48,984 DEBUG AbstractFlushingEventListener:114 - Flushed: 1 (re)creations, 0 updates, 0 removals to 1 collections
21:15:48,984 DEBUG Printer:106 - listing entities:
21:15:48,984 DEBUG Printer:113 - com.v512.examples.Product{id=1, price=10, description=apple, name=apple}
21:15:48,984 DEBUG Printer:113 - com.v512.examples.Category{id=1, description=fruit category, name=fruit, products=[com.v512.examples.Product#2, com.v512.examples.Product#1]}
21:15:48,984 DEBUG Printer:113 - com.v512.examples.Product{id=2, price=20, description=orige, name=orige}
21:15:48,984 DEBUG AbstractBatcher:410 - about to open PreparedStatement (open PreparedStatements: 0, globally: 0)
21:15:48,984 DEBUG SQL:111 - 
    insert 
    into
        hibernate_demo.category
        (name, description, id) 
    values
        (?, ?, ?)
Hibernate: 
    insert 
    into
        hibernate_demo.category
        (name, description, id) 
    values
        (?, ?, ?)
21:15:48,984 DEBUG AbstractBatcher:66 - Executing batch size: 1
21:15:48,984 DEBUG AbstractBatcher:418 - about to close PreparedStatement (open PreparedStatements: 1, globally: 1)
21:15:48,984 DEBUG AbstractBatcher:410 - about to open PreparedStatement (open PreparedStatements: 0, globally: 0)
21:15:48,984 DEBUG SQL:111 - 
    insert 
    into
        hibernate_demo.product
        (name, price, description, category_id, id) 
    values
        (?, ?, ?, ?, ?)
Hibernate: 
    insert 
    into
        hibernate_demo.product
        (name, price, description, category_id, id) 
    values
        (?, ?, ?, ?, ?)
21:15:48,984 DEBUG AbstractBatcher:248 - reusing prepared statement
21:15:48,984 DEBUG SQL:111 - 
    insert 
    into
        hibernate_demo.product
        (name, price, description, category_id, id) 
    values
        (?, ?, ?, ?, ?)
Hibernate: 
    insert 
    into
        hibernate_demo.product
        (name, price, description, category_id, id) 
    values
        (?, ?, ?, ?, ?)
21:15:48,984 DEBUG AbstractBatcher:66 - Executing batch size: 2
21:15:48,984 DEBUG AbstractBatcher:418 - about to close PreparedStatement (open PreparedStatements: 1, globally: 1)
21:15:48,984 DEBUG AbstractCollectionPersister:1112 - Inserting collection: [com.v512.examples.Category.products#1]
21:15:48,984 DEBUG AbstractBatcher:410 - about to open PreparedStatement (open PreparedStatements: 0, globally: 0)
21:15:48,984 DEBUG SQL:111 - 
    update
        hibernate_demo.product 
    set
        category_id=? 
    where
        id=?
Hibernate: 
    update
        hibernate_demo.product 
    set
        category_id=? 
    where
        id=?
21:15:48,984 DEBUG AbstractBatcher:248 - reusing prepared statement
21:15:48,984 DEBUG SQL:111 - 
    update
        hibernate_demo.product 
    set
        category_id=? 
    where
        id=?
Hibernate: 
    update
        hibernate_demo.product 
    set
        category_id=? 
    where
        id=?
21:15:48,984 DEBUG AbstractCollectionPersister:1194 - done inserting collection: 2 rows inserted
21:15:48,984 DEBUG AbstractBatcher:66 - Executing batch size: 2
21:15:48,984 DEBUG AbstractBatcher:418 - about to close PreparedStatement (open PreparedStatements: 1, globally: 1)
21:15:48,984 DEBUG JDBCTransaction:147 - committed JDBC Connection
21:15:48,984 DEBUG ConnectionManager:427 - aggressively releasing JDBC connection
21:15:48,984 DEBUG ConnectionManager:464 - releasing JDBC connection [ (open PreparedStatements: 0, globally: 0) (open ResultSets: 0, globally: 0)]
21:15:49,000  INFO SessionFactoryImpl:853 - closing
21:15:49,000  INFO DriverManagerConnectionProvider:170 - cleaning up connection pool: jdbc:mysql://localhost:3306/hibernate_demo
 

 

如果我们不使用级联操作,即cascade=“save-update”,则需要先保存category,然后再保存product。

那么保存数据就是这样

 

		session.save(category);
		//启用级联操作
		session.save(product);
		session.save(product1);
		tx.commit();

 

而启用级联,则只需要保存category就行。

 

cascade取值如下:


all : 所有情况下均进行关联操作。
none:所有情况下均不进行关联操作。(默认值)
save-update:在执行save/update/saveOrUpdate时进行关联操作。
delete:在执行delete时进行关联操作。

 


请注意看一下sql,以Hibernate:开头的才是hibernate执行的sql,其他的代表发送给hibernate执行的sql语句。刚开始看错了,还以为hibernate执行了多条sql。

 

 

这种方法Hibernate reference称之为
基于外键关联的单向一对多关联是一种很少见的情况,并不推荐使用。


推荐使用:
基于连接表的单向一对多关联 应该优先被采用。请注意,通过指定unique="true",我们可以把多样性从多对多改变为一对多。

分享到:
评论

相关推荐

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

    在本教程中,我们将探讨如何实现一对一唯一外键关联映射,特别关注单向关联的情况。 ### 1. Hibernate一对一关联概述 一对一关联分为两种类型:共享主键关联(Primary Key Join)和唯一外键关联(Unique Foreign ...

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

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

    Hibernate 一对多外键单向关联

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

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

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

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

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

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

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

    Hibernate基于连接表的一对多单向关联

    标题 "Hibernate基于连接表的一对多单向关联" 涉及的是数据库对象关系映射(ORM)框架Hibernate中的一个重要概念。在Java开发中,Hibernate是广泛使用的工具,它允许开发者将Java类与数据库表进行映射,简化了数据...

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

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

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

    Hibernate 一对一唯一外键关联映射详解 Hibernate是一种流行的Java持久层框架,提供了多种关联映射方式,其中一对一唯一外键关联映射是一种常见的关联方式。在本文中,我们将详细介绍Hibernate一对一唯一外键关联...

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

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

    hibernate03:多对一单向关联、多对一双向关联

    本文主要探讨的是Hibernate中的两种关联关系:多对一单向关联和多对一双向关联。通过理解这两种关联方式,我们可以更好地设计和实现复杂的数据库模型。 首先,我们来看**多对一单向关联**。这种关联意味着一个实体...

    Hibernate一对多单向关联映射

    **标题:“Hibernate一对多单向关联映射”** 在Java持久化框架Hibernate中,一对多关系是常见的数据关联模式,它表示一个实体可以与多个其他实体相关联。在这个主题中,我们将深入探讨如何在Hibernate中实现一对多...

    hibernate多对多单向关联

    总结来说,Hibernate中的多对多单向关联是一种高效的数据映射方式,它允许我们在不增加复杂性的情况下处理两个实体之间的复杂关系。通过学习和实践,开发者能够更好地掌握这种关联类型,从而在实际项目中灵活运用。

    hibernate一对多关联映射(单向关联)

    这篇博客文章“hibernate一对多关联映射(单向关联)”将深入讲解如何配置和使用这种映射关系。 在单向关联中,只有一个实体知道另一个实体的存在,也就是说,只有父实体("一"的一端)有对子实体("多"的一端)的...

    Hibernate学习:单向多对一关联 工程

    本项目“Hibernate学习:单向多对一关联 工程”专注于讲解Hibernate中的单向多对一关联映射,这是数据库设计中常见的关系类型,尤其在处理具有层次结构的数据时。 单向多对一关联指的是在一个实体类中有一个引用,...

    hibernate单向一对多关联映射(注解版)

    在Java的持久化框架Hibernate中,单向一对多关联映射是常见的数据关系处理方式,尤其是在处理数据库中的实体类和表之间的关系时。本主题主要关注如何使用注解来实现这种映射。Hibernate通过注解使得对象关系映射...

Global site tag (gtag.js) - Google Analytics