持久层ORM框架Hibernate框架的使用及搭建方式

目录
  • 前言
  • 一、Hibernate的优点?
  • 二、Hibernate的缺点
  • 三、搭建Hibernate项目架构
  • 四、Hibernate核心接口的介绍
  • 五、封装Hibernate的工具类
  • 六、常用的CRUD操作
  • 七、主键生成机制
  • 八、Hibernate的类型
  • 总结

前言

hibernate的概念
hibernate是一个ormapping框架(ORM框架,全自动ORM框架)
hibernate是一个数据库的操作框架即持久层框架
Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库(SQL语句由Hibernate根据对象自动生成)。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用.。

提示:以下是本篇文章正文内容,下面案例可供参考

一、Hibernate的优点?

1、Hibernate的代码是比较简单的。
2、Hibernate是面向对象的操作。
3、Hibernate的数据库移动植性很强。
4、Hibernate的缓存是世界级的。

二、Hibernate的缺点

1、不能干预sql语句的生成所以如果一个项目中,如果对sql语句的优化要求比较高,那么不适合用hibernate
2、如果一张表中有千万级别的数据量,也不适合用hibernate(因为缓存机制,它会将大量数据放入缓存)
3、hibernate适合用中小型企业开发软件
4、hibernate不适合处理复杂SQL。

三、搭建Hibernate项目架构

项目目录

1、第一步导包

2、第二步编写Hibernate的配置文件

我用的是Mysql数据库,你要是用别的把数据源驱动信息改一下即可。

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <!--创建数据源-->
    <session-factory>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://127.0.0.1:3306/MySql</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <!-- SQL 方言 -->
        <property name="dialect">org.hibernate.dialect.OracleDialect</property>

        <!-- 是否显示SQL -->
        <property name="show_sql">true</property>
        <!-- 实现格式化的sql -->
        <property name="format_sql">true</property>

        <!-- 是否自动生成对象
     create 表示每次都重新建立所需对象
     update表示如果有就直接使用,如果修改则更新,如果没有则创建
     <property name="hbm2ddl.auto">update</property>
     -->
        <!--配置hibernate映射文件  -->
         <!--配置映射文件-->
        <mapping resource="com/zrrd/mapper/Dept.hbm.xml"></mapping>
    </session-factory>
</hibernate-configuration>

关于方言可以参考下面的图片,根据项目需求配置即可。

3、第三步:编写持久化类(pojo类)

package com.zrrd.vo;

public class Dept {
    private Integer deptno;
    private String dname;
    private String loc;

    public Integer getDeptno() {
        return deptno;
    }

    public void setDeptno(Integer deptno) {
        this.deptno = deptno;
    }

    public String getDname() {
        return dname;
    }

    public void setDname(String dname) {
        this.dname = dname;
    }

    public String getLoc() {
        return loc;
    }

    public void setLoc(String loc) {
        this.loc = loc;
    }
    //直接转换,看着方便
    @Override
    public String toString() {
        return "Dept{" +
                "deptno=" + deptno +
                ", dname='" + dname + '\'' +
                ", loc='" + loc + '\'' +
                '}';
    }

    public Dept() {
        super();
    }

    public Dept(Integer deptno, String dname, String loc) {
        this.deptno = deptno;
        this.dname = dname;
        this.loc = loc;
    }
}

4、第四步:编写Hibernate映射文件(*.hbm.xml)

该文件完成 持久化类和数据库中指定表的映射。说白了就是说明持久化类对应数据库中的哪张表,类中的每个属性都对应数据库中的那些字段。

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- package="com.javashidai.hibernate001.domain" 指明持久化类所在的包 -->
<hibernate-mapping package="com.zrrd.vo">
	<!-- name="Dept" 表示类名 table="dept" 对应的表名 -->
	<class name="Dept" table="dept" >
		<!-- 指明主键对应的属性和字段
		 name="deptno" 表示持久化类中的deptno对应主键字段
		 column="deptno"表示是主键字段
		 -->
		<id name="deptno" column="deptno">
		   <!-- 主键生成策略 :序列 -->
			<generator class="sequence">
				<!-- 指明所需的序列名 -->
				<param name="sequence">SEQ_DEPT</param>
			</generator>
		</id>
		<!-- property指明非主键列
		 name="dname"表示持久化类中的属性名
		 length="14"指明数据库中对应字段接收的长度
		 column="dname" 指明对应数据库中的什么字段
		 type="string" 对应的数据类型
		  -->
		<property name="dname" 	length="14"	column="dname" type="string"/>
		<property name="loc" length="13"	column="loc" type="string"/>
	</class>

</hibernate-mapping>

5、第五步:编写测试类完成对数据库的操作

package com.zrrd.text;

import com.zrrd.vo.Dept;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class Text {
    public static void main(String[] args){
        //读取Hibernate.cfg.xml配置文件
        Configuration configuration=new Configuration();
        configuration.configure("hibernate.cfg.xml");
        //创建sessionfactory工程
        SessionFactory sessionFactory=configuration.buildSessionFactory();
        //创建Session对象
        Session session=sessionFactory.openSession();
        //创建实体对象(与数据库中表对应的vo对象为实体对象,进而操作数据库(由Hibernate自动创建SQL语句)
        Dept dept=session.get(Dept.class,1);
        System.out.println(dept);

        session.close();
        sessionFactory.close();
    }
}

执行结果图

数据库存的数据

四、Hibernate核心接口的介绍

Hibernate的核心接口一共有6个,分别为:Session、SessionFactory、
Transaction、Query、Criteria和Configuration。这6个核心接口在任何开发中都会用到。通过这些接口,不仅可以对持久化对象进行存取,还能够进行事务控制。

1.Session

Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流,包含了很多常见的SQL语句。)。但需要注意的是Session对象是非线程安全的。同时,Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时,其实指的是Hibernate中的session,而以后会将HttpSession对象称为用户session。

2.SessionFactory

SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理,并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的,因为一般情况下,一个项目通常只需要一个SessionFactory就够,当需要操作多个数据库时,可以为每个数据库指定一个SessionFactory。

3.Transaction

Transaction 接口是一个可选的API,可以选择不使用这个接口,取而代之的是Hibernate 的设计者自己写的底层事务处理代码。 Transaction 接口是对实际事务实现的一个抽象,这些实现包括JDBC的事务、JTA 中的UserTransaction、甚至可以是CORBA 事务。之所以这样设计是能让开发者能够使用一个统一事务的操作界面,使得自己的项目可以在不同的环境和容器之间方便地移植。

4.Query

Query接口让你方便地对数据库及持久对象进行查询,它可以有两种表达方式:HQL语言或本地数据库的SQL语句。Query经常被用来绑定查询参数、限制查询记录数量,并最终执行查询操作。

5.Criteria

Criteria接口与Query接口非常类似,允许创建并执行面向对象的标准化查询。值得注意的是Criteria接口也是轻量级的,它不能在Session之外使用。

6.Configuration

Configuration 接口的作用是对Hibernate 进行配置,以及对它进行启动。在Hibernate 的启动过程中,Configuration 类的实例首先定位映射文档的位置,读取这些配置,然后创建一个SessionFactory对象。虽然Configuration 接口在整个Hibernate 项目中只扮演着一个很小的角色,但它是启动hibernate 时所遇到的第一个对象。

五、封装Hibernate的工具类

当然我们在实际开发的项目当中肯定不会CRUD的时候都去写测试类里面的代码,这样会导致项目代码量巨大而且可移植性太差,所以我们要封装一下写一个工具类,用的时候直接调用即可。

public class HibernateUtil {
	//一个Hibernate容器中只需要一个SessionFactory
	private static SessionFactory sessionFactory;
	//利用静态代码框创建SessionFactory对象
	static
	{
		//创建Configuration对象
		Configuration conf = new Configuration();
		//加载Hibernate配置文件
		conf.configure();//默认加载src下的hibernate.cfg.xml
		//创建SessionFactory对象
		sessionFactory  = conf.buildSessionFactory();
	}
	//得到Session对象
	public static Session getSession()
	{
		return sessionFactory.openSession();
	}
}

六、常用的CRUD操作

我都已经写好啦相关执行的方法,你只要改改返回的类型就可以啦,就像Jpa框架那样,直接在你的项目中使用就可以啦。不用太感谢我,为人民服务!

1.根据主键查询对象

public Dept selectOne(int deptno)
	{
		Dept dept= null;
		//得到session对象
		Session session = null;
		try
		{
			//得到Session对象
			session = HibernateUtil.getSession();
			//根据主键得到对应的信息
			dept = (Dept) session.get(Dept.class, deptno);
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(session != null)
			{
				session.close();
			}
		}
		return dept;
	}

2.查询全部的信息

public static List<Dept> queryDept()
	{
		List<Dept> deptList = null;
		//声明session
		Session session = null;
		try
		{
			//创建Session对象
			session= HibernateUtil.getSession();
			//声明HQL  :其中Dept为实体类
			String hql="from Dept ";//from后写的是类名
			//得到Query对象
			Query query = session.createQuery(hql);
			//执行查询
			deptList = query.list();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(session != null)
			{
				session.close();
			}
		}
		return deptList;
	}

3.条件查询

public List<Dept> queryDeptByLoc(String loc)
	{

		List<Dept> deptList = null;
		//声明session
		Session session = null;
		try
		{
			//创建Session对象
			session= HibernateUtil.getSession();
			//声明HQL  :其中Dept为实体类
			String hql="from com.zrrd.vo.Dept where loc=:loc ";//:loc表示是参数
			//得到query对象
			Query query =  session.createQuery(hql);
			//给参数赋值
			query.setString("loc", loc);//给指定参数赋值
			//查询返回List<Dept>
			deptList = query.list();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(session != null)
			{
				session.close();
			}
		}
		return deptList;
	}

4.根据主键删除

public void deleteDept(int deptno)
	{
		//声明Session对象
		Session session = null;
		try
		{
			//得到Session对象
			session = HibernateUtil.getSession();
			//开启事务保护
			Transaction  ta = session.beginTransaction();
			//根据id得到对应的值
			Dept deleteObj = (Dept) session.get(Dept.class, deptno);
			//删除该对应
			session.delete(deleteObj);
			//提交事务
			ta.commit();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(session != null)
			{
				session.close();
			}
		}
	}

5.根据指定条件删除

/**
	 * 利用Hql进行删除
	 * 根据部门编号进行删除
	 */
	public int deleteDeptByLoc(String loc)
	{
		int result =0;
		//声明Session对象
		Session session = null;
		try
		{
			//得到Session对象
			session = HibernateUtil.getSession();
			//开启事务保护
			Transaction  ta = session.beginTransaction();
			//编写删除使用的HQL 这里的:loc表示参数名
			String hql="delete com.zrrd.vo.Dept where loc=:loc";
			//得到Query对象
			Query query =session.createQuery(hql);
			//给参数赋值
			query.setString("loc", loc);
			//执行DML语句
			result = query.executeUpdate();
			//提交事务
			ta.commit();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(session != null)
			{
				session.close();
			}
		}
		return result;
	}

6.修改单个对象

public static void updateDept(Dept dept)
	{
		//声明Session对象
		Session session = null;
		try
		{
			//得到Session对象
			session = HibernateUtil.getSession();
			//开启事务保护
			Transaction  ta = session.beginTransaction();
			//根据持久化对象进行修改
			session.update(dept);
			//提交事务
			ta.commit();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(session != null)
			{
				session.close();
			}
		}
	}

7.根据条件进行修改(HQL)

public static int updateDeptLoc(String oldLoc,String newLoc)
	{
int result =0;
		//声明Session对象
		Session session = null;
		try
		{
			//得到Session对象
			session = HibernateUtil.getSession();
			//开启事务保护
			Transaction  ta = session.beginTransaction();
			//编写删除使用的HQL 这里的:loc表示参数名
			String hql="update Dept set loc=:newLoc where loc=:oldLoc";
			//得到Query对象
			Query query =session.createQuery(hql);
			//给参数赋值
			query.setString("newLoc", newLoc);
			query.setString("oldLoc", oldLoc);
			//执行DML语句
			result = query.executeUpdate();
			//提交事务
			ta.commit();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(session != null)
			{
				session.close();
			}
		}
		return result;
	}

8.将对象存入数据库

	public static void saveDept(Dept dept)
	{
		Session session = null;
		try
		{
			//得到Session对象
			session = HibernateUtil.getSession();
			//得到事务对象
			Transaction ta = session.beginTransaction();
			//将持久化对象存入 数据库
			session.save(dept);
			//提交事务
			ta.commit();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(session != null)
			{
				session.close();
			}
		}
	}

七、主键生成机制

1、increment:表示hibernate调用所连接的数据库的加一机制为该字段生成信息(即生成主键)
2、identity:表示由所连接的数据本身调用自加一机制为该字段生成信息(即生成主键)
Increment 和identity的区别在于前者是由hibernate调用生成机制,后者是数据库本身调用生成机制(即您在建表的时候就声明该字段是自动加一的)。但是以上两种主键生成机制在连接Oracle时都不适用。因为Oracle没有自动加一机制。如果Oracle要用自动加一机制就必须依靠。
3、sequence:表示该字段由数据的序列生成,如果不想指定特定的序列则在Oracle中该序列名字必须叫HIBERNATE_SEQUENCE 用于默认选择。


4、uuid:根据UUID算法生成生成32位字符类型的主键信息。

5、guid:利用数据库提供的sys_guid 函数生成主键。但是要注意不是所有数据库都有sys_guid函数的。所以首选还是uuid

6、native:根据具体连接的数据库从identity, sequence或者hilo选择一种来生成主键。适用的数据库根据选择的生成方式确定。(这个情况数据库是可以跨越的,因为它能自动选择生成方案),在Oracle中就必须有名字叫HIBERNATE_SEQUENCE的序列
assigned: 交给应用自己给主键赋值。要注意的是赋值必须在调用save()方法之前完成。适用的数据库根据选择的生成方式确定。

八、Hibernate的类型

在Hibernate中可以使用纯java类型和Hibernate指定类型。在Hibernate框架的内部可以自动对Java类型或者Hibernate类型完成对表的对应。建议在开发中使用java类型,效率比较快

总结

以上文章只是其中的一部分只是教你如何实现框架实现CRUD的操作,最重要的是后续我要写的知识点:反向创建Hibernate工程、对象(DO对象)的三种状态、一对多关系(在主对象设计从对象集合属性)、多对多、懒加载(延迟加载)、抓取策略、Hibernate的一级缓存(Session缓存)、Hibernate的二级缓存、HQL、Query.list和query.iterator等等,这些才是重中之重,任重而道远。

到此这篇关于持久层ORM框架Hibernate框架的使用及搭建方式的文章就介绍到这了,更多相关ORM框架Hibernate框架使用内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Hibernate 与 Mybatis 的共存问题,打破你的认知!(两个ORM框架)

    很长一段时间,网上有很多关于Hibernate与Mybatis孰优孰劣的争论,两个阵营的人谁也不能说服谁,每个人的理由都很有道理. 今天,我分享的主题是:在一个项目中同时使用Hibernate和Mybatis两个ORM框架. 作为一个开发者,没有必要花费过多的时间去证明技术无用论,当你开始指责某个框架垃圾,另外一个框架最好时,隐性的暴露出你对某个框架没有深入的研究,无知的指责对于技术的提升没有任何的帮助. 框架本身没有对错一说,只有适合和更适合项目的选择.任何框架都有自身的能力范围,就拿Hibe

  • 持久层ORM框架Hibernate框架的使用及搭建方式

    目录 前言 一.Hibernate的优点? 二.Hibernate的缺点 三.搭建Hibernate项目架构 四.Hibernate核心接口的介绍 五.封装Hibernate的工具类 六.常用的CRUD操作 七.主键生成机制 八.Hibernate的类型 总结 前言 hibernate的概念: hibernate是一个ormapping框架(ORM框架,全自动ORM框架) hibernate是一个数据库的操作框架即持久层框架 Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行

  • SpringBoot集成JPA持久层框架,简化数据库操作

    目录 与SpringBoot2.0整合 1.核心依赖 2.配置文件 3.实体类对象 4.JPA框架的用法 5.封装一个服务层逻辑 测试代码块 源代码地址 与SpringBoot2.0整合 1.核心依赖 <!-- JPA框架 --> <dependency>     <groupId>org.springframework.boot</groupId>     <artifactId>spring-boot-starter-data-jpa<

  • Java持久层框架Mybatis入门详细教程

    mybatis介绍 mybatis它是轻量级持久层框架,由ibatis演化而来.它自动连接数据库,将数据库的结果集封装到对象中POJO. POJO: 一个简单的Java类,这个类没有实现/继承任何特殊的java接口或者类,不遵循任何主要java模型,约定或者框架的java对象.在理想情况下,POJO不应该有注解. JavaBean: JavaBean是可序列化的,实现了serializable接口 具有一个无参构造器 有按照命名规范的set和gett,is(可以用于访问布尔类型的属性)方法 My

  • MyBatis持久层框架的用法知识小结

    MyBatis 是支持普通 SQL查询,存储过程和高级映射的优秀持久层框架.MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索.MyBatis 使用简单的 XML或注解用于配置和原始映射,将接口和 Java 的POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录. MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google c

  • 深入解析Java的Hibernate框架中的持久对象

    一.持久对象生命周期 应用程序在使用Hibernate框架后,创建的持久对象会经历一整套生命周期来完成数据库的操作,其中主要的三个状态分别是瞬态(Transient).持久化(Persistent).脱管(detached).这三种状态的转换是能够在应用程序中控制的,如下图: 为了能清楚的了解这几种状态,这里使用一个实例来查看下这几种状态下对象的不同,下面状态内的代码,具体步骤如下: (1)创建Hibernate_session程序集,并添加像相应的jar包: (2)配置Hibernate,添加

  • java持久层框架mybatis防止sql注入的方法

    sql注入大家都不陌生,是一种常见的攻击方式,攻击者在界面的表单信息或url上输入一些奇怪的sql片段,例如"or '1'='1'"这样的语句,有可能入侵参数校验不足的应用程序.所以在我们的应用中需要做一些工作,来防备这样的攻击方式.在一些安全性很高的应用中,比如银行软件,经常使用将sql语句全部替换为存储过程这样的方式,来防止sql注入,这当然是一种很安全的方式,但我们平时开发中,可能不需要这种死板的方式. mybatis框架作为一款半自动化的持久层框架,其sql语句都要我们自己来手

  • Java持久层框架MyBatis简单实例

    什么是Mybatis MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis .iBATIS一词来源于"internet"和"abatis"的组合,是一个基于Java的持久层框架.iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO). MyBatis 本是apache的一个开源项目iB

  • 解析MyBatis源码实现自定义持久层框架

    目录 自定义框架设计 自定义框架实现 使用端 框架端 自定义框架设计 使用端 : 提供核⼼配置⽂件: sqlMapConfig.xml : 存放数据源信息,引⼊mapper.xml Mapper.xml : sql语句的配置⽂件信息 框架端: 1.读取配置⽂件 读取完成以后以流的形式存在,我们不能将读取到的配置信息以流的形式存放在内存中,不好操作,可以创建JavaBean来存储 (1)Configuration : 存放数据库基本信息.Map<唯⼀标识,Mapper>, 唯⼀标识:namesp

  • Mybatis持久层框架入门之CRUD实例代码详解

    目录 1.MyBatis第一个程序 1.1.代码演示 1.2.问题说明 2.CRUD操作 2.1.namespace 2.2.select 2.3.insert 2.4.update 2.5.delete 2.6.拓展思维 1.MyBatis第一个程序 思路流程:搭建环境–>导入Mybatis—>编写代码—>测试 1.1.代码演示 ​ 1.搭建实验数据库 CREATE DATABASE `mybatis`; USE `mybatis`; DROP TABLE IF EXISTS `use

  • Java手写持久层框架的详细代码

    目录 前言 JDBC操作回顾及问题分析 1.定义配置xml文件 2.读取配置文件 3.定义sql操作接口SqlSession 4.编写数据库执行逻辑 5.调用测试 ⾃定义框架优化 总结 本文适合有一定java基础的同学,通过分析jdbc存在的问题,进行手写自定义持久层框架,可以更加清楚常用的mybatis等开源框架的原理. 前言 本文适合有一定java基础的同学,通过自定义持久层框架,可以更加清楚常用的mybatis等开源框架的原理. JDBC操作回顾及问题分析 学习java的同学一定避免不了接

随机推荐