`

hibernate一对多例子-已更新

阅读更多

先看由满江红翻译团队(RedSaga Translate Team)翻译的一对多配置说明
然后在看例子
 一对多关联(One-to-many Associations)

一对多关联 通过外键 连接两个类对应的表,而没有中间集合表。 这个关系模型失去了一些Java集合的语义:

  • 一个被包含的实体的实例只能被包含在一个集合的实例中

  • 一个被包含的实体的实例只能对应于集合索引的一个值中

一个从ProductPart的关联需要关键字字段,可能还有一个索引字段指向Part所对应的表。 <one-to-many>标记指明了一个一对多的关联。

<one-to-many 
        class="ClassName"                                  (1)
        not-found="ignore|exception"                       (2)
        entity-name="EntityName"                           (3)
        node="element-name"
        embed-xml="true|false"
    />
(1)

class(必须):被关联类的名称。

(2)

not-found (可选 - 默认为exception): 指明若缓存的标示值关联的行缺失,该如何处理: ignore 会把缺失的行作为一个空关联处理。

(3)

entity-name (可选): 被关联的类的实体名,作为class的替代。

例子

<set name="bars">
    <key column="foo_id"/>
    <one-to-many class="org.hibernate.Bar"/>
</set>

注意:<one-to-many>元素不需要定义任何字段。 也不需要指定表名。

重要提示 :如果一对多关联中的外键字段定义成NOT NULL,你必须把<key>映射声明为not-null="true",或者使用双向关联,并且标明inverse="true"

详细请看http://www.huihoo.com/framework/hibernate/reference-v3_zh-cn/collections.html



1 先建表

 create   table  student
(sid 
varchar ( 32 not   null   primary   key ,
 sname 
varchar ( 16 ),
 sage 
varchar ( 16 ),
)
 create   table  book
(bid 
varchar ( 32 not   null   primary   key ,
bname 
varchar ( 16 ),
bprice 
varchar ( 16 ),
sid 
varchar ( 32 )
)
 
2.写vo
  Student.java
package com.test;

import java.util.Set;

public class Student
{
    
private String sid;
    
private String sname;
    
private String sage;
    
private Set book;
    
public Student()
    
{
    }

  
// 写上get set
Book.JAVA
package com.test;

public class Book
{
    
private String bid;
    
private String bname;
    
private String bprice;
    
public Book()
    
{
    }

   
//写上get set
3.写对应的映射文件
Student.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
    PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"
>

<hibernate-mapping>

    
<class name="com.test.Student" table="student" >

        
<id name="sid" type="string" unsaved-value="null" >
            
<column name="sid" sql-type="char(32)" not-null="true"/>
            
<generator class="uuid.hex"/>
        
</id>

        
<property name="sname">
            
<column name="sname" sql-type="varchar(16)" not-null="true"/>
        
</property>

        
<property name="sage">
            
<column name="sage" sql-type="varchar(16)" not-null="true"/>
        
</property>

        
<set name="book" cascade="all" outer-join="true">
            
<key column="sid"/>
            
<one-to-many class="com.test.Book" />
        
</set>

    
</class>

</hibernate-mapping>

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

<hibernate-mapping>

    
<class name="com.test.Book" table="book" >

        
<id name="bid" type="string" unsaved-value="null" >
            
<column name="bid" sql-type="char(32)" not-null="true"/>
            
<generator class="uuid.hex"/>
        
</id>

        
<property name="bname">
            
<column name="bname" sql-type="varchar(16)" not-null="true"/>
        
</property>

        
<property name="bprice">
            
<column name="bprice" sql-type="varchar(16)" not-null="true"/>
        
</property>

    
</class>

</hibernate-mapping>

接着把下面的hibernate.properties文件拷到classes目录下。。这里用的是mysql
hibernate.query.substitutions true 1, false 0, yes 'Y', no 'N'
## MySQL
hibernate.dialect net.sf.hibernate.dialect.MySQLDialect
hibernate.connection.driver_class org.gjt.mm.mysql.Driver
hibernate.connection.url jdbc:mysql://localhost:3306/wjcms
hibernate.connection.username root
hibernate.connection.password wujun
hibernate.connection.pool_size 1
hibernate.proxool.pool_alias pool1
hibernate.show_sql true
hibernate.jdbc.batch_size 0
hibernate.max_fetch_depth 1
hibernate.cache.use_query_cache true 
4.写测试类了..
package com.test;

import net.sf.hibernate.Session;
import net.sf.hibernate.SessionFactory;
import net.sf.hibernate.cfg.Configuration;
import net.sf.hibernate.*;
import java.util.Set;
import java.util.HashSet;
import java.sql.*;
import java.util.List;
import java.util.Iterator;

public class TestOneToMany
{
    SessionFactory sf;
    Session session;
    
public TestOneToMany()
    
{
        
try
        
{
            Configuration cfg 
= new Configuration();
            sf 
= cfg.addClass(Student.class).addClass(Book.class).buildSessionFactory();
        }

        
catch(HibernateException ex)
        
{
            ex.printStackTrace();
        }

    }

    
//插入
    public void doCreate()
    
{
        
try
        
{
            session 
= sf.openSession();

            Student student 
= new Student();
            student.setSname(
"小王");
            student.setSage(
"22");

            Set bookSet 
= new HashSet();
            Book book 
= null;
            
for(int i=0;i<2;i++)
            
{
                book 
= new Book();
                book.setBname(
"java "+i);
                book.setBprice(
"50");
                bookSet.add(book);
            }

            student.setBook(bookSet);

            session.save(student);
            session.flush();
            session.connection().commit();

        }

        
catch(HibernateException ex)
        
{
            ex.printStackTrace();
        }

        
catch(SQLException ex1)
        
{
            ex1.printStackTrace();
        }

        
finally
        
{
                
try{
                    session.close();
                }

                
catch(HibernateException ex2){
                }

        }


    }

    
//查询
    public void doQuery()
    
{
        
try{
            session 
= sf.openSession();
            Query q 
= session.createQuery("select s from Student as s");
            List l 
= q.list();
            Student s 
= null;
            Book book 
= null;
            
for(int i=0;i<l.size();i++)
            
{
                s 
= (Student)l.get(i);
                System.out.println(
"姓名: "+s.getSname());
                System.out.println(
"年龄: "+s.getSage());
                System.out.println(
"所有的书:");
                Iterator it 
= s.getBook().iterator();
                
while(it.hasNext())
                
{
                    book 
= (Book)it.next();
                    System.out.println(
"书名: "+book.getBname());
                    System.out.println(
"价格: "+book.getBprice());
                }



            }


        }

        
catch(HibernateException ex){
            ex.printStackTrace();
        }

        
finally{
            
try{
                session.close();
            }

            
catch(HibernateException ex2){
            }

        }

    }

    
public static void main(String[] args)
    
{
        TestOneToMany t 
= new TestOneToMany();
        
//t.doCreate();
        t.doQuery();
    }

}


好了。。

在这里把这些例子几下来。。方便查阅。。

也是很适合象我们这样的出学者。。。
分享到:
评论

相关推荐

    hibernate一对多例子

    ### Hibernate一对多关系详解 #### 一、理解一对多关系 在数据库设计中,一对多(One-to-Many)是一种常见的关联方式,指的是一个表中的记录可以与另一个表中的多个记录建立联系。例如,在学生与书籍的关系中,一...

    hibernate一对多项目

    本项目“hibernate一对多项目”旨在演示如何在JavaWeb应用中使用Hibernate处理一对多的关系映射。这里我们将深入探讨 Hibernate 的一对多关系、配置以及在实际项目中的应用。 首先,一对多关系在数据库中很常见,...

    Hibernate 一对一,一对多,多对多例子

    “Hibernate 一对一,一对多,多对多例子” 指的是使用Hibernate框架实现数据库中不同关联关系的示例。Hibernate是一个Java持久化框架,它提供了对象关系映射(ORM)功能,使得开发人员可以方便地在Java对象和关系...

    Hibernate-one-to-many

    ### Hibernate一对多关系详解 在Hibernate框架中,处理实体间的关系是常见的需求,尤其是在复杂的业务逻辑中。本文将深入探讨Hibernate中一对多(One-to-Many)关系的处理方式,特别是通过外键映射和inverse属性的...

    Hibernate应用例子many-to-many

    本示例将详细讲解如何在Hibernate中实现多对多(many-to-many)的关系映射。 在数据库设计中,多对多关系是指两个实体之间存在多个关联,比如学生和课程的关系,一个学生可以选修多门课程,一门课程也可以被多个...

    Hibernate one-to-many / many-to-one关系映射

    在"hibernate-father-son"这个例子中,可能包含两个实体类,如"Father"和"Son","Father"与多个"Son"之间存在一对多关系。在实际开发中,这种关系映射可以方便地处理父子级联操作,如级联保存、更新和删除。 四、...

    hibernate-2.1.8-all-bin_b.rar

    这些示例可能包括简单的单表操作,多表关联映射,甚至更复杂的一对多、多对一、一对多、多对多的关系映射处理。此外,它们还展示了事务管理和缓存机制的使用,帮助你理解Hibernate如何实现对象的持久化。 三、`lib`...

    Hibernate关于注解的一对多,多对多,一对一

    本篇文章将深入探讨Hibernate中注解的一对多、多对多和一对一关系映射。 ### 一对多关系 在现实生活中,例如一个班级有一个班主任,而班主任可以管理多个学生,这就是典型的“一对多”关系。在Hibernate中,我们...

    Hibernate ORM - 一对多双向关联关系

    这个压缩包文件“HibernateORM”很可能包含了关于如何在实际项目中设置和使用Hibernate一对多双向关联的示例代码、配置文件或者详细教程。通过学习这些材料,开发者能够深入理解如何在Java应用中利用Hibernate来处理...

    (4)Hibernate中的many-to-one和one-to-many关系

    本话题主要探讨两种基本的关系映射类型:many-to-one(多对一)和one-to-many(一对多)。这两种关系映射是数据库中常见的关联类型,理解和掌握它们对于开发高质量的Java应用至关重要。 1. many-to-one关系 many-to...

    hibernate一对多与多对一

    本篇文章将详细讲解"hibernate一对多与多对一"的关系映射概念,以及如何在实际开发中进行配置和使用。 首先,我们来看一下“一对多”关系。在现实世界中,这种关系可以对应到例如一个班级有多个学生,或者一个人...

    hibernate many-to-one(多对一)及 cascade(级联).doc

    在数据库设计中,实体之间的关系主要包括一对一、一对多、多对多等几种类型。而在ORM(对象关系映射)框架Hibernate中,通过不同的注解或者XML配置来表示这些关系。其中,`many-to-one`(多对一)关系是较为常见的一...

    hibernate实例(一对多,多对一)

    在这个“hibernate实例(一对多,多对一)”的主题中,我们将深入探讨两种重要的关联关系:一对一(One-to-One)和一对多(One-to-Many)。 **一对一关联(One-to-One)** 在一对一关联中,一个实体与另一个实体之间...

    hibernate-validator-6.1.2.Final-dist.zip

    3. 国际化:Hibernate Validator支持多语言的错误消息,方便根据不同地区展示不同的错误提示。 4. 组验证:允许对一组相关的验证注解进行分组,根据业务逻辑选择执行特定的验证组。 三、使用 Hibernate Validator ...

    hibernate一对多映射的例子

    通过运行这个例子,你可以更深入地理解Hibernate的一对多映射,包括如何配置映射,如何在代码中操作对象,以及它们如何在数据库中体现。 总之,Hibernate的一对多映射是处理复杂关联关系的重要工具,它允许我们在...

    Hibernate 一对多、多对一、级联、加载、反转

    在Java持久化框架Hibernate中,一对多(One-to-Many)、多对一(Many-to-One)、级联(Cascading)、加载(Loading)和反转(Inversing)是关系映射的重要概念,它们对于理解如何在数据库和对象之间有效地管理关联至...

    MyEclipse8.5 hibernate一对多例子

    该例子可以先通过mysql建立数据库 利用myeclipse的逆向工程生成pojo(java简单对象),dao(数据库操作对象),hibernateSession类 快速构建数据库操作架构,适合初学者参考. 关于myeclipse的逆向工程视频可以参考myeclipse...

    hibernate例子(多对一)

    在Hibernate中,关系映射是通过配置文件或注解来定义的,包括一对一、一对多、多对一和多对多等关系。 1. **多对一关系的概念** 在数据库中,多对一关系意味着多个表(或实体)中的条目可以关联到另一个表(或实体...

    Hibernate 经典例子全

    在`hibernate_one2one_ufk_1`示例中,我们学习了如何配置和管理一对一的关系。这种关系在数据库中通常通过主键外键关联实现,Hibernate提供了多种方式来建立和维护这种关系,例如使用`@OneToOne`注解。 **五、懒...

    hibernate框架相关的例子

    Hibernate 是一款开源的对象关系映射(ORM)框架,它极大地简化了Java应用程序对数据库的操作。这个框架允许开发者用面向对象的方式来处理数据库操作,从而避免了传统SQL语句的繁琐和易错性。在这个“hibernate框架...

Global site tag (gtag.js) - Google Analytics