hibernate_hibernateutil - CSDN
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] 
收起全文
精华内容
参与话题
  • 【SSH进阶之路】Hibernate基本原理(一)

    万次阅读 多人点赞 2014-11-20 21:02:35
    在开始学Hibernate之前,一直就有人说:Hibernate并不难,无非是对JDBC进一步封装。一句不难,难道是真的不难还是眼高手低?  如果只是停留在使用的层面上,我相信什么技术都不难,看看别人怎么做的,你也可以很快...

          在开始学Hibernate之前,一直就有人说:Hibernate并不难,无非是对JDBC进一步封装。一句不难,难道是真的不难还是眼高手低?

          如果只是停留在使用的层面上,我相信什么技术都不难,看看别人怎么做的,你也可以很快上手。

          这难道是学习的最终目的吗?

          不是,绝对不是。我们需要了解这门技术的基本概念,它到底是什么,它是干什么的,它有什么优缺点。下面我就带领大家一起回顾一下Hibernate:


    什么是Hibernate?


          Hibernate,翻译过来是冬眠的意思,正好现在已经进入秋季,世间万物开始准备冬眠了。其实对于对象来说就是持久化。

     

    扫盲--------------------------------------------------------------------------------------------------------

          持久化(Persistence),即把数据(如内存中的对象)保存到可永久保存的存储设备中(如磁盘)。持久化的主要应用是将内存中的对象存储在关系型的数据库中,当然也可以存储在磁盘文件中、XML数据文件中等等。

     

    持久化是将程序数据在持久状态和瞬时状态间转换的机制。
     

    JDBC就是一种持久化机制。文件IO也是一种持久化机制。
     

    日常持久化的方法:
    1、将鲜肉冷藏,吃的时候再解冻的方法也是。
    2、将水果做成罐头的方法也是。

    结束----------------------------------------------------------------------------------------------------------

      

    我们从三个角度理解一下Hibernate:

     

    一、Hibernate是对JDBC进一步封装

           原来没有使用Hiberante做持久层开发时,存在很多冗余,如:各种JDBC语句,connection的管理,所以出现了Hibernate把JDBC封装了一下,我们不用操作数据,直接操作它就行了。
     

    二、我们再从分层的角度来看

           我们知道非常典型的三层架构:表示层,业务层,还有持久层。Hiberante也是持久层的框架,而且持久层的框架还有很多,比如:IBatis,Nhibernate,JDO,OJB,EJB等等。

     

    三、Hibernate是开源的一个ORM(对象关系映射框架

          ORM,即Object-Relational Mapping,它的作用就是在关系型数据库和对象之间做了一个映射。从对象(Object)映射到关系(Relation),再从关系映射到对象。这样,我们在操作数据库的时候,不需要再去和复杂SQL打交道,只要像操作对象一样操作它就可以了(把关系数据库的字段在内存中映射成对象的属性)。

     

    Hibernate的核心:

     

                     

     

         从上图中,我们可以看出Hibernate六大核心接口,两个主要配置文件,以及他们直接的关系。Hibernate的所有内容都在这了。那我们从上到下简单的认识一下,每个接口进行一句话总结。

    1、Configuration接口:负责配置并启动Hibernate

    2、SessionFactory接口:负责初始化Hibernate

    3、Session接口:负责持久化对象的CRUD操作

    4、Transaction接口:负责事务

    5、Query接口和Criteria接口:负责执行各种数据库查询

     

    注意:Configuration实例是一个启动期间的对象,一旦SessionFactory创建完成它就被丢弃了。

     

    Hibernate的优/缺点:

     

    优点:

    1、更加对象化

          以对象化的思维操作数据库,我们只需要操作对象就可以了,开发更加对象化。

    2、移植性
          因为Hibernate做了持久层的封装,你就不知道数据库,你写的所有的代码都具有可复用性。

    3、Hibernate是一个没有侵入性的框架,没有侵入性的框架我们称为轻量级框架。

          对比Struts的Action和ActionForm,都需要继承,离不开Struts。Hibernate不需要继承任何类,不需要实现任何接口。这样的对象叫POJO对象。

    4、Hibernate代码测试方便。

    5、提高效率,提高生产力。

     

    缺点:

    1、使用数据库特性的语句,将很难调优

    2、对大批量数据更新存在问题

    3、系统中存在大量的攻击查询功能

     
    总结:

     

          Hibernate可以使我们采用对象化的思维操作关系型数据库。这篇博文最主要的目的是从整体上认识Hibernate,内容可能会有点空,不是特别详细,但是后面会有更加针对性的博文进行讲解。敬请期待。

     

     

    展开全文
  • Hibernate入门教程(一)

    千次阅读 2018-06-19 09:12:26
    讲师:钟昕灵,叩丁狼教育高级讲师。原创文章,转载请注明出处。框架的介绍什么是框架?框架其实就是一个半成品,为某一领域提供解决方案,我们可以在这个基础之上继续开发,完成实际的业务需求三层架构在实际开发中,...

    讲师:钟昕灵,叩丁狼教育高级讲师。原创文章,转载请注明出处。

    框架的介绍

    什么是框架?

    框架其实就是一个半成品,为某一领域提供解决方案,我们可以在这个基础之上继续开发,完成实际的业务需求

    三层架构

    在实际开发中,为了项目的可维护性和可拓展性,我们往往将项目按照功能性分为三层:

    • 表现层:主要对用户的请求接受,以及数据的返回,为客户端提供应用程序的访问;代表框架:Struts2/SpringMVC
    • 业务层:负责业务逻辑运算,处于表现层和持久层之间;代表框架:Spring
    • 持久层:负责与数据库或者存储设备的交互,如,对数据的CRUD,代码框架:Hibernate/MyBatis
      hibernate(冬眠)简介
      Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任—-百度百科

    通过以上的介绍,相信大家对hibernate框架相关的基本概念有了一定的认识和了解,那么,接下来,我们就开始学习hibernate吧!

    环境搭建及相关准备

    • JDK版本: 1.8
    • hibernate版本: 5.2.13
    • 开发工具(IDE): STS(Spring Tool Suite)

    hibernate中的文件介绍:

    • documentation: hibernate相关的文档资源,如API,参考手册等
    • lib: 该文件夹存放Hibernate框架的核心类库以及Hibernate的第三方类库。该文件夹下的required子目录存放运行Hibernate项目的必须的核心类库
    • project: hibernate中各个项目的源代码

    所以,在开发hibernate应用之前,首先在项目中导入lib/required/目录中的jar包
    必需的jar包

    使用hibernate实现数据的增删改操作

    数据准备

    • 创建user表和实体类User
      CREATE TABLE `user` (
      `id` bigint(20) NOT NULL AUTO_INCREMENT,
      `username` varchar(20) DEFAULT NULL,
      `password` varchar(50) DEFAULT NULL,
      `age` tinyint(4) DEFAULT NULL,
      `hiredate` date DEFAULT NULL,
      PRIMARY KEY (`id`)
      ) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
      
      ```
      //lombok插件中的注解:自动生成getter/setter方法
      @Getter@Setter
      public class User {
      private Long uid;
      private String uusername;
      private String upassword;
      private Integer uage;
      private Date uhiredate;
      }
    注:刻意使列名和属性名不一致,期待hibernate帮我们解决这个问题
    -  hibernate.cfg.xml
    hibernate的主配置文件,可以在该配置文件中配置连接数据库的基本信息
    在项目中创建一个[source folder],命名为resources
    从hibernate的project/etc目录中拷贝hibernate.cfg.xml,然后做如下配置
    

    <!DOCTYPE hibernate-configuration PUBLIC
    “-//Hibernate/Hibernate Configuration DTD 3.0//EN”
    http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    <!-- hibernate的主配置文件 -->

    <hibernate-configuration>
    <session-factory>
    <!-- 连接数据库的基本信息 -->
    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="connection.url">jdbc:mysql:///hibernate</property>
    <property name="connection.username">root</property>
    <property name="connection.password">admin</property>
    <!-- 在控制台中显示执行的sql -->
    <property name="show_sql">true</property>
    <!-- 关联映射文件 -->
    <mapping resource="cn/wolfcode/_01_hello/User.hbm.xml" />
    </session-factory>
    </hibernate-configuration>

    - User.hbm.xml
    实现数据库中的表和Java中的类的映射
    

    <?xml version=”1.0”?>
    <!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="cn.wolfcode._01_hello.User" table="user">
    <id name="uid" column="id">
    <generator class="native" />
    </id>
    <property name="uusername" column="username" />
    <property name="upassword" column="password" />
    <property name="uage" column="age" />
    <property name="uhiredate" column="hiredate" />
    </class>
    </hibernate-mapping>

    以上是使用hibernate实现CRUD的基本准备,那么接下来我们来测试一下
    创建一个DAO接口及其实现类:在实现类中使用hibernate相关API实现数据的增删改操作
    

    package cn.wolfcode._01_hello;

    public interface IUserDAO {
    void save(User u);

    void delete(User u);
    
    void update(User u);
    

    }

    保存数据:session.save(Object object);
    

    package cn.wolfcode._01_hello;
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    public class UserDAOImpl implements IUserDAO {
    @Override
    public void save(User u) {
    // 创建hibernate的配置对象
    Configuration conf = new Configuration();
    // 加载hibernate的配置文件
    conf.configure(“/hibernate.cfg.xml”);
    // 创建SessionFactory对象:可理解为一个连接池对象
    SessionFactory factory = conf.buildSessionFactory();
    // 创建Session对象:可理解为一个连接对象
    Session session = factory.openSession();
    // 获取事务管理对象
    Transaction transaction = session.getTransaction();
    // 开启事务
    transaction.begin();
    // 调用session的save方法完成数据的保存操作
    session.save(u);
    // 提交事务
    transaction.commit();
    // 释放资源
    session.close();
    }
    }

    在测试类中测试dao中的save方法
    

    package cn.wolfcode._01_hello;
    import java.util.Date;
    import org.junit.Test;
    public class UserDAOImplTest {
    private IUserDAO dao = new UserDAOImpl();
    @Test
    public void testSave() {
    User u = new User();
    u.setUage(10);
    u.setUusername(“admin”);
    u.setUpassword(“123456”);
    u.setUhiredate(new Date());
    dao.save(u);
    }
    }

    执行SQL
    

    Hibernate: insert into user (username, password, age, hiredate) values (?, ?, ?, ?)

    在完成数据的保存之后,我们可以使用相同的方式实现数据的删除和修改操作,如下
    
    删除数据: session.delete(Object object);
    

    public void delete(User u) {
    // 创建hibernate的配置对象
    Configuration conf = new Configuration();
    // 加载hibernate的配置文件
    conf.configure(“/hibernate.cfg.xml”);
    // 创建SessionFactory对象:可理解为一个连接池对象
    SessionFactory factory = conf.buildSessionFactory();
    // 创建Session对象:可理解为一个连接对象
    Session session = factory.openSession();
    // 获取事务管理对象
    Transaction transaction = session.getTransaction();
    // 开启事务
    transaction.begin();
    // 调用session的delete方法完成数据的删除操作
    session.delete(u);
    // 提交事务
    transaction.commit();
    // 释放资源
    session.close();
    }

    执行SQL
    

    Hibernate: delete from user where id=?

    修改数据: session.update(Object object);
    

    public void update(User u) {
    // 创建hibernate的配置对象
    Configuration conf = new Configuration();
    // 加载hibernate的配置文件
    conf.configure(“/hibernate.cfg.xml”);
    // 创建SessionFactory对象:可理解为一个连接池对象
    SessionFactory factory = conf.buildSessionFactory();
    // 创建Session对象:可理解为一个连接对象
    Session session = factory.openSession();
    // 获取事务管理对象
    Transaction transaction = session.getTransaction();
    // 开启事务
    transaction.begin();
    // 调用session的delete方法完成数据的删除操作
    session.update(u);
    // 提交事务
    transaction.commit();
    // 释放资源
    session.close();
    }

    执行SQL
    

    Hibernate: update user set username=?, password=?, age=?, hiredate=? where id=?

    
    ####查询数据: 
    查询单条数据:session.get(Class<T> type, Serializable id)
    数据查询可以脱离事务执行
    

    public User get(long id) {
    // 创建hibernate的配置对象
    Configuration conf = new Configuration();
    // 加载hibernate的配置文件
    conf.configure(“/hibernate.cfg.xml”);
    // 创建SessionFactory对象:可理解为一个连接池对象
    SessionFactory factory = conf.buildSessionFactory();
    // 创建Session对象:可理解为一个连接对象
    Session session = factory.openSession();
    // 调用session的delete方法完成数据的删除操作
    User user = session.get(User.class, id);
    // 释放资源
    session.close();
    return user;
    }

    执行sql
    

    Hibernate:
    select
    user0.id as id1_0_0, user0.username as username2_0_0, user0.password
    as password3_0_0
    , user0.age as age4_0_0, user0.hiredate as hiredate5_0_0
    from
    user user0
    where
    user0
    .id=?

    查询多条数据:session.createQuery(String hql);
    

    public List<User> list() {
    // 创建hibernate的配置对象
    Configuration conf = new Configuration();
    // 加载hibernate的配置文件
    conf.configure(“/hibernate.cfg.xml”);
    // 创建SessionFactory对象:可理解为一个连接池对象
    SessionFactory factory = conf.buildSessionFactory();
    // 创建Session对象:可理解为一个连接对象
    Session session = factory.openSession();
    // 调用session的delete方法完成数据的删除操作
    List<User> list = session.createQuery(“FROM User”).list();
    // 释放资源
    session.close();
    return list;
    }

    执行SQL
    

    Hibernate:
    select
    user0.id as id1_0, user0.username as username2_0, user0.password
    as password3_0
    , user0.age as age4_0, user0.hiredate as hiredate5_0
    from
    user user0_
    ```

    小结

    以上,我们使用Hibernate相关的API实现了数据的基本CRUD操作,下面我们小结一下基本的开发流程,在下一节中我们再来分析Hibernate的执行流程

    1. 创建表以及实体类
    2. 导入hibernate应用必须的jar包
    3. 编写配置文件:hibernate.cfg.xml / user.hbm.xml
    4. 在dao中实现数据的保存操作
      // 创建hibernate的配置对象
      // 加载hibernate的配置文件
      // 创建SessionFactory对象:可理解为一个连接池对象
      // 创建Session对象:可理解为一个连接对象
      // 获取事务管理对象
      // 开启事务
      // 调用session的delete方法完成数据的删除操作
      // 提交事务
      // 释放资源

    1. 完成各个测试

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

    万次阅读 多人点赞 2019-09-03 20:07:18
    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

    千次阅读 2019-09-26 09:29:42
    Hibernate 概念 Hibernate 是一个开放源代码的对象关系映射框架,它对 JDBC 进行了非常轻量级的对象封装,它将 pojo 与数据库表建立映射关系,是一个全自动的 ORM(Object - Relationship - Mapping)框架,...

    Hibernate 概念

    • Hibernate 是一个开放源代码的对象关系映射框架,它对 JDBC 进行了非常轻量级的对象封装,它将 pojo 与数据库表建立映射关系,是一个全自动的 ORM(Object - Relationship - Mapping)框架,Hibernate 可以自动生成 SQL 语句,自动执行,使得 Java 程序员可以随心所欲的使用对象编程思维来操纵数据库。
    • Hibernate 可以应用在任何使用 JDBC 的场合。
    • Gavin King 他是 Hibernate 的创始人,也是那本经典的 Hibernate in action 的作者。
    • Hibernate 原本是 JBOSS 旗下的产品,2006 年 JBOSS 被 RED HAT 收购,变成了红帽公司的产品。

    ORM / JPA / Hibernate 概念与关系

    • ORM(Object - Relationship - Mapping)即对象关系映射,他是一种思想,他的实质就是将关系数据库中的业务数据用对象的形式表示出来,并通过面向对象的方式将这些对象组织出来,实现系统的业务逻辑。说到底就是 Java 实体对象跟数据库数据的映射关系。
    • JPA(Java - Persistence - API)是 Java EE 关于 ORM 思想的标准接口,仅仅是一套规范和接口,不是实现。
    • Hibernate 就是实现这一规范和接口的 ORM 组件。

    Hibernate 工作原理

    这里写图片描述

    应用程序操作 Hibernate 对外提供的接口,API 其实底层还是调用的 JDBC,然后 JDBC 再去访问的数据库。

    关注我的微信公众号(曲健磊的个人随笔),观看更多精彩内容:
    在这里插入图片描述

    展开全文
  • Hibernate最全面试题

    万次阅读 多人点赞 2018-09-08 16:53:03
    Hibernate工作原理及为什么要用? Hibernate工作原理及为什么要用? 读取并解析配置文件 读取并解析映射信息,创建SessionFactory 打开Sesssion 创建事务Transation 持久化操作 提交事务 关闭Session ...
  • Hibernate 框架入门

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

    千次阅读 2018-09-29 13:57:13
    1.什么是ORM    ORM的全称是Object Relational Mapping,即对象关系映射。它的实现思想就是将关系数据库中表的数据映射成为对象,以对象的形式展现,这样开发人员就可以把对数据库的操作转化... 对于Hibernate...
  • hibernate基础

    2016-09-08 19:39:50
    一, 第一个hibernate程序 1, 导入包 2, 编写实体类 实体类可序列化 都用引用类型进行映射 无参的构建函数   3, 写映射文件  实体类跟表的映射 主键映射   指定映射的表的列名称  主键生成策略 ...
  • hibernate是一种ORM框架(全称为Object-Relative Database-Mapping,在java对象与数据库之间建立某种映射,以实现直接存取java对象(一般为POJO)),与各种数据库,SQL语句打交道,是数据持久化的一种解决方案。...
  • Hibernate中的数据库方言(Dialect)

    万次阅读 多人点赞 2013-05-09 12:51:00
    在配置hibernate.cfg.xml时需指定使用数据库的方言: 例: property name="dialect">org.hibernate.dialect.MySQL5Dialectproperty> 以下是各数据库对应的方言(Dialect): 数据库 方言...
  • hibernate完整jar包下载

    万次阅读 2015-06-05 20:57:50
    hibernate完整jar包下载
  • hibernate4与hibernate5的一些区别

    万次阅读 2016-07-12 17:58:55
     hibernate4:private static Configuration configuration = null; private static SessionFactory sessionFactory = null; private static ServiceRegistry serviceRegistry = null; public s
  • 数据库属性hibernate.dialect的设置

    万次阅读 2016-11-24 22:39:56
    数据库属性hibernate.dialect设置正确的 org.hibernate.dialect.Dialect子类.  如果指定一种方言, Hibernate将为上面列出的一些属性使用合理的默认值.  Hibernate SQL方言 (hibernate.dialect) ...
  • hibernate 注解字段默认值

    万次阅读 2013-10-19 12:36:50
    hibernate 注解字段默认值的设置:    @Column(name="ISPUBLIC" ,nullable=false,columnDefinition="INT default 0") private int isPublic;   注意字段的类型必须指定,因为hibernate 会把columnDefinition
  • Hibernate properties详解

    万次阅读 2012-02-08 00:22:45
    关键字:Hibernate properties详解 Hibernate properties Hibernate配置属性 属性名 用途 hibernate.dialect ;一个Hibernate Dialect类名允许Hibernate针对特定的关系数据库生成优化的SQL. 取值 full....
  • javax.servlet.ServletException: org.springframework.transaction.CannotCreateTransactionException: Could not open Hibernate Session for transaction; nested exception is org.hibernate.TransactionEx
  • mybatis与hibernate的对比

    万次阅读 2018-03-28 15:38:37
    相同点:(1)Hibernate与MyBatis都是通过SessionFactoryBuider由XML配置文件生成SessionFactory,由SessionFactory 生成Session,由Session来开启执行事务和SQL(Structured Query Language,结构化查询语言)语句。...
  • hibernate配置文件hibernate.cfg.xml的详细解释

    万次阅读 多人点赞 2013-07-24 22:19:57
    <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  • hibernate配置文件中添加 log4j.properties中添加 log4j.logger.org.hibernate.type.descriptor.sql.BasicBinder=TRACE log4j.logger.org.hibernate.type.descriptor.sql.BasicExtractor=TRACE ...
  • Hibernate5最新教程

    千次阅读 2018-03-24 22:53:10
    Hibernate框架是当今主流的Java持久层框架之一,由于它具有简单易学、灵活性强、扩展性强等特点,能够大大地简化程序的代码量,提高工作效率,因此受到广大开发人员的喜爱。教程软件版本说明:1)Hibernate框架:...
1 2 3 4 5 ... 20
收藏数 433,228
精华内容 173,291
关键字:

hibernate