hibernate 订阅
Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的JaveEE架构中取代CMP,完成数据持久化的重任。 展开全文
Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的JaveEE架构中取代CMP,完成数据持久化的重任。
信息
关键技术
数据持久化
典型应用
EJB的J2EE架构中取代CMP
作    用
数据库与界面之间的桥梁
中文名
对象关系映射框架
属    性
开放源代码的对象关系映射框架
外文名
Hibernate
Hibernate简介
Hibernate作为数据库与界面之间的桥梁,需要面向对象思想操纵对象。对象可能是普通JavaBeans/POJO。应用程序通过抽象将应用从底层事务隔离开。使用底层的API或Transaction对象完成轻量级框架提供一级缓存和二级缓存。Hibernate直接提供相关支持,底层驱动可以随意切换数据库,快速简洁。使业务层与具体数据库分开,只针对Hibernate 进行开发,完成数据和对象的持久化。针对不同的数据库形成不同的SQL 查询语句,降低数据库之间迁移的成本。Hibernate支持多种缓存机制,Hibernate适配MS SQLSERVER、ORACLE、SQL、H2、Access和Mysql等多种数据库。Hibernate用反射机制实现持久化对象操作,实现与IDE(Integrated Development Environment)的耦合度。Hibernate使用数据库和配置信息为应用程序提供持久化服务。从配置文件中读取数据库相关参数,将持久化类和数据表对应使用。用Hibernate API对象持久化,利用映像信息将持久化操作翻译为SQL语句进行查询。Hibernate框架技术最关键是数据持久化,是将数据保存到持久层的过程。持久层的数据在掉电后也不会丢失的数据。持久层是基于Hibernate技术的检索系统开发的基本。系统结构的层次模型有三个阶段。整个过程首先实现应用层和数据层。数据层保存持久化数据,应用层接收输入的数据。然后通过MVC 模式实现业务逻辑与表示层的分开。表示层和用户实现交互,业务逻辑层处理数据持久化操作。将第二阶段业务逻辑层的功能部署拆分后,业务逻辑层完成核心业务逻辑处理,持久层完成对象持久化。降低业务逻辑层复杂度的同时将数据持久化让其他组件完成。 [1] 
收起全文
精华内容
下载资源
问答
  • Hibernate

    千次阅读 2018-06-02 00:25:00
    Hibernate完成对象模型和基于SQL的关系模型的映射关系 Hibernate较iBATIS更具有面向对象的特征 Java EE 5抛弃了传统的Entity EJB, 改用JPA作为持久成解决方案 JPA实体可以当作Hibernate PO使用 低侵入 不要求PO...

     Hibernate完成对象模型和基于SQL的关系模型的映射关系
     Hibernate较iBATIS更具有面向对象的特征
     Java EE 5抛弃了传统的Entity EJB, 改用JPA作为持久层解决方案
     JPA实体可以当作Hibernate PO使用
     低侵入 不要求PO继承Hibernate的某个超类或实现Hibernate的某个接口
     Hibernate使得Java EE应用的OOA OOD OOP三个过程一脉相承 成为一个整体
     编程语言和底层数据库发展不协调催生出了ORM框架(对象/关系数据库映射 一种规范)
     JPA规范未提供ORM实现 开发者面向JPA编程 应用程序底层可以在不同的ORM框架之间切换
     随着面向对象数据库的广泛发展 ORM工具会自动消亡
     面向对象程序设计优势(面向对象建模、操作 多态、继承 摈弃难以理解的过程 简单易用)
     关系数据库的优势(大量数据查找、排序 集合数据连接操作、映射 并发、事务 约束、隔离)
     操作持久化对象 (面向对象的操作转化为底层的SQL操作)

    流行的ORM框架 
    JPA(官方标准 jBPM未来都将会采用JPA作为持久层解决方案)
    Hibernate(属于JBoss、Red Hat 优秀的性能 丰富的文档)
    iBATIS SQL Mapping框架 允许直接编写SQL语句
    TopLink Oracle公司产品
    数据为中心的程序 使用存储过程实现商业逻辑 Hibernate不是好方案
    中间件应用 采用面向对象的业务模型和商业逻辑 Hibernate是最有用的
    类到表的映射(包括java数据类型到SQL数据类型的映射)

    Hibernate优势 开源免费 轻量级 可扩展性 API开放 开发者活跃

    Hibernate官网下载 zip包解压后 
    documentation/ 参考文档和API文档 
    lib/ 所依赖的第三方类库 required/子目录必须的第三方类库
    project/ 源代码
    hibernate3.jar 核心JAR包
    hibernate3.jar lib/required lib/jpa子目录下所有jar 需要添加到类加载路径
    如果是控制台编译 需要添加到环境变量CLASSPATH 否则可以使用Ant工具或者IDE工具管理
    底层JDBC和MySQL的驱动也需要添加到类加载路径

    展开全文
  • Hibernate入门第一讲——Hibernate框架的快速入门

    万次阅读 多人点赞 2019-08-04 14:59:27
    Hibernate框架介绍什么是Hibernate我们可以从度娘上摘抄这样有关Hibernate的介绍: Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全...

    Hibernate框架的概述

    什么是框架?

    框架指的是软件的半成品,已经完成了部分功能。

    JavaEE开发的三层架构

    了解框架的基本概念之后,我们就来看看Hibernate框架处于JavaEE开发的经典三层架构中的什么位置。
    在这里插入图片描述
    温馨提示:虽然Servlet+JSP+JavaBean+JDBC使用这套架构可以开发市面的所有应用(拥有它,你就能打天下),但是在企业中并不会使用(过于底层),这还有个屌用啊!企业中开发一般使用SSH(Struts2+Spring+Hibernate)和SSM(SpringMVC+Spring+MyBatis)。

    Hibernate概述

    什么是Hibernate?

    我们可以从度娘上看到这样有关Hibernate的介绍:
    在这里插入图片描述
    从中,我们可以得出这样的结论:Hibernate是一个轻量级的JDBC封装,也就是说,我们可以使用Hibernate来完成原来我们使用JDBC完成的操作,也就是与数据库的交互操作。它是在Dao层去使用的。总而言之,Hibernate就是一个持久层的ORM框架

    什么是ORM?

    使用传统的JDBC开发应用系统时,如果是小型应用系统,并不觉得有什么麻烦,但是对于大型应用系统的开发,使用JDBC就会显得力不从心。例如对几十、几百张包含几十个字段的表进行插入操作时,编写的SQL语句不但很长,而且繁琐,容易出错;在读取数据时,需要写多条getXxx语句从结果集中取出各个字段的信息,不但枯燥重复,并且工作量非常大。为了提高数据访问层的编程效率,Gavin King开发出了一个当今最流行的的ORM框架,它就是Hibernate框架。
    所谓的ORM就是利用描述对象和数据库表之间映射的元数据,自动把Java应用程序中的对象,持久化到关系型数据库的表中。通过操作Java对象,就可以完成对数据库表的操作。可以把ORM理解为关系型数据和对象的一个纽带,开发人员只需要关注纽带一端映射的对象即可。ORM原理如下图所示。
    在这里插入图片描述
    说那么多,无非就是想说说ORM是个什么东西,对象关系映射(英语:Object Relation Mapping,简称ORM,或O/RM,或O/R mapping),指的是将一个Java中的对象与关系型数据库中的表建立一种映射关系,从而操作对象就可以操作数据库中的表。就这么简单,说那么多干嘛!

    为什么要学习Hibernate框架?

    与其它操作数据库的技术相比,Hibernate具有以下几点优势:

    • Hibernate对JDBC访问数据库的代码做了轻量级封装,大大简化了数据访问层繁琐的重复性代码,并且减少了内存消耗,加快了运行效率;
    • Hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM实现,它很大程度的简化了DAO(Data Access Object,数据访问对象)层编码工作;
    • Hibernate的性能非常好,映射的灵活性很出色。它支持很多关系型数据库,从一对一到多对多的各种复杂关系;
    • 可扩展性强,由于源代码的开源以及API的开放,当本身功能不够用时,可以自行编码进行扩展。

    总结:Hibernate是企业级开发中的主流框架,映射的灵活性很出色,并且它支持很多关系型数据库。

    Hiberate框架学习目标

    由于之前学过Hiberate框架,所以这就等于是在复习了。对于Hiberate框架的学习重点,可以总结为:

    1. 掌握Hiberate的基本配置——即搭建Hiberate开发环境;
    2. 掌握Hiberate常用API——即如何使用Hiberate框架进行开发;
    3. 掌握Hiberate的关联映射——解决表与表之间存在的关系问题,有1:n(一对多)、 1:1(一对一)、m:n(多对多)关系;
    4. 掌握Hiberate的检索方式——即掌握Hiberate的查询;
    5. 掌握Hiberate的优化方式——即提高Hiberate的效率。

    Hibernate快速入门

    介绍完Hibernate框架之后,我们来快速入门Hibernate,对其有一个直观的了解。

    下载Hibernate5

    大家可去官网下载Hibernate,我下载的是
    这里写图片描述
    所以,之后有关Hibernate的系列文章都是以这个版本为蓝图展开的。下载解压缩之后,可以看到如下目录结构:
    这里写图片描述

    其中,在lib/required目录下,包含运行Hibernate项目所必须的jar包:
    这里写图片描述

    创建一个普通的Java项目,导入Hibernate框架相关依赖jar包

    创建一个普通的Java项目,例如hibernate_demo01,然后导入Hibernate框架相关依赖jar包。

    • 首先导入Hibernate开发必须的jar包,即lib/required目录下所有的jar包:
      这里写图片描述

    • 再导入MySQL数据库的驱动jar包:
      这里写图片描述

    • 最后导入日志记录相关的jar包:
      这里写图片描述
      导入完日志相关的jar包之后,我们还要导入日志记录文件,日志记录文件咱也是第一次接触,不知道咋写啊?没关系,找到project/etc/log4j.properties文件,很明显,它就是日志记录文件,将它拷贝复制到我们项目的src目录下,打开它,这里面的内容有点多啊!而且我们现在也不知道是什么意思,咋办?先跟着我将其内容精简为下面这样,后面我再来为大家做一点解释。

      ### direct log messages to stdout ###
      log4j.appender.stdout=org.apache.log4j.ConsoleAppender
      log4j.appender.stdout.Target=System.err
      log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
      log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
      
      ### direct messages to file mylog.log ###
      log4j.appender.file=org.apache.log4j.FileAppender
      log4j.appender.file.File=c\:mylog.log
      log4j.appender.file.layout=org.apache.log4j.PatternLayout
      log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
      
      ### set log levels - for more verbose logging change 'info' to 'debug' ###
      # error warn info debug trace
      log4j.rootLogger= info, stdout
      

    这样工程的整个结构就变成:
    在这里插入图片描述

    创建数据库与表

    正如前面所说,Hibernate是一个轻量级的JDBC封装,也就是说,我们可以使用Hibernate来完成原来我们使用JDBC完成的操作,也就是与数据库的交互操作。所以我们首先要创建数据库与表,这里我使用的数据库是MySQL。

    create database hibernate_demo01;
    use hibernate_demo01;
    CREATE TABLE `cst_customer` (
    	`cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
    	`cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
    	`cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
    	`cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
    	`cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
    	`cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
    	`cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
    	PRIMARY KEY (`cust_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
    

    创建实体类

    我们在com.meimeixia.hibernate.demo01包中创建一个实体类——Customer.java,如下:

    package com.meimeixia.hibernate.demo01;
    
    public class Customer {
    
    	private Long cust_id;
    	private String cust_name;
    	private String cust_source;
    	private String cust_industry;
    	private String cust_level;
    	private String cust_phone;
    	private String cust_mobile;
    	
    	public Long getCust_id() {
    		return cust_id;
    	}
    	public void setCust_id(Long cust_id) {
    		this.cust_id = cust_id;
    	}
    	public String getCust_name() {
    		return cust_name;
    	}
    	public void setCust_name(String cust_name) {
    		this.cust_name = cust_name;
    	}
    	public String getCust_source() {
    		return cust_source;
    	}
    	public void setCust_source(String cust_source) {
    		this.cust_source = cust_source;
    	}
    	public String getCust_industry() {
    		return cust_industry;
    	}
    	public void setCust_industry(String cust_industry) {
    		this.cust_industry = cust_industry;
    	}
    	public String getCust_level() {
    		return cust_level;
    	}
    	public void setCust_level(String cust_level) {
    		this.cust_level = cust_level;
    	}
    	public String getCust_phone() {
    		return cust_phone;
    	}
    	public void setCust_phone(String cust_phone) {
    		this.cust_phone = cust_phone;
    	}
    	public String getCust_mobile() {
    		return cust_mobile;
    	}
    	public void setCust_mobile(String cust_mobile) {
    		this.cust_mobile = cust_mobile;
    	}
    	@Override
    	public String toString() {
    		return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + ", cust_source=" + cust_source
    				+ ", cust_industry=" + cust_industry + ", cust_level=" + cust_level + ", cust_phone=" + cust_phone
    				+ ", cust_mobile=" + cust_mobile + "]";
    	}
    	
    }
    

    创建Hibernate的相关配置文件

    准备好以上工作之后,我们终于要踏入Hibernate的学习中了。首先我们要编写Hibernate的相关配置文件,Hibernate的相关配置文件分为两种:

    1. Xxx.hbm.xml:它主要是用于描述类与数据库中的表的映射关系;
    2. hibernate.cfg.xml:它是Hibernate框架的核心配置文件。

    有关这两个配置文件的详细介绍,我后面会给大家讲解,如果就在这里弄的话,违背了我的初衷了,本文只是在教初学者怎样快速入门Hibernate。

    创建映射配置文件

    首先我们要学会如何编写映射配置文件,大家要知道编写完的映射配置文件应与实体类在同一个包下,并且名称应是类名.hbm.xml,所以我们要在com.meimeixia.hibernate.demo01包下创建一个Customer.hbm.xml文件,但是它的约束应该怎么写呢?可以在Hibernate的核心jar包——hibernate-core-5.0.7.Final.jar的org.hibernate包下查找到hibernate-mapping-3.0.dtd文件,打开该文件,找到如下内容:
    在这里插入图片描述
    然后复制黏贴到Customer.hbm.xml文件中即可。这里我先给出Customer.hbm.xml文件的内容,但内容不做过多介绍:

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
        
    <hibernate-mapping>
    	<!-- 建立类与表的映射 -->
    	<class name="com.meimeixia.hibernate.demo01.Customer" table="cst_customer">
    		<!-- 建立类中的属性与表中的主键相对应 -->
    		<id name="cust_id" column="cust_id">
    			<!-- 主键的生成策略,后面会讲,现在使用的是本地生成策略 -->
    			<generator class="native" />
    		</id>
    		
    		<!-- 建立类中的普通属性和表中的字段相对应 -->
    		<property name="cust_name" column="cust_name" />
    		<property name="cust_source" column="cust_source" />
    		<property name="cust_industry" column="cust_industry" />
    		<property name="cust_level" column="cust_level" />
    		<property name="cust_phone" column="cust_phone" />
    		<property name="cust_mobile" column="cust_mobile" />
    	</class>
    </hibernate-mapping>
    

    创建核心配置文件

    核心配置文件主要是Hibernate框架所使用的,它主要包含了连接数据库的相关信息和Hibernate的相关配置等。现在我们要学会如何编写Hibernate的核心配置文件,大家也要知道编写完的核心配置文件应在src目录下,并且名称应是hibernate.cfg.xml,所以我们要在src目录下创建一个hibernate.cfg.xml文件,但是它的约束又应该怎么写呢?同样可以在Hibernate的核心jar包——hibernate-core-5.0.7.Final.jar的org.hibernate包下查找到hibernate-configuration-3.0.dtd文件,打开该文件,找到如下内容:
    在这里插入图片描述
    然后复制黏贴到hibernate.cfg.xml文件中即可。在这个文件中到底该如何配置呢?我们可以参考hibernate-release-5.0.7.Final\project\etc\hibernate.properties文件。这里我先给出hibernate.cfg.xml文件的内容,但内容不做过多介绍:

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-configuration PUBLIC
    	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    	
    <hibernate-configuration>
    	<session-factory>
    		<!-- 下面是三个必须要有的配置 -->
    		<!-- 配置连接MySQL数据库的基本参数 -->
    		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    		<property name="hibernate.connection.url">jdbc:mysql:///hibernate_demo01</property>
    		<property name="hibernate.connection.username">root</property>
    		<property name="hibernate.connection.password">liayun</property>
    		
    		<!-- 配置Hibernate的方言 -->
    		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    		
    		<!-- 下面两个是可选的配置哟! -->
    		<!-- 打印sql语句 -->
    		<property name="hibernate.show_sql">true</property>
    		<!-- 格式化sql语句 -->
    		<property name="hibernate.format_sql">true</property>
    		
    		<!-- 告诉Hibernate的核心配置文件加载哪个映射文件 -->
    		<mapping resource="com/meimeixia/hibernate/demo01/Customer.hbm.xml"/>
    	</session-factory>
    </hibernate-configuration>
    

    Hibernate快速入门开发测试

    在com.meimeixia.hibernate.demo01包下创建一个单元测试类——HibernateDemo1.java。

    package com.meimeixia.hibernate.demo01;
    
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    import org.junit.Test;
    
    /**
     * Hibernate的入门案例
     * @author liayun
     *
     */
    public class HibernateDemo1 {
    	
    	//保存用户的案例
    	@Test
    	public void demo1() {
    		//1. 加载Hibernate的核心配置文件
    		Configuration configuration = new Configuration().configure();
    		//如果在Hibernate的核心配置文件没有设置加载哪个映射文件,则可手动加载映射文件
    		//configuration.addResource("com/meimeixia/hibernate/demo01/Customer.hbm.xml");
    		
    		//2. 创建SessionFactory对象,类似于JDBC中的连接池
    		SessionFactory sessionFactory = configuration.buildSessionFactory();
    		
    		//3. 通过SessionFactory获取到Session对象,类似于JDBC中的Connection
    		Session session = sessionFactory.openSession();
    		
    		//4. 手动开启事务,(最好是手动开启事务)
    		Transaction transaction = session.beginTransaction();
    		
    		//5. 编写代码
    		Customer customer = new Customer();
    		customer.setCust_name("张小敬aaa");
    		
    		session.save(customer);//保存一个用户
    		
    		//6. 事务提交
    		transaction.commit();
    		
    		//7. 释放资源
    		session.close();
    		sessionFactory.close();
    	}
    	
    }
    

    测试如若都无任何问题,则我们就算入门Hibernate了。

    Hibernate执行原理总结

    可从度娘上看到如下文字:
    在这里插入图片描述
    码字不易,希望大家能够喜欢!

    展开全文
  • hibernate jar包程序文件

    万次下载 热门讨论 2014-08-05 14:44:41
    hibernate-commons-annotations-4.0.1.Final.jar hibernate-core-4.1.12.Final.jar hibernate-ehcache-4.1.12.Final.jar hibernate-entitymanager-4.1.12.Final.jar hibernate-jpa-2.0-api-1.0.1.Final.jar ...
  • Hibernate06_配置文件详解

    万次阅读 2020-08-05 12:16:06
    Hibernate06_配置文件详解 dynamic-insert=“true” 动态添加 测试: People people =new People(); people.setName("李四"); session.save(people); session.beginTransaction().commit(); session.close(); 结果...

    Hibernate06_配置文件详解

    dynamic-insert=“true” 动态添加
    dynamic-update=“true” 动态更新
    where=“id = 1” 附加查询条件
    inverse=“true” 放弃关系维护权
    cascade=“true” 设置级联操作

    dynamic-insert=“true” 动态添加

    测试:

    People people  =new People();
    people.setName("李四");
    session.save(people);
    session.beginTransaction().commit();
    session.close();
    

    结果:

    Hibernate: 
        insert 
        into
            people
            (name, money) 
        values
            (?, ?)
    

    在这里插入图片描述
    修改People.hbm.xml,设置 dynamic-insert="true"

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    		"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
    	<class name="com.blu.entity.People" table="people" dynamic-insert="true">
    		<id name="id" type="java.lang.Integer">
    			<column name="id"></column>
    			<generator class="identity"></generator>
    		</id>
    		<property name="name" type="java.lang.String">
    			<column name="name"></column>
    		</property>
    		<property name="money" type="java.lang.Double">
    			<column name="money"></column>
    		</property>
    	</class>
    
    </hibernate-mapping>
    

    再次测试的结果:

    Hibernate: 
        insert 
        into
            people
            (name) 
        values
            (?)
    

    在这里插入图片描述


    dynamic-update=“true” 动态更新

    测试:

    People people = session.get(People.class, 2);
    people.setMoney(2000.0);
    session.update(people);
    session.beginTransaction().commit();
    session.close();
    

    结果:

    Hibernate: 
        select
            people0_.id as id1_3_0_,
            people0_.name as name2_3_0_,
            people0_.money as money3_3_0_ 
        from
            people people0_ 
        where
            people0_.id=?
    Hibernate: 
        update
            people 
        set
            name=?,
            money=? 
        where
            id=?
    

    在这里插入图片描述

    修改People.hbm.xml,设置 dynamic-update="true"

    配置文件略
    

    再次测试:

    People people = session.get(People.class, 3);
    people.setMoney(3000.0);
    session.update(people);
    session.beginTransaction().commit();
    session.close();
    

    结果:

    Hibernate: 
        select
            people0_.id as id1_3_0_,
            people0_.name as name2_3_0_,
            people0_.money as money3_3_0_ 
        from
            people people0_ 
        where
            people0_.id=?
    Hibernate: 
        update
            people 
        set
            money=? 
        where
            id=?
    

    总结:使用 dynamic-insert=“true”dynamic-update=“true” 后,SQL语句被优化,执行效率提高,提升了系统性能!


    where=“id = 1” 附加查询条件

    测试

    String hql = "from People";
    Query query = session.createQuery(hql);
    List<People> list = query.list();
    for(People people : list) {
    	System.out.println(people);
    }
    session.beginTransaction().commit();
    session.close();
    

    结果:

    Hibernate: 
        select
            people0_.id as id1_3_,
            people0_.name as name2_3_,
            people0_.money as money3_3_ 
        from
            people people0_
    People(id=1, name=张三, money=1000.0)
    People(id=2, name=李四, money=2000.0)
    People(id=3, name=王五, money=3000.0)
    

    修改People.hbm.xml,设置 where="id = 1"

    配置文件略
    

    再次测试的结果:

    Hibernate: 
        select
            people0_.id as id1_3_,
            people0_.name as name2_3_,
            people0_.money as money3_3_ 
        from
            people people0_ 
        where
            (
                people0_.id = 1
            )
    People(id=1, name=张三, money=1000.0)
    

    inverse="true" 放弃关系维护权

    测试:

    Customer customer = new Customer();
    customer.setName("李四");
    		
    Orders order1 = new Orders();
    order1.setName("订单a");
    order1.setCustomer(customer);
    		
    Orders order2 = new Orders();
    order2.setName("订单b");
    order2.setCustomer(customer);
    		
    Set<Orders> orders = new HashSet<Orders>();
    orders.add(order1);
    orders.add(order2);
    customer.setOrders(orders);
    
    session.save(customer);	
    session.save(order1);
    session.save(order2);
    session.beginTransaction().commit();
    session.close();
    

    结果执行了5条SQL(如果先保存订单后保存客户,则会执行七条SQL):

    Hibernate: 
        insert 
        into
            customer
            (name) 
        values
            (?)
    Hibernate: 
        insert 
        into
            orders
            (name, cid) 
        values
            (?, ?)
    Hibernate: 
        insert 
        into
            orders
            (name, cid) 
        values
            (?, ?)
    Hibernate: 
        update
            orders 
        set
            cid=? 
        where
            id=?
    Hibernate: 
        update
            orders 
        set
            cid=? 
        where
            id=?
    

    在这里插入图片描述
    在这里插入图片描述
    原因是Customer和Orders都在维护一对多关系,所以会重复设置主外键约束关系。

    解决方法1:去掉一方维护关系的代码

    Customer customer = new Customer();
    customer.setName("李四");
    		
    Orders order1 = new Orders();
    order1.setName("订单a");
    order1.setCustomer(customer);
    		
    Orders order2 = new Orders();
    order2.setName("订单b");
    order2.setCustomer(customer);
    
    session.save(customer);
    session.save(order1);
    session.save(order2);
    session.beginTransaction().commit();
    session.close();
    

    结果:

    Hibernate: 
        insert 
        into
            customer
            (name) 
        values
            (?)
    Hibernate: 
        insert 
        into
            orders
            (name, cid) 
        values
            (?, ?)
    Hibernate: 
        insert 
        into
            orders
            (name, cid) 
        values
            (?, ?)
    

    解决方法2:通过配置 inverse="true" 让Customer放弃关系维护权

    <set name="orders" table="orders" lazy="extra" inverse="true">
    	<key column="cid"></key>
    	<one-to-many class="com.blu.entity.Orders"></one-to-many>
    </set>
    

    cascade="true" 设置级联操作

    测试:

    Customer customer = session.get(Customer.class, 10);
    session.delete(customer);
    session.beginTransaction().commit();
    session.close();
    

    删除报错,原因:外键约束
    解决方法1:先删除所有的orders,再删除customer

    Customer customer = session.get(Customer.class, 10);
    Iterator<Orders> iterator = customer.getOrders().iterator();
    while(iterator.hasNext()) {
    	session.delete(iterator.next());
    }
    session.delete(customer);
    session.beginTransaction().commit();
    session.close();
    

    结果:

    Hibernate: 
        select
            customer0_.id as id1_1_0_,
            customer0_.name as name2_1_0_ 
        from
            customer customer0_ 
        where
            customer0_.id=?
    Hibernate: 
        select
            orders0_.cid as cid3_2_0_,
            orders0_.id as id1_2_0_,
            orders0_.id as id1_2_1_,
            orders0_.name as name2_2_1_,
            orders0_.cid as cid3_2_1_ 
        from
            orders orders0_ 
        where
            orders0_.cid=?
    Hibernate: 
        delete 
        from
            orders 
        where
            id=?
    Hibernate: 
        delete 
        from
            orders 
        where
            id=?
    Hibernate: 
        delete 
        from
            customer 
        where
            id=?
    

    解决方法2: 通过配置 cascade="delete" 开启级联删除操作

    <set name="orders" table="orders" lazy="extra" inverse="true" cascade="delete">
    	<key column="cid"></key>
    	<one-to-many class="com.blu.entity.Orders"></one-to-many>
    </set>
    

    测试:

    Customer customer = session.get(Customer.class, 11);
    session.delete(customer);
    session.beginTransaction().commit();
    session.close();
    

    结果:

    Hibernate: 
        select
            customer0_.id as id1_1_0_,
            customer0_.name as name2_1_0_ 
        from
            customer customer0_ 
        where
            customer0_.id=?
    Hibernate: 
        select
            orders0_.cid as cid3_2_0_,
            orders0_.id as id1_2_0_,
            orders0_.id as id1_2_1_,
            orders0_.name as name2_2_1_,
            orders0_.cid as cid3_2_1_ 
        from
            orders orders0_ 
        where
            orders0_.cid=?
    Hibernate: 
        delete 
        from
            orders 
        where
            id=?
    Hibernate: 
        delete 
        from
            customer 
        where
            id=?
    
    展开全文
  • 由于spring对hibernate配置文件hibernate.cfg.xml的集成相当好, 所以,在项目中我一直使用spring的org.springframework.orm.hibernate.LocalSessionFactoryBean来取代hibernate.cfg.xml文件的功能 ...

    由于springhibernate配置文件hibernate.cfg.xml的集成相当好, 

    所以,在项目中我一直使用spring的org.springframework.orm.hibernate.LocalSessionFactoryBean来取代hibernate.cfg.xml文件的功能 

    LocalSessionFactoryBean有好几个属性用来查找hibernate映射文件:

    mappingResources、mappingLocations、mappingDirectoryLocations与mappingJarLocations 

    他们的区别: 

    mappingResources:指定classpath下具体映射文件名 

    <propertyname="mappingResources"> 

       <value>petclinic.hbm.xml </value> 

    </property> 

    mappingLocations:可以指定任何文件路径,并且可以指定前缀:classpath、file等 

    <propertyname="mappingLocations"> 

       <value>/WEB-INF/petclinic.hbm.xml </value> 

    </property> 


    <propertyname="mappingLocations"> 

       <value>classpath:/com/company/domain/petclinic.hbm.xml</value> 

    </property> 

    也可以用通配符指定,'*'指定一个文件(路径)名,'**'指定多个文件(路径)名,例如: 

    <propertyname="mappingLocations"> 

       <value>classpath:/com/company/domainmaps/*.hbm.xml</value> 

    </property> 

    上面的配置是在com/company/domain包下任何maps路径下的hbm.xml文件都被加载为映射文件 

     

    mappingDirectoryLocations:指定映射的文件路径 

     

    <propertyname="mappingDirectoryLocations">

     <list>

     <value>WEB-INF/HibernateMappings</value>

     </list>

    </property>

    也可以通过classpath来指出

    <propertyname="mappingDirectoryLocations">

     <list>

     <value>classpath:/XXX/package/</value>

     </list>

    </property>

     

    mappingJarLocations:指定加载的映射文件在jar文件中 

    展开全文
  • Hibernate与 MyBatis的比较

    万次阅读 多人点赞 2012-11-16 11:42:15
    最近做了一个Hibernate与MyBatis的对比总结,希望大家指出不对之处。 第一章 Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架,它出身于sf.net,现在已经成为Jboss的一部分。 Mybatis 是另外一...
  • SpringMVC+Hibernate+Spring整合实例

    千次下载 热门讨论 2013-05-31 15:49:34
    SpringMVC+Hibernate+Spring整合实例源码下载,很完整的例子,需要的可以下载源码学习
  • hibernate3.3.2官方完整版(hibernate开发)

    千次下载 热门讨论 2013-09-22 21:48:56
    hibernate3.3.2.zip,此压缩包包含hibernate-distribution-3.3.2.GA、hibernate-annotations-3.4.0.GA及slf4j-1.5.8。使用此压缩包内jar包即可进行hibernate开发。
  • Native HibernateHibernate JPA

    千次阅读 2015-12-05 00:15:39
    本文作者:苏生米沿本文地址:翻译来源:http://stackoverflow.com/questions/20820880/hibernate-native-vs-hibernate-jpaHibernate 官方网站说,有native Hibernate API和 Hibernate 的JPA实现。在这两者之间有...
  • Hibernate是非常典型的持久层框架,持久化的思想是非常值得我们学习和研究的。这篇博文,我们主要以实例的形式学习Hibernate,不深究Hibernate的思想和原理,否则,一味追求,苦学思想和原理,到最后可能什么也学...
  • J2EE进阶(十九)Nested exception: java.io.FileNotFoundException: http://hibernate.org/dtd/hibernate-mapping-3.0.dtd  在调试过程中,莫名奇妙的出现了“Nested exception:java.io.FileNotFoundException: ...
  • Hibernate和MyBatis的区别

    万次阅读 多人点赞 2018-12-31 23:32:21
    摘抄自:《javaEE互联网轻量级框架整合开发》 ...无论MyBatis或Hibernate都可以称为ORM框架,Hibernate的设计理念是完全面向POJO的,而MyBatis不是。 Hibernate基本不再需要编写SQL就可以通过映射关系来操作...
  • Hibernate框架基础——Hibernate入门

    万次阅读 多人点赞 2016-10-04 12:01:58
    Hibernate入门Hibernate介绍Hibernate是一个基于jdbc的开源的持久化框架,是一个优秀的ORM实现,它很大程度的简化了dao层编码工作。Hibernate对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码...
  • Hibernate-1.Hibernate概述

    万次阅读 2018-01-04 12:02:28
    1.1什么是Hibernate 纯面向对象的方式来操作数据库 HQL SQL 1.Hibernate是轻量级JavaEE应用的持久层解决方案,是一个关系数据库ORM框架 a)ORM 就是通过将Java对象映射到数据库表,通过操作Java对象,就可以完成...
  • Hibernate入门第三讲——Hibernate的常见配置

    万次阅读 多人点赞 2019-08-05 08:34:30
    在《Hibernate快速入门》一文中,我有讲到Hibernate的两个配置文件,今天就来详细地介绍这两个配置文件。Hibernate的配置详解在Hibernate中,我们使用时主要有两种配置文件: 核心配置文件——hibernate.cfg.xml...
  • Hibernate 框架入门

    万次阅读 多人点赞 2018-08-01 10:44:04
    一、Hibernate框架介绍 什么是Hibernate 我们可以从度娘上摘抄这样有关Hibernate的介绍: Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系...
  • 如何从 Hibernate官网下载 Hibernate原码 和Hibernatetools? 浏览器中输入HIbernate官网 http://hibernate.org/  1. 下载原码? 点击  Hibernate ORM 上的more进入    重新排序后 终于看到了...
  • HibernateHibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java...
  • Hibernate框架基础——Hibernate API及Hibernate主配置文件

    千次阅读 多人点赞 2016-10-05 16:32:24
    Hibernate的学习路线图Hibernate API简介ConfigurationConfiguration类负责管理Hibernate的配置信息,包括如下内容: Hibernate运行的底层信息:数据库的URL、用户名、密码、JDBC驱动类,数据库Dialect,数据库连接...
  • 理解hibernate hibernate工作原理

    千次阅读 2017-09-18 22:47:15
    Hibernate是一个开放源代码的对象关系映射框架。  Hibernate对JDBC进行了非常轻量级的对象封装,它将POJO(Plain Ordinary Java Object:简单的java对象,实际就是普通JavaBeans)与数据库表建立映射关系,是一个...
  • hibernate约束

    千次阅读 2018-01-05 17:06:37
    hibernate.cfg.xml <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> com.mysql.jdbc.Dr
  • Hibernate-2.Hibernate快速入门

    万次阅读 2018-01-04 12:25:15
    2.1开发步骤 2.1.1创建数据库和表 2.1.2创建对应实体类 2.1.3导入Hibernate的jar包 1.外层的hibernate3.jar hibernate3.jar 2.lib\required 里面的所有jar包 antlr-2.7.6.jar
  • hibernate 参数一览

    千次阅读 2018-09-05 14:40:16
    实现包含了Hibernate与数据库的基本连接信息的配置方式有两种方式: 第一种是使用hibernate.properties文件作为配置文件。 第二种是使用hibernate.cfg.xml文件作为配置文件。 hibernate.cfg.xml 例子 &lt;?...
  • Hibernate配制项之hibernate.show_sql, hibernate.show_sql和hibernate.use_sql_comments 前言 在本地开发时,我们经常有查看执行的SQL语句的需求。 本次介绍输出和统计SQL语句相关的三个配制项。 本文测试...
  • 命名:hibernate.cfg.xml 案例: <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> &...
  • org.hibernate.HibernateException: /hibernate.cfg.xml not found 备注: 此处hibernate版本号:3.6.10.Final 2、分析原因 一下是hibernate创建session工厂的示例代码: private static Configuration ...
  • Hibernate概述

    万次阅读 2018-04-30 22:16:10
    Hibernate概述Hibernate是流行的ORM(ObjectRelational Mapping,对象关系映射)框架解决方案。ORM框架为了将针对关系型数据的操作转换成对象操作,需要实现关系数据到对象的映射,这种映射关系通常写在ORM框架的...
  • 最新版本的Struts2+Spring4+Hibernate4框架整合

    千次下载 热门讨论 2014-10-15 14:39:34
    项目原型:Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6 二、 项目目的: 整合使用最新版本的三大框架(即Struts2、Spring4和Hibernate4),搭建项目架构原型。 项目架构原型:Struts2.3.16 + Spring4.1.1 + ...
  • Hibernate核心配置文件  我们先来看一个比较常见的hibernate.cfg.xml配置文件: <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" ...
  • Hibernatehibernate-mapping配置文件

    千次阅读 2017-09-14 23:10:40
    Hibernatehibernate-mapping配置文件需要在对应工程中建立类,同时修改相应的package路径,<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 233,684
精华内容 93,473
关键字:

hibernate