Hibernate基于配置文件（十五）集合映射List、Map

对方是实体类

用关联映射 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状态
		}
	}
	
	
	
}

 

 

===========================================================================