`
schy_hqh
  • 浏览: 540304 次
  • 性别: Icon_minigender_1
社区版块
存档分类
最新评论

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状态
		}
	}
	
	
	
}

 

 

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

 

分享到:
评论

相关推荐

    Hibernate常见集合映射(Set,List_Array,Map,Bag)

    Hibernate常见集合映射(Set,List_Array,Map,Bag)

    hibernate集合的映射

    hibernate集合的映射 集合的映射 set list array map

    Hibernate容器映射技术(Set、List、Map)

    Hibernate容器映射技术(Set、List、Map)

    hibernate 集合映射

    适合初学者了解在hibernate中配置set,list,map,bag等集合映射

    hibernate 中的 set map list 代码

    -Hibernate容器-Hibernate容器映射技术(Set、List、Map)(1)映射技术-Hibernate容器映射技术(Set、List、Map)(1)(Set、List、Map)(1)

    Hibernate3.1_学习源码

    案例目录: ...配置文件分别用list、set和map元素配置第二张表。 07 07Hibernate_Mapping : Hibernate中的数据关联技术,是一个重点又是一个难点,演示了 一对一、多对一、一对多、多对多等几种情况。

    精通 Hibernate:Java 对象持久化技术详解(第2版).part2

     14.3 映射List(列表)  14.4 映射Map  14.5 对集合排序  14.5.1 在数据库中对集合排序  14.5.2 在内存中对集合排序  14.6 映射组件类型集合  14.7 小结  14.8 思考题 第15章 映射实体关联关系  15.1 映射...

    hibernate 体系结构与配置 参考文档(html)

    1. Hibernate入门 1.1. 前言 1.2. 第一部分 - 第一个Hibernate应用程序 1.2.1. 第一个class 1.2.2. 映射文件 1.2.3. Hibernate配置 1.2.4. 用Ant构建 1.2.5. 启动和辅助类 1.2.6. 加载并存储对象 1.3. 第...

    Hibernate+中文文档

    Bag和list是反向集合类中效率最高的 19.5.4. 一次性删除(One shot delete) 19.6. 监测性能(Monitoring performance) 19.6.1. 监测SessionFactory 19.6.2. 数据记录(Metrics) 20. 工具箱指南 20.1. ...

    Hibernate实战(第2版 中文高清版)

     6.1.4 映射list   6.1.5 映射map   6.1.6 排序集合和有序集合  6.2 组件的集合   6.2.1 编写组件类   6.2.2 映射集合   6.2.3 启用双向导航   6.2.4 避免非空列   6.3 用注解映射集合   6.3.1 ...

    HibernateAPI中文版.chm

    Bag和list是反向集合类中效率最高的 19.5.4. 一次性删除(One shot delete) 19.6. 监测性能(Monitoring performance) 19.6.1. 监测SessionFactory 19.6.2. 数据记录(Metrics) 20. 工具箱指南 20.1. ...

    hibernate3.2中文文档(chm格式)

    Bag和list是反向集合类中效率最高的 19.5.4. 一次性删除(One shot delete) 19.6. 监测性能(Monitoring performance) 19.6.1. 监测SessionFactory 19.6.2. 数据记录(Metrics) 20. 工具箱指南 20.1. ...

    Hibernate 中文 html 帮助文档

    Bag和list是反向集合类中效率最高的 19.5.4. 一次性删除(One shot delete) 19.6. 监测性能(Monitoring performance) 19.6.1. 监测SessionFactory 19.6.2. 数据记录(Metrics) 20. 工具箱指南 20.1. ...

    hibernate 教程

    XML配置文件 4. 持久化类(Persistent Classes) 4.1. POJO简单示例 4.1.1. 为持久化字段声明访问器(accessors)和是否可变的标志(mutators) 4.1.2. 实现一个默认的构造方法(constructor) 4.1.3. ...

    精通 Hibernate:Java 对象持久化技术详解(第2版).part4

     14.3 映射List(列表)  14.4 映射Map  14.5 对集合排序  14.5.1 在数据库中对集合排序  14.5.2 在内存中对集合排序  14.6 映射组件类型集合  14.7 小结  14.8 思考题 第15章 映射实体关联关系  15.1 映射...

    精通 Hibernate:Java 对象持久化技术详解(第2版).part3

     14.3 映射List(列表)  14.4 映射Map  14.5 对集合排序  14.5.1 在数据库中对集合排序  14.5.2 在内存中对集合排序  14.6 映射组件类型集合  14.7 小结  14.8 思考题 第15章 映射实体关联关系  15.1 映射...

    Hibernate中文详细学习文档

    Bag和list是反向集合类中效率最高的 19.5.4. 一次性删除(One shot delete) 19.6. 监测性能(Monitoring performance) 19.6.1. 监测SessionFactory 19.6.2. 数据记录(Metrics) 20. 工具箱指南 20.1. ...

    精通 Hibernate:Java 对象持久化技术详解(第2版).part1.rar

     14.3 映射List(列表)  14.4 映射Map  14.5 对集合排序  14.5.1 在数据库中对集合排序  14.5.2 在内存中对集合排序  14.6 映射组件类型集合  14.7 小结  14.8 思考题 第15章 映射实体关联关系  15.1 映射...

    最全Hibernate 参考文档

    3.7. XML配置文件 3.8. J2EE应用程序服务器的集成 3.8.1. 事务策略配置 3.8.2. JNDI绑定的SessionFactory 3.8.3. JTA和Session的自动绑定 3.8.4. JMX部署 4. 持久化类(Persistent Classes) 4.1. 一个简单的...

Global site tag (gtag.js) - Google Analytics