hibernate配置的一些总结

最新推荐文章于 2024-08-23 18:02:39 发布
最新推荐文章于 2024-08-23 18:02:39 发布
阅读量471 收藏
点赞数 1
分类专栏： 三大框架 文章标签： hibernate generator table class string xml

 many-to-one 2009-03-17

Xml代码 复制代码
  1. <!--关联映射的本质：-->  
  2.     <!--* 将关联关系映射到数据库，所谓的关联关系是对象模型在内存中的一个或多个引用-->  
  3.   
  4. <!--<many-to-one>会在多的一端加入一个外键，指向一的一端，这个外键是由<many-to-one>中的column属性定义的，如果忽略了这个属性那么默认的外键与实体的属性一致<many-to-one>标签的定义示例：-->  
  5.     <!-- * <many-to-one name="group" column="groupid"/>-->  
  6.   
  7. <hibernate-mapping>  
  8.     <class name="com.langhua.hibernate.pojo.User" table="t_user">  
  9.         <id name="id">  
  10.             <generator class="native"/>  
  11.         </id>  
  12.         <property name="name"/>  
  13.         <many-to-one name="group" column="groudid" cascade="save-update"></many-to-one>  
  14.     </class>  
  15. </hibernate-mapping>  
  16.   
  17. <hibernate-mapping>  
  18.     <class name="com.langhua.hibernate.pojo.Group" table="t_group">  
  19.         <id name="id">  
  20.             <generator class="native"/>  
  21.         </id>  
  22.         <property name="name"/>          
  23.     </class>  
  24. </hibernate-mapping>  



one-to-one主键关连 单向

Xml代码 复制代码
  1. <hibernate-mapping>  
  2.     <class name="com.langhua.hibernate.pojo.Person" table="t_Person">  
  3. <!-- person的主键来源idCard，也就是共享idCard的主键 -->  
  4.         <id name="id">  
  5.             <generator class="foreign">  
  6.                 <param name="property">idCard</param>  
  7.             </generator>  
  8.         </id>  
  9.         <property name="name"/>  
  10. <!-- one-to-one标签的含义，指示hibernate怎么加载它的关联对象，默认根据主键加载，constrained="true"，表明当前主键上存在一个约束，person的主键作为外键参照了idCard -->      
  11.         <one-to-one name="idCard" constrained="true"/>       
  12.     </class>  
  13. </hibernate-mapping>  
  14.   
  15. <hibernate-mapping>  
  16.     <class name="com.langhua.hibernate.pojo.IdCard" table="t_IdCard">  
  17.         <id name="id">  
  18.             <generator class="native"/>  
  19.         </id>  
  20.         <property name="num"/>           
  21.     </class>  
  22. </hibernate-mapping>  



one-to-one 主键关连 双向

Xml代码 复制代码
  1. <hibernate-mapping>  
  2.     <class name="com.langhua.hibernate.pojo.Person" table="t_Person">  
  3.         <id name="id">  
  4.             <generator class="foreign">  
  5.                 <param name="property">idCard</param>  
  6.             </generator>  
  7.         </id>  
  8.         <property name="name"/>      
  9.         <one-to-one name="idCard" constrained="true"/>       
  10.     </class>  
  11. </hibernate-mapping>  
  12.   
  13. <hibernate-mapping>  
  14.     <class name="com.langhua.hibernate.pojo.IdCard" table="t_IdCard">  
  15.         <id name="id">  
  16.             <generator class="native"/>  
  17.         </id>  
  18.         <property name="num"/>       
  19.         <one-to-one name="person"/>      
  20.     </class>  
  21. </hibernate-mapping>  



one-to-one 唯一外键关连 单向 就是多对一

Xml代码 复制代码
  1. <hibernate-mapping>  
  2.     <class name="com.langhua.hibernate.pojo.Person" table="t_Person">  
  3.         <id name="id">  
  4.             <generator class="native"/>  
  5.         </id>  
  6.         <property name="name"/>      
  7. <!--可以采用<many-to-one>标签，指定多的一端的unique=true，这样就限制了多的一端的多重性为一通过这种手段映射一对一唯一外键关联-->  
  8.         <many-to-one name="idCard" unique="true" cascade="all"/>     
  9.     </class>  
  10. </hibernate-mapping>  
  11.   
  12. <hibernate-mapping>  
  13.     <class name="com.langhua.hibernate.pojo.IdCard" table="t_IdCard">  
  14.         <id name="id">  
  15.             <generator class="native"/>  
  16.         </id>  
  17.         <property name="num"/>           
  18.     </class>  
  19. </hibernate-mapping>  



one-to-one 唯一外键 双向

Xml代码 复制代码
  1. <hibernate-mapping>  
  2.     <class name="com.langhua.hibernate.pojo.Person" table="t_Person">  
  3.         <id name="id">  
  4.             <generator class="native"/>  
  5.         </id>  
  6.         <property name="name"/>      
  7.         <many-to-one name="idCard" unique="true" cascade="all"/>     
  8.     </class>  
  9. </hibernate-mapping>  
  10. <hibernate-mapping>  
  11.     <class name="com.langhua.hibernate.pojo.IdCard" table="t_IdCard">  
  12.         <id name="id">  
  13.             <generator class="native"/>  
  14.         </id>  
  15.         <property name="num"/>       
  16.         <one-to-one name="person" property-ref="idCard"/>    
  17.     </class>  
  18. </hibernate-mapping>  



one-to-many 单向

Xml代码 复制代码
  1. <hibernate-mapping>  
  2.     <class name="com.langhua.hibernate.pojo.Classes" table="t_classes">  
  3.         <id name="id">  
  4.             <generator class="native"/>  
  5.         </id>  
  6.         <property name="name"/>  
  7.         <set name="students" cascade="all">  
  8.             <key column="classesid"/>  
  9.             <!-- 有缺点 -->  
  10. <!--多对一关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是多指向一-->  
  11. <!--一对多关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是一指向多-->  
  12. <!--* 如果将t_student表里的classesid字段设置为非空，则无法保存-->  
  13. <!--* 因为不是在student这一端维护关系，所以student不知道是哪个班的，-->  
  14. <!--所以需要发出多余的update语句来更新关系-->  
  15.             <one-to-many class="com.langhua.hibernate.pojo.Students"/>  
  16.         </set>  
  17.     </class>  
  18. </hibernate-mapping>  
  19.   
  20. <hibernate-mapping>  
  21.     <class name="com.langhua.hibernate.pojo.Students" table="t_students">  
  22.         <id name="id">  
  23.             <generator class="native"/>  
  24.         </id>  
  25.         <property name="name"/>  
  26.     </class>  
  27. </hibernate-mapping>  



one-to-many 双向

Xml代码 复制代码
  1. <hibernate-mapping>  
  2.     <class name="com.langhua.hibernate.pojo.Classes" table="t_classes">  
  3.         <id name="id">  
  4.             <generator class="native"/>  
  5.         </id>  
  6.         <property name="name"/>  
  7.         <set name="students" inverse="true" cascade="all">  
  8.             <key column="classesid"/>  
  9.             <!-- 有缺点 -->  
  10.             <one-to-many class="com.langhua.hibernate.pojo.Students"/>  
  11.         </set>  
  12.     </class>  
  13. </hibernate-mapping>  
  14.   
  15. <hibernate-mapping>  
  16.     <class name="com.langhua.hibernate.pojo.Students" table="t_students">  
  17.         <id name="id">  
  18.             <generator class="native"/>  
  19.         </id>  
  20.         <property name="name"/>  
  21.         <many-to-one name="classes" column="classesid"/>  
  22.     </class>  
  23. </hibernate-mapping>  



many-to-many 双向

Xml代码 复制代码
  1. <!--table属性值必须和单向关联中的table属性值一致-->  
  2. <!--<key>中column属性值要与单向关联中的<many-to-many>标签中的column属性值一致-->  
  3. <!--在<many-to-many>中的column属性值要与单向关联中<key>标签的column属性值一致-->  
  4. <hibernate-mapping>  
  5.     <class name="com.langhua.hibernate.pojo.User" table="t_user">  
  6.         <id name="id">  
  7.             <generator class="native"/>  
  8.         </id>  
  9.         <property name="name"/>  
  10.         <set name="roleSet" table="t_user_role">  
  11.             <key column="userId"/>  
  12.             <many-to-many class="com.langhua.hibernate.pojo.Role" column="roleId"/>  
  13.         </set>  
  14.     </class>  
  15. </hibernate-mapping>  
  16.   
  17. <hibernate-mapping>  
  18.     <class name="com.langhua.hibernate.pojo.Role" table="t_role">  
  19.         <id name="id">  
  20.             <generator class="native"/>  
  21.         </id>  
  22.         <property name="name"/>  
  23.         <set name="userSet" table="t_user_role" inverse="true">  
  24.             <key column="roleId"/>  
  25.             <many-to-many class="com.langhua.hibernate.pojo.User" column="userId"/>  
  26.         </set>  
  27.     </class>  
  28. </hibernate-mapping>  



一对多双向关联映射：
* 在一一端的集合上使用<key>，在对方表中加入一个外键指向一一端
* 在多一端采用<many-to-one>

注意：<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致，否则引用字段的错误

如果在”一“一端维护一对多关联关系，hibernate会发出多余的udpate语句，所以我们一般在多
的一端来维护关联关系

关于inverse属性：
inverse主要用在一对多和多对多双向关联上，inverse可以被设置到集合标签<set>上，
默认inverse为false，所以我们可以从”一“一端和”多“一端维护关联关系，
如果设置成inverse为true，则我们只能从多一端来维护关联关系

注意：inverse属性，只影响数据的存储，也就是持久化

inverse和cascade
* inverse是关联关系的控制方向
* cascade操作上的连锁反应

复合主键

Java代码 复制代码
  1.   
  2. public class FiscalYearPeriod {   
  3.        
  4.     private FiscalYearPeriodPK fiscalYearPeriodPK;   
  5.        
  6.     //开始日期   
  7.     private Date beginDate;   
  8.        
  9.     //结束日期   
  10.     private Date endDate;   
  11.        
  12.     //状态   
  13.     private String periodSts;   
  14. }   
  15. public class FiscalYearPeriodPK implements Serializable {   
  16.   
  17.     //核算年   
  18.     private int fiscalYear;   
  19.        
  20.     //核算月   
  21.     private int fiscalPeriod;   
  22.   
  23.     @Override  
  24.     public int hashCode() {   
  25.         final int prime = 31;   
  26.         int result = 1;   
  27.         result = prime * result + fiscalPeriod;   
  28.         result = prime * result + fiscalYear;   
  29.         return result;   
  30.     }   
  31.   
  32.     @Override  
  33.     public boolean equals(Object obj) {   
  34.         if (this == obj)   
  35.             return true;   
  36.         if (obj == null)   
  37.             return false;   
  38.         if (getClass() != obj.getClass())   
  39.             return false;   
  40.         final FiscalYearPeriodPK other = (FiscalYearPeriodPK) obj;   
  41.         if (fiscalPeriod != other.fiscalPeriod)   
  42.             return false;   
  43.         if (fiscalYear != other.fiscalYear)   
  44.             return false;   
  45.         return true;   
  46.     }   
  47.        
  48. }  
public class FiscalYearPeriod {
	
	private FiscalYearPeriodPK fiscalYearPeriodPK;
	
	//开始日期
	private Date beginDate;
	
	//结束日期
	private Date endDate;
	
	//状态
	private String periodSts;
}
public class FiscalYearPeriodPK implements Serializable {

	//核算年
	private int fiscalYear;
	
	//核算月
	private int fiscalPeriod;

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + fiscalPeriod;
		result = prime * result + fiscalYear;
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		final FiscalYearPeriodPK other = (FiscalYearPeriodPK) obj;
		if (fiscalPeriod != other.fiscalPeriod)
			return false;
		if (fiscalYear != other.fiscalYear)
			return false;
		return true;
	}
	
}


Xml代码 复制代码
  1. ]   
  2. <hibernate-mapping>  
  3.     <class name="com.bjsxt.hibernate.FiscalYearPeriod" table="t_fiscal_year_period">  
  4.         <composite-id name="fiscalYearPeriodPK">  
  5.             <key-property name="fiscalYear"/>  
  6.             <key-property name="fiscalPeriod"/>      
  7.         </composite-id>  
  8.         <property name="beginDate"/>  
  9.         <property name="endDate"/>  
  10.         <property name="periodSts"/>  
  11.     </class>  
  12. </hibernate-mapping>  


集合

Java代码 复制代码
  1. public class CollectionMapping implements Serializable {   
  2.     private int id;   
  3.     private String name;   
  4.     private Set setValue;   
  5.     private List listValue;   
  6.     private String[] arrayValue;   
  7.     private Map mapValue;   
  8. }  
public class CollectionMapping implements Serializable {
	private int id;
	private String name;
	private Set setValue;
	private List listValue;
	private String[] arrayValue;
	private Map mapValue;
}

 

Xml代码 复制代码
  1. <hibernate-mapping>  
  2.     <class name="com.langhua.hibernate.pojo.CollectionMapping" table="t_CollectionMapping">  
  3.         <id name="id">  
  4.             <generator class="native"/>  
  5.         </id>  
  6.         <property name="name"/>  
  7.            
  8.         <set name="setValue" table="t_setValue">  
  9.             <key column="set_id"/>  
  10.             <!--    
  11.             <composite-element class="">  
  12.                 这个是配置对象   
  13.             </composite-element>  
  14.              -->  
  15.              <element type="string" column="set_value"/>  
  16.         </set>  
  17.            
  18.         <list name="listValue" table="t_listValue">  
  19.             <key column="list_id"/>  
  20.             <list-index column="list_index"/>  
  21.             <element type="string" column="list_value"/>  
  22.         </list>  
  23.            
  24.         <array name="arrayValue" table="t_arrayValue">  
  25.             <key column="array_id"/>  
  26.             <list-index column="list_index"/>  
  27.             <element type="string" column="array_value"/>  
  28.         </array>  
  29.            
  30.         <map name="mapValue" table="t_mapValue">  
  31.             <key column="map_id"/>  
  32.             <map-key type="string" column="map_key"/>  
  33.             <element type="string" column="map_value"/>  
  34.         </map>  
  35.     </class>  
  36. </hibernate-mapping>  
wr5532
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate配置
weixin_42490093的博客
06-16 498
一、准备 1、安装Mysql，地址：http://www.mysql.com/downloads/ 2、下载mysql的JDBC驱动，地址：http://dev.mysql.com/downloads/connector/j/3.1.html 3、下载Hibernate的Jar文件，地址：http://hibernate.org/orm/ 二、开发环境 JDK1.8、windows10、Eclipse 三、配置 1、创建一个Web Project。 2、将下载的Hibernate压缩文件解压
Hibernate的具体配置（转）（自己收藏）
08-04 4143
Hibernate配置文件可以有两种格式，一种是 hibernate.properties ，另一种是 hibernate.cfg.xml  后者稍微方便一些，当增加hbm映射文件的时候，可以直接在 hibernate.cfg.xml 里面增加，不必像 hibernate.properties 必须在初始化代码中加入。 但不管怎么说，两种的配置项都是一样的，下面详细介绍： 在Hibernate的s
Hibernate配置总结
麒麟木木
10-09 1918
本文总结了Hibernate框架配置文件的配置：包括了主配置文件和映射文件
Hibernate总结—hibernate配置文件
Coder Yasmine
06-28 2394
    Hibernate作为ORM框架的一个强大实现，配置文件是必不可少的。.NET中对ORM框架的实现，用的是EntityFramework，Java这边则是Hibernate。在说Hibernate配置文件之前，先说说EF的配置文件，这样有个共鸣。       EF的配置文件主要有这么三部分：   1、连接数据库       连接数据库需要数据库驱动，数据库服务，用户名和密码。 ...
Hibernate 学习总结
weixin_39981912的博客
04-18 2100
一：hibernate（是一个开源的轻量级（就是不需要依赖其他就可以运行）框架）是应用在dao层（持久化层）的一个框架，是对数据库的crud操作（就是增删改查操作），就是对jdbc进行的封装，不在写复杂的SQL语句，只需要在配置文件中配置即可。二：MVC思想 就是（M：模型    V:视图    C：控制器）三：hibernate使用的是ORM思想对数据库进行crud操作        ORM（o...
hibernate配置总结
09-06
hibernate配置总结
Hibernate知识点总结
11-27
2. **创建Hibernate配置文件**：通常命名为`hibernate.cfg.xml`，此文件用于配置数据库连接信息和其他全局设置。 3. **创建持久化类**：持久化类代表数据库中的表，需要遵循一定的约定，例如提供无参数构造器、标识...
Hibernate4的一些总结
04-05
【标题】：“Hibernate4的一些总结” 【描述】：这篇博客主要涵盖了Hibernate4框架在实际开发中的应用和理解，作者通过个人实践对Hibernate4的核心特性和使用技巧进行了深度解析。 【标签】：“源码”和“工具”这...
Hibernate 简单 PPT 总结
09-01
【Hibernate 简单 PPT 总结】 Hibernate 是一个流行的开源对象关系映射（ORM）框架，它简化了Java应用程序对数据库的操作。通过提供一套API和元数据，Hibernate允许开发者将业务对象直接映射到数据库表，从而避免了...
28. Hibernate 中的常见坑
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
08-12 681
框架方便了开发者的工作，但是运行速度并没有原生的快。原生开发是直接告诉 JVM 要做什么，框架则是曲线救国，JVM 需要绕些圈子才明白开发者的意图。显然，框架是要以更多性能消耗、运行速度作为代价的。本节课，和大家聊一聊使用 Hibernate 中可能遇到的坑。避开这些坑，真正享受 Hibernate 带给开发者的福利。
【架构-24】XML和JSON
qq_45611002的博客
08-23 460
XML和JSON各有优势，选择哪种格式取决于具体的需求。如果需要灵活的、可扩展的结构，XML是个不错的选择；如果追求轻量级和高效性，尤其是在Web环境中，JSON则更为合适。
Maven的配置文件pom.xml标签详解(含常用plugin)
weixin_49999835的博客
08-23 749
一、什么是pom.xml pom.xml是Maven项目的核心配置文件，它是 项目对象模型 - Project Object Model（POM） 的缩写。POM定义了项目的所有属性，包括项目的名称、版本、依赖关系、构建配置等。使用pom.xml，我们可以轻松地管理项目的构建和依赖关系，让我们能够更专注于业务逻辑的开发。 二、pom.xml的结构 我们先看一个简单pom.xml的结构，首先和标签主要针对的是本pom.xml文件的格式，如下： <?xml version="1.0" encoding=
Spring 中FileSystemXmlApplicationContext
小湘西的博客
08-20 921
是 Spring Framework 中的一个重要类，位于包中。它是接口的实现，专门用于从文件系统中的 XML 配置文件加载 Spring bean 定义。与不同，它允许开发者从文件系统的任何路径访问配置文件，不仅限于类路径。
还在拼接字符串生成XML？(Java)
weixin_53132064的博客
08-23 593
选择FreeMarker还是DOM4J主要取决于具体需求。如果需要生成复杂的、动态的XML内容，FreeMarker是一个更好的选择；而对于简单的XML结构，DOM4J提供了一种快速、类型安全的方式。根据项目需求选择合适的工具，以提高开发效率和代码质量。
[Matsim]Matsim学习笔记-population.xml的创建
机器学习菜鸟
08-20 254
示例代码中创建person对象需要的标签id、起点坐标、终点坐标、activity结束的时间、leg的模式，生成的person对象要包含这些值。幸运的发现matsim中实现了很多的writer工具类，population的生成就需要用到PopulationWriter这个工具类。在利用matsim实现交通模拟时，需要把模拟的乘客出行数据替换成自己的，如何进行替换呢？带着这个问题，调研学习matsim，实现population.xml的生成。
XML 实例：深入解析与实际应用
wjs2024的博客
08-22 497
XML 是一种强大且灵活的数据格式，广泛用于各种应用程序和行业中。通过自定义标签和结构，XML 提供了一种标准化方法来存储、传输和交换数据。随着技术的发展，XML 的应用范围不断扩大，包括但不限于网页开发、数据交换、网络服务和文档处理。
R 语言学习教程，从入门到精通，R XML 文件使用（19）
qq_45746668的博客
08-20 262
XML 指的是可扩展标记语言（eXtensible Markup Language），XML 被设计用来传输和存储数据。 R 语言读写 XML 文件需要安装扩展包，我们可以在 R 到控制台输入以下命令来安装
关于xml中存在特殊的转义字符，不能正常反序列化问题
最新发布
等待のL先森的博客
08-23 386
如果这些字符直接出现在xml文档中，而没有被转义，那么xml解析器可能就会误解他们的意思，比如，解析器可能错误的认为。使用Apache Commons Lang 中的。标志着·一个新的xml元素的开始。方法来转义XML字符串。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值