对方是实体类
用关联映射 one-to-many many-to-one 等
对方不是一个实体类，比如String,Integer.Address(无id字段)等，用集合来存储---集合映射
List
Set
Map
删除的时候，会自动删除对应的表中的所有数据(类似于级联删除)
===========================================================================
Set集合映射（不重复）
package org.leadfar.hibernate.model;
import java.util.HashSet;
import java.util.Set;
public class Person {
private int id;
private String name;
private Set<String> qqNumbers;//一个字段存不下多个QQ，需用一张表来存储
Person() {
}
public void addQq(String qq){
if(qqNumbers == null) {
qqNumbers = new HashSet<String>();
}
qqNumbers.add(qq);
}
public Set<String> getQqNumbers() {
return qqNumbers;
}
public void setQqNumbers(Set<String> qqNumbers) {
this.qqNumbers = qqNumbers;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
<?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 package="org.hibernate.auction"> <!-- name为实体类 table为映射到数据库中的表 lazy默认为true 延迟发出select语句，直到真正用到对象的属性(非id属性)--> <class name="org.leadfar.hibernate.model.Person" table="t_person" > <!-- id为数据库标识，作为主键 --> <id name="id"> <generator class="native"/> </id> <property name="name"/> <set name="qqNumbers" table="t_person_qq"> <key column="personId"></key> <element type="string" column="qqNumber"></element> </set> </class> </hibernate-mapping>
package org.leadfar.hibernate.model;
import java.util.Set;
import junit.framework.TestCase;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class Test_Component_01 extends TestCase {
public void testSave_01() throws Exception {
//默认读取类路径根目录下的hibernate.cfg.xml配置文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory
//buildSessionFactory的时候会自动创建数据库表
SessionFactory sfactory = cfg.buildSessionFactory();
//创建Hibernate Session
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Person p = new Person();
p.setName("张三");
p.addQq("1240234098");
p.addQq("124234");
p.addQq("1234324");
session.save(p);
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void testLoad_01() throws Exception {
//默认读取类路径根目录下的hibernate.cfg.xml配置文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory
//buildSessionFactory的时候会自动创建数据库表
SessionFactory sfactory = cfg.buildSessionFactory();
//创建Hibernate Session
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Person p = (Person)session.load(Person.class, 1);
System.out.println(p.getName());
Set<String> qqNumbers = p.getQqNumbers();
for(String qq : qqNumbers) {
System.out.println(qq);
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void testDelete_01() throws Exception {
//默认读取类路径根目录下的hibernate.cfg.xml配置文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory
//buildSessionFactory的时候会自动创建数据库表
SessionFactory sfactory = cfg.buildSessionFactory();
//创建Hibernate Session
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Person p = (Person)session.load(Person.class, 1);
session.delete(p);//一并删除t_person_qq表
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
}
===========================================================================
List集合映射（由于list集合需要有索引号，所以，如果存储实体类，那么，必须在一的一端维护关联关系，所以，一般在实体类映射上，使用Set集合较多！）
package org.leadfar.hibernate.model;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
public class Person {
private int id;
private String name;
private List<Integer> qqNumbers;//一个字段存不下多个QQ，需用一张表来存储
Person() {
}
public void addQq(Integer qq){
if(qqNumbers == null) {
qqNumbers = new ArrayList<Integer>();
}
qqNumbers.add(qq);
}
public List<Integer> getQqNumbers() {
return qqNumbers;
}
public void setQqNumbers(List<Integer> qqNumbers) {
this.qqNumbers = qqNumbers;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
<?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 package="org.hibernate.auction"> <!-- name为实体类 table为映射到数据库中的表 lazy默认为true 延迟发出select语句，直到真正用到对象的属性(非id属性)--> <class name="org.leadfar.hibernate.model.Person" table="t_person" > <!-- id为数据库标识，作为主键 --> <id name="id"> <generator class="native"/> </id> <property name="name"/> <list name="qqNumbers" table="t_person_qq"> <key column="personId"></key> <!-- list集合需要增加一个索引字段 --> <list-index column="qq_index"></list-index> <element type="int" column="qqNumber"></element> </list> </class> </hibernate-mapping>
package org.leadfar.hibernate.model;
import java.util.List;
import junit.framework.TestCase;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class Test_Component_01 extends TestCase {
public void testSave_01() throws Exception {
//默认读取类路径根目录下的hibernate.cfg.xml配置文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory
//buildSessionFactory的时候会自动创建数据库表
SessionFactory sfactory = cfg.buildSessionFactory();
//创建Hibernate Session
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Person p = new Person();
p.setName("张三");
p.addQq(240234098);
p.addQq(124234);
p.addQq(1234324);
session.save(p);
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void testLoad_01() throws Exception {
//默认读取类路径根目录下的hibernate.cfg.xml配置文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory
//buildSessionFactory的时候会自动创建数据库表
SessionFactory sfactory = cfg.buildSessionFactory();
//创建Hibernate Session
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Person p = (Person)session.load(Person.class, 1);
System.out.println(p.getName());
List<Integer> qqNumbers = p.getQqNumbers();
for(Integer qq : qqNumbers) {
System.out.println(qq);
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void testDelete_01() throws Exception {
//默认读取类路径根目录下的hibernate.cfg.xml配置文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory
//buildSessionFactory的时候会自动创建数据库表
SessionFactory sfactory = cfg.buildSessionFactory();
//创建Hibernate Session
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Person p = (Person)session.load(Person.class, 1);
session.delete(p);//一并删除t_person_qq表
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
}
===========================================================================
Map集合映射
package org.leadfar.hibernate.model;
import java.util.HashMap;
import java.util.Map;
public class Person {
private int id;
private String name;
private Map<String,String> addresses;//一个字段存不下多个QQ，需用一张表来存储
Person() {
}
public void addAddress(String type,String addr) {
if(addresses==null) {
addresses = new HashMap<String,String>();
}
addresses.put(type,addr);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setAddresses(Map<String, String> addresses) {
this.addresses = addresses;
}
public Map<String, String> getAddresses() {
return addresses;
}
}
<?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 package="org.hibernate.auction"> <!-- name为实体类 table为映射到数据库中的表 lazy默认为true 延迟发出select语句，直到真正用到对象的属性(非id属性)--> <class name="org.leadfar.hibernate.model.Person" table="t_person" > <!-- id为数据库标识，作为主键 --> <id name="id"> <generator class="native"/> </id> <property name="name"/> <map name="addresses" table="t_person_address"> <key column="personId"></key> <map-key type="string" column="addrType"></map-key> <element type="string" column="addr"></element> </map> </class> </hibernate-mapping>
package org.leadfar.hibernate.model;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import junit.framework.TestCase;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class Test_Component_01 extends TestCase {
public void testSave_01() throws Exception {
//默认读取类路径根目录下的hibernate.cfg.xml配置文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory
//buildSessionFactory的时候会自动创建数据库表
SessionFactory sfactory = cfg.buildSessionFactory();
//创建Hibernate Session
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Person p = new Person();
p.setName("张三");
p.addAddress("地址1", "a");
p.addAddress("地址2", "b");
p.addAddress("地址3", "c");
session.save(p);
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void testLoad_01() throws Exception {
//默认读取类路径根目录下的hibernate.cfg.xml配置文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory
//buildSessionFactory的时候会自动创建数据库表
SessionFactory sfactory = cfg.buildSessionFactory();
//创建Hibernate Session
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Person p = (Person)session.load(Person.class, 1);
System.out.println(p.getName());
Map<String,String> addresses = p.getAddresses();
Set<Map.Entry<String,String>> set = addresses.entrySet();
for (Iterator iterator = set.iterator(); iterator.hasNext();) {
Entry<String, String> entry = (Entry<String, String>) iterator.next();
System.out.println(entry.getKey()+"---"+entry.getValue());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void testDelete_01() throws Exception {
//默认读取类路径根目录下的hibernate.cfg.xml配置文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory
//buildSessionFactory的时候会自动创建数据库表
SessionFactory sfactory = cfg.buildSessionFactory();
//创建Hibernate Session
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Person p = (Person)session.load(Person.class, 1);
session.delete(p);//一并删除t_person_qq表
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
}
===========================================================================
package org.leadfar.hibernate.model;
import java.util.HashMap;
import java.util.Map;
public class Person {
private int id;
private String name;
private Map<String,Address> addresses;//不将Address看做一个实体类
Person() {
}
public void addAddress(String type,String province,String city,String street) {
if(addresses==null) {
addresses = new HashMap<String,Address>();
}
Address address = new Address();
address.setProvince(province);
address.setCity(city);
address.setStreet(street);
addresses.put(type,address);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Map<String, Address> getAddresses() {
return addresses;
}
public void setAddresses(Map<String, Address> addresses) {
this.addresses = addresses;
}
}
package org.leadfar.hibernate.model;
public class Address {
//没有数据库标识字段id
private String province;
private String city;
private String street;
Address(){}
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
}
<?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 package="org.hibernate.auction"> <!-- name为实体类 table为映射到数据库中的表 lazy默认为true 延迟发出select语句，直到真正用到对象的属性(非id属性)--> <class name="org.leadfar.hibernate.model.Person" table="t_person" > <!-- id为数据库标识，作为主键 --> <id name="id"> <generator class="native"/> </id> <property name="name"/> <!-- map集合的数据被另一张表存储，每组key和value结合personId组成一条记录 --> <map name="addresses" table="t_person_address"> <!-- key标签指定了与t_person表进行关联的id值 (即在t_person_address表中使用personId字段来存储t_person中某条记录的主键id) --> <key column="personId"></key> <!-- 保存map集合key的字段 --> <map-key type="string" column="addrType"></map-key> <!-- map集合的value为复合类型，使用composite-element来指定各个属性 --> <composite-element class="org.leadfar.hibernate.model.Address"> <property name="province"></property> <property name="city"></property> <property name="street"></property> </composite-element> </map> </class> </hibernate-mapping>
package org.leadfar.hibernate.model;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import junit.framework.TestCase;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class Test_Component_01 extends TestCase {
public void testSave_01() throws Exception {
//默认读取类路径根目录下的hibernate.cfg.xml配置文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory
//buildSessionFactory的时候会自动创建数据库表
SessionFactory sfactory = cfg.buildSessionFactory();
//创建Hibernate Session
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Person p = new Person();
p.setName("张三");
p.addAddress("地址1", "a","b","c");
p.addAddress("地址2", "d","e","f");
p.addAddress("地址3", "c","h","i");
session.save(p);
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void testLoad_01() throws Exception {
//默认读取类路径根目录下的hibernate.cfg.xml配置文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory
//buildSessionFactory的时候会自动创建数据库表
SessionFactory sfactory = cfg.buildSessionFactory();
//创建Hibernate Session
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Person p = (Person)session.load(Person.class, 1);
System.out.println(p.getName());
Map<String,Address> map = p.getAddresses();
Set<Map.Entry<String,Address>> set = map.entrySet();
Iterator<Map.Entry<String,Address>> it = set.iterator();
while(it.hasNext()){
Map.Entry<String, Address> entry = it.next();
String name = entry.getKey();
Address addr = entry.getValue();
System.out.println(name+","+addr.getProvince()+","+addr.getCity()+","+addr.getStreet());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void testDelete_01() throws Exception {
//默认读取类路径根目录下的hibernate.cfg.xml配置文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory
//buildSessionFactory的时候会自动创建数据库表
SessionFactory sfactory = cfg.buildSessionFactory();
//创建Hibernate Session
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Person p = (Person)session.load(Person.class, 1);
session.delete(p);//一并删除t_person_qq表
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
}
===========================================================================
相关推荐
在Hibernate的映射文件（.hbm.xml）中，我们通常使用`<set>`, `<list>`, `<map>`等标签来定义集合映射。每个标签都有对应的属性，例如： - `name`: 对象属性名。 - `table`: 所映射的数据库表名。 - `inverse`: ...
常见的集合映射类型有 Set、List、Array、Map 和 Bag 等，每种类型都有其特点和应用场景。 Set 集合映射 Set 集合是 Hibernate 中基础的集合类型，元素数据一般使用外键同主表关联。Set 集合非常适用于集合元素不...
本文将深入探讨Hibernate中的四种主要集合映射类型：Set、List、Array和Map，以及它们在实际开发中的应用场景和配置。 一、Set集合映射 Set集合映射是最常见的映射类型，它不允许重复元素。在Hibernate中，Set通常...
在Java的持久化框架Hibernate中，集合映射是将数据库中的表关系映射到对象模型中的集合类，如List、Set、Map等。这允许我们在Java代码中操作对象集合，而Hibernate负责处理底层的SQL查询和数据存储。本文将深入探讨`...
对于"student与Score的Map集合关系"，在Hibernate配置文件中，我们需要定义两个实体（Student和Score），并在Student实体中声明一个Map类型属性，用于存储Score对象。映射关系可以通过`@OneToMany`和`@ManyToOne`...
Hibernate支持多种集合映射类型，包括List、Set、Map、Bag、Array等。它们之间的区别主要在于元素的唯一性、顺序性和映射到数据库的实现方式。例如，List和Array维护元素的插入顺序，而Set不允许重复元素；Map则...
在探讨Hibernate中List信息的配置时，我们主要聚焦于如何在ORM（对象关系映射）框架下有效地管理和操作集合类型，尤其是List、Set以及Map。本文将深入解析List与Set在Hibernate中的映射机制，同时也会简要提及Map的...
1. **、<list>、<map> 和 **：这些元素是Hibernate用于映射不同类型的集合的标签。`<set>`用于映射无序且不重复的集合，如Java的HashSet；`<list>`用于映射有序的集合，如ArrayList，元素可以通过索引访问；`<map>`...
`hibernate-mapping`节点是Hibernate映射文件中的顶级节点，用于定义一系列配置选项，控制整个映射文件的行为和映射规则。这些配置包括数据库连接细节、默认的映射策略等。 - **schema**: 定义了数据库的Schema名称...
在“CollectionMapping”这个示例程序中，你将看到如何在Hibernate配置文件中定义这些集合映射，以及如何在实体类中声明和使用它们。通过实践这些范例，你将更深入地了解Hibernate的集合映射机制，并能熟练地应用于...
### Hibernate映射文件基础结构 映射文件通常以`<!DOCTYPE hibernate-mapping>`开头，引用DTD（文档类型定义），确保文件遵循正确的格式。例如： ```xml <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/...
综上所述，"Hibernate映射配置实例大全"涵盖的内容广泛，包括基本的配置文件设置、实体类的XML和注解映射、集合映射、加载策略、事务管理和缓存配置等。通过深入学习和实践这些实例，开发者可以熟练地运用Hibernate...
本文将深入探讨Hibernate中的关联关系、CRUD操作以及集合映射（基于注解的方式）。关联关系是数据库设计中的核心概念，而Hibernate通过注解使得这种关系在代码中得以体现，简化了开发工作。 ### Hibernate关联关系 ...
1. **一对多关系**：在映射文件中，可以通过`set`、`list`或`map`标签来表示。例如，部门与员工关系，部门对应多员工，员工对应单一部门，可以这样映射： ```xml <!-- 部门映射 --> <!-- 员工映射 --> ``` ...
Hibernate容器映射技术(Set、List、Map)
集合映射是Hibernate中一个非常关键的概念，它使得Java集合类如List、Set、Map等能够与数据库中的多对一、一对多、多对多关系对应起来。在这个主题中，我们将深入探讨Hibernate集合映射的各个方面。 首先，我们来看...
本文主要聚焦于Hibernate框架下的集合映射机制，特别是针对`Set`、`List`、`Array`、`Map`、`Bag`五种集合类型的映射进行深入探讨。通过具体的代码示例和XML配置文件，帮助读者理解如何在Hibernate中正确地配置这些...
关于工具的使用，Hibernate提供了hibernate.cfg.xml配置文件或基于Java的配置方式来设置数据库连接参数、实体类扫描路径等。同时，它还提供了SessionFactory、Session、Transaction等接口，供开发者进行数据库操作。...