学习笔记之Hibernate(一)

最新推荐文章于 2019-07-24 10:23:00 发布

helloDev

最新推荐文章于 2019-07-24 10:23:00 发布

阅读量215

点赞数

分类专栏： Hibernate 文章标签： Hibernate HQL hibernate配置详解 hibernate三种状态转换

本文链接：https://blog.csdn.net/helloDev/article/details/79757458

版权

Hibernate 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文介绍了Hibernate框架的基础知识，包括什么是框架、Hibernate的作用、框架搭建步骤，详细讲解了ORM元数据配置、主配置文件设置，以及实体类创建规则。此外，文章还探讨了Hibernate中的实体对象状态、一级缓存、事务隔离级别配置，并引入了HQL查询语言的基本使用，旨在帮助读者深入理解Hibernate的使用和操作。

摘要由CSDN通过智能技术生成

1、框架是什么

从开发的角度来说框架是用来提高开发效率的，他其实就是几个Jar包，封装好了一些功能，我们需要使用这些功能时，调用即可，不再需要手动实现，可以极大的提高开发效率。我们可以把它理解成一个工具。那么，如何使用好这个工具就成了学习框架的重点。

2、Hibernate是什么

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

简单来说，Hibernate是用来帮助我们完成数据库操作的。操作数据库的时候，可以以面向对象的方式来完成，不需要书写SQL语句。他是一款完全的ORM（object relationg mapping. 对象关系映射）框架，程序中使用配置（或者其他方式，一般用配置），将对象的信息与数据库中的表进行对应，完成操作，这种性质称之为ORM。

3、Hibernate框架的搭建

1）导包，Hibernate所需jar包及数据库对应的驱动包

2）创建数据库，准备表，实体

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_linkman` VARCHAR(64) 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;

3）书写ORM，即写对象与表的关系映射配置文件

对象类（实体类）：Customer有如下成员变量：

private Long cust_id;
private String cust_name;
private String cust_source;
private String cust_industry;
private String cust_level;
private String cust_linkman;
private String cust_phone;
private String cust_mobile;

注：记得get和set方法

关系映射配置文件：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">
   <!-- 配置表与实体对象的关系 -->
   <!-- package属性:填写一个包名.在元素内部凡是需要书写完整类名的属性,可以直接写简答类名了. -->
<hibernate-mapping package="cn.shx.domain" >
	<class name="Customer" table="cst_customer" >	
		<id name="cust_id"  >
			<!-- generator:主键生成策略 -->
			<generator class="native"></generator>
		</id>
		<property name="cust_name" column="cust_name" >
		</property>
		<property name="cust_source" column="cust_source" ></property>
		<property name="cust_industry" column="cust_industry" ></property>
		<property name="cust_level" column="cust_level" ></property>
		<property name="cust_linkman" column="cust_linkman" ></property>
		<property name="cust_phone" column="cust_phone" ></property>
		<property name="cust_mobile" column="cust_mobile" ></property>
	</class>
</hibernate-mapping>

4）书写主配置文件

<?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>
		 <!-- 数据库驱动 -->
		<property name="hibernate.connection.driver_class"> com.mysql.jdbc.Driver </property>
		<property name="hibernate.connection.url">jdbc:mysql:///hibernate_32</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">1234</property>
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		
		<!-- 将hibernate生成的sql语句打印到控制台 -->
		<property name="hibernate.show_sql">true</property>
		<!-- 将hibernate生成的sql语句格式化(语法缩进) -->
		<property name="hibernate.format_sql">true</property>
		<property name="hibernate.hbm2ddl.auto">update</property>
		<mapping resource="cn/shx/domain/Customer.hbm.xml" />
	</session-factory>
</hibernate-configuration>

5）测试

public class Demo {
	@Test
	//保存客户
	public void fun1(){
		Configuration conf = new Configuration().configure();
		SessionFactory sessionFactory = conf.buildSessionFactory();
		Session session = sessionFactory.openSession();
		Transaction tx = session.beginTransaction();
		//----------------------------------------------
		Customer c = new Customer();
		c.setCust_name("google公司");
		session.save(c);//执行保存
		//----------------------------------------------
		tx.commit();
		session.close();
		sessionFactory.close();
	}
}

4、orm元数据(xxx.hbm.xml)配置文件详解

1）约束头，用于引进约束

<?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">

2）根元素 hibernate-mapping，用来配置表与实体对象的关系

- package属性:填写一个包名，在元素内部凡是需要书写完整类名的属性,之后就可以直接写简单类名了

<hibernate-mapping package="cn.itheima.domain" >

3）class元素，用来配置实体与表的对应关系，嵌套在根元素内

- name属性: 完整类名

- table属性:数据库表名

<class name="Customer" table="cst_customer" >

4） id元素，用来配置主键映射的属性，嵌套在class元素内，其中：

- name: 填写主键对应属性名

- column(可选): 填写表中的主键列名.默认值:列名会默认使用属性名

- type(可选):填写列(属性)的类型.hibernate会自动检测实体的属性类型.

每个类型有三种填法: java类型|hibernate类型|数据库类型

- not-null(可选):配置该属性(列)是否不能为空. 默认值:false

- length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度

<id name="cust_id"  >
	<!-- generator:主键生成策略-->
	<generator class="native"></generator>
</id>

5）property元素:除id之外的普通属性映射，嵌套在class元素内，其中：

-name: 填写属性名

-column(可选): 填写列名

-type(可选): 填写列(属性)的类型.hibernate会自动检测实体的属性类型.

每个类型有三种填法: java类型|hibernate类型|数据库类型

-not-null(可选):配置该属性(列)是否不能为空. 默认值:false

-length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度

<property name="cust_name" column="cust_name" >
	<!--  <column name="cust_name" sql-type="varchar" ></column> -->
</property>

5、主配置hibernate.cfg.xml配置详解

1）必选属性配置

<!-- 数据库驱动 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- 数据库url -->
<property name="hibernate.connection.url">jdbc:mysql:///hibernate_32</property>
<!-- 数据库连接用户名 -->
<property name="hibernate.connection.username">root</property>
<!-- 数据库连接密码 -->
	<property name="hibernate.connection.password">1234</property>
	<!-- 数据库方言
	不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成.
	sql99标准: DDL 定义语言  库表的增删改查
			DCL 控制语言  事务 权限
		     DML 操纵语言  增删改查
			注意: MYSQL在选择方言时,请选择最短的方言.
	 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

2）可选属性配置

<!-- 将hibernate生成的sql语句打印到控制台 -->
<property name="hibernate.show_sql">true</property>
<!-- 将hibernate生成的sql语句格式化(语法缩进) -->
<property name="hibernate.format_sql">true</property>
<property name="hibernate.hbm2ddl.auto">update</property>

自动导出表结构，自动建表详解

#hibernate.hbm2ddl.auto create 自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)

#hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)

#hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).

#hibernate.hbm2ddl.auto validate 校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.

3）元数据引入配置（填写src下的路径）

<mapping resource="cn/shx/domain/Customer.hbm.xml" />

6、hibernateAPI详解

1）Configuration

                //1 创建,调用空参构造
		Configuration conf = new Configuration();
		//2 读取指定主配置文件 => 空参加载方法,加载src下的hibernate.cfg.xml文件
		conf.configure();
		//3 读取指定orm元数据(扩展),如果主配置中已经引入映射配置.不需要手动加载
		//conf.addResource(resourceName);
		//conf.addClass(persistentClass);
		//4 根据配置信息,创建 SessionFactory对象
		SessionFactory sf = conf.buildSessionFactory();

2) SessionFactory

SessionFactory对象:用来产生核心会话对象Session的工厂对象

SessionFactory功能: 用于创建操作数据库核心对象session对象的工厂.

简单说功能就一个---创建session对象

注意:1.sessionfactory 负责保存和使用所有配置信息.消耗内存资源非常大.

2.sessionFactory属于线程安全的对象设计.

结论: 保证在web项目中,只创建一个sessionFactory.

                //5 获得session
		//打开一个新的session对象
		sf.openSession();
		//获得一个与线程绑定的session对
		sf.getCurrentSession();

3)Session

session对象功能: 表达hibernate框架与数据库之间的连接(会话).session类似于JDBC年代的connection对象. 还可以完成对数据库中数据的增删改查操作.session是hibernate操作数据库的核心对象

创建session以及打开事务

public void fun1(){
		//1 创建,调用空参构造
		Configuration conf = new Configuration().configure();
		//2 根据配置信息,创建 SessionFactory对象
		SessionFactory sf = conf.buildSessionFactory();
		//3 获得session
		Session session = sf.openSession();
		//4 session获得操作事务的Transaction对象
		//获得操作事务的tx对象
		//Transaction tx = session.getTransaction();
		//开启事务并获得操作事务的tx对象(建议使用)
		Transaction tx2 = session.beginTransaction();
		//----------------------------------------------
		此处为各种业务操作
		//----------------------------------------------
		tx2.commit();//提交事务
		tx2.rollback();//回滚事务
		session.close();//释放资源
		sf.close();//释放资源
	}

4）使用session进行增删改查

增：

        Customer c = new Customer();
	c.setCust_name("苏焕雄");
	session.save(c);

删：

        //1 获得要修改的对象
	Customer c = session.get(Customer.class, 1l);
	//2 调用delete删除对象
	session.delete(c);

改：

//1 获得要修改的对象
	Customer c = session.get(Customer.class, 1l);
	//2 修改
	c.setCust_name("小浣熊");
	//3 执行update
	session.update(c);

查：此处先列一个简单查询，具体的接下来会说

Customer customer = session.get(Customer.class, 1l);
System.out.println(customer);

5）事务操作

事务（Transaction），一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务通常由高级数据库操纵语言或编程语言（如SQL，C++或Java）书写的用户程序的执行所引起，并用形如begin transaction和end transaction语句（或函数调用）来界定。事务由事务开始(begin transaction)和事务结束(end transaction)之间执行的全体操作组成。

事务是恢复和并发控制的基本单位。

事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。

原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。

一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。

隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

持久性（durability）。持久性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

事务的具体操作：

打开事务：

Transaction tx = session.getTransaction();
tx.begin();

开启事务并获得操作事务的tx对象(建议使用)

        Transaction tx2 =session.beginTransaction();

提交事务

tx2.commit();

回滚事务：

  tx2.rollback()；

一般情况下，使用事务需在打开事务到事务提交的前后做异常捕捉，如果抛出异常，则回滚事务。

7、hibernate中的实体类创建规则

1）创建实体类的注意事项

1.需要为持久化类提供无参数构造函数

2.成员变量用private修饰，提供公有get和set方法访问。（JavaBean提供属性访问）

3.持久化类中的属性，应尽量使用包装类型。

4.持久化类需要提供唯一标志（Oid）,与数据库中的主键列对应

5.不要用final修饰实体类，hibernate使用cglib代理生成代理对象.代理对象是继承被代理对象.如果被final修饰.将无法生成代理.

6.建议实现序列化接口

2）主键类型

1.自然主键（少见），表的业务列中,有某业务列符合,必须有,并且不重复的特征时,该列可以作为主键使用.如学生的学号

2.代理主键（常见），表的业务列中,没有某业务列符合,必须有,并且不重复的特征时,创建一个没有业务意义的列作为主键

3）主键生成策略

1.代理主键：

identity : 主键自增.由数据库来维护主键值.录入时不需要指定主键.

sequence:Oracle中的主键生成策略.

increment:主键自增.由hibernate来维护.每次插入前会先查询表中id最大值.+1作为新主键值.一般不使用

hilo(了解): 高低位算法.主键自增.由hibernate来维护.开发时一般不使用.

native:hilo+sequence+identity自动三选一策略.

uuid:产生随机字符串作为主键. 主键类型必须为string 类型.

2. 自然主键：assigned:自然主键生成策略. hibernate不会管理主键值.由开发人员自己录入.

8、hibernate中实体对象的三种状态

hibernate中的实体对象的状态分为三种，瞬时状态，持久化状态，游离状态，一般我们可以用该对对象有无id，有没有在session缓存中来区分

1）瞬时（临时）状态：没有id,没有在session缓存中

2）持久化状态：有id,在session缓存中

3）游离（托管）状态：有id,没有在session缓存中

三种状态的状态转换图：

9、hibernate中的一级缓存

缓存一般用来提高效率，hibernate中的一级缓存也是为了提高操作数据库的效率.

一级缓存使用如下手段提高效率：

1）减少不必要的查询语句发送，提高查询效率

2）减少不必要的修改语句发送

10、在hibernate中配置数据库的隔离级别

可以在session-factory中添加一个属性节点，其中隔离级别分为：1|2|4|8

0001 1 读未提交，可能存在脏读，不可重复读，幻读，虚读

0010 2 读已提交，可能存在不可重复读，幻读，虚读

0100 4 可重复读，可能幻读，虚读，这是MySQL的默认隔离级别

1000 8 串行化，没有任何并发问题，但一般情况不使用，效率极低

<propertyname="hibernate.connection.isolation">2</property>

如何管理事务？

在我们的业务代码开始之前打开事务,业务代码执行完毕之后提交事务. 执行过程中出现异常则回滚事务。

在dao层操作数据库需要用到session对象，在service控制事务也是使用session对象完成。因此我们要确保dao层和service层使用的使用同一个session对象，在hibernate中,确保使用同一个session的问题,hibernate已经帮我们解决了. 我们开发人员只需要调用sessionFactory.getCurrentSession()方法即可获得与当前线程绑定的session对象。

注意1: 调用getCurrentSession方法必须配合主配置中的一段配置

<property name="current_session_context_class">thread</property>

注意2:通过getCurrentSession方法获得的session对象.当事务提交时,session会自动关闭.不要手动调用close关闭。

11、HQL查询-hibernate Query Language

此小节参考原文：https://www.cnblogs.com/printN/p/6415602.html

Hibernate将HQL查询方式立为官方推荐的标准查询方式，HQL查询在涵盖Criteria查询的所有功能的前提下，提供了类似标准SQL语句的查询方式，同时也提供了更加面向对象的封装。完整的HQL语句形势如下：

select/update/delete(这里不写默认为select)…… from …… where …… groupby …… having …… order by …… asc/desc

可见HQL查询非常类似于标准SQL查询。

1)基本查询

例子：

 String hql=”from User user ”;
 List<User> list=session.CreateQuery(hql).list();

上面的代码执行结果是，查询出User实体对象所对应的所有数据，而且将数据封装成User实体对象，并且放入List<User>中返回。这里需要注意的是，Hibernate的实体查询存在着对继承关系的判定，如果我们的User类它有两个子类分别是AdminUser，CommonUser,如果有这样的HQL语句：“from User”,当执行检索时Hibernate会检索出所有User类型实体对象所对应的数据（包括它的子类AdminUser，CommonUser对应的数据）。

因为HQL语句与标准SQL语句相似，所以我们也可以在HQL语句中使用where字句，并且可以在where字句中使用各种表达式，比较操作符以及使用“and”,”or”连接

不同的查询条件的组合。看下面的一些简单的例子：

from User user where user.age=20;
from User user where user.age between 20 and 30;
from User user where user.age in(20,30);
from User user where user.name is null;
from User user where user.name like ‘%zx%’;
from User user where (user.age%2)=1;
from User user where user.age=20 and user.name like ‘%zx%’;

2）实体的更新和删除：

在继续讲解HQL其他更为强大的查询功能前，我们先来讲解以下利用HQL进行实体更新和删除的技术。这项技术功能是Hibernate3的新加入的功能，在Hibernate2中是不具备的。比如在Hibernate2中，如果我们想将数据库中所有18岁的用户的年龄全部改为20岁，那么我们要首先将年龄在18岁的用户检索出来，然后将他们的年龄修改为20岁，最后调用Session.update()语句进行更新。在Hibernate3中对这个问题提供了更加灵活和更具效率的解决办法，如下面的代码：

 Transaction trans=session.beginTransaction();
 String hql=”update User user set user.age=20 where user.age=18”;
 Query queryupdate=session.createQuery(hql);
 int ret=queryupdate.executeUpdate();
 trans.commit();

通过这种方式我们可以在Hibernate3中，一次性完成批量数据的更新，对性能的提高是相当的可观。同样也可以通过类似的方式来完成delete操作，如下面的代码

 Transaction trans=session.beginTransaction();
 String hql=”delete from User user where user.age=18”;
 Query queryupdate=session.createQuery(hql);
 int ret=queryupdate.executeUpdate();
 trans.commit();

这种操作方式在Hibernate3中称为bulk/delete/update，这种方式能够在很大程度上提高操作的灵活性和运行效率，但是采用这种方式极有可能引起缓存同步上的问题.

3）属性查询。

部分属性检索

很多时候我们在检索数据时，并不需要获得实体对象所对应的全部数据，而只需要检索实体对象的部分属性所对应的数据。这时候就可以利用HQL属性查询技术，如下面程序示例：

List list=session.createQuery(“select user.name from User user ”).list();
for(int i=0;i<list.size();i++){
 System.out.println(list.get(i));
}

我们只检索了User实体的name属性对应的数据，此时返回的包含结果集的list中每个条目都是String类型的name属性对应的数据。我们也可以一次检索多个属性，如下面程序：

 List list=session.createQuery(“select user.name,user.age from User user ”).list();
 for(int i=0;i<list.size();i++){
  Object[] obj=(Object[])list.get(i);
  System.out.println(obj[0]);
  System.out.println(obj[1]);
 }

此时返回的结果集list中，所包含的每个条目都是一个Object[]类型，其中包含对应的属性数据值。作为当今我们这一代深受面向对象思想影响的开发人员，可能会觉得上面返回Object[]不够符合面向对象风格，这时我们可以利用HQL提供的动态构造实例的功能对这些平面数据进行封装，如下面的程序代码：

List list=session.createQuery(“select new User(user.name,user.age) from User user ”).list();
for(int i=0;i<list.size();i++){
 User user=(User)list.get(i);
 System.out.println(user.getName());
 System.out.println(user.getAge());
}

这里我们通过动态构造实例对象，对返回结果进行了封装，使我们的程序更加符合面向对象风格，但是这里有一个问题必须注意，那就是这时所返回的User对象，仅仅只是一个普通的Java对象而已，除了查询结果值之外，其它的属性值都为null（包括主键值id），也就是说不能通过Session对象对此对象执行持久化的更新操作。如下面的代码：

4 ）分组与排序

A、Order by子句：

与SQL语句相似，HQL查询也可以通过orderby子句对查询结果集进行排序，并且可以通过asc或者desc关键字指定排序方式，如下面的代码：

from User user order by user.name asc,user.age desc;

上面HQL查询语句，会以name属性进行升序排序，以age属性进行降序排序，而且与SQL语句一样，默认的排序方式为asc,即升序排序。

B、Group by子句与统计查询：

在HQL语句中同样支持使用group by子句分组查询，还支持group by子句结合聚集函数的分组统计查询，大部分标准的SQL聚集函数都可以在HQL语句中使用，比如：

count(),sum(),max(),min(),avg()等。如下面的程序代码：

String hql=”select count(user),user.age from User user group by user.age having count(user)>10 ”;
List list=session.createQuery(hql).list();

5）参数绑定

Hibernate中对动态查询参数绑定提供了丰富的支持，而且在Hibernate中对这个功能还提供了比传统JDBC操作丰富的多的特性，在Hibernate中共存在4种参数绑定的方式，下面我们将分别介绍：

A、按参数名称绑定：
在HQL语句中定义命名参数要用”:”开头，形式如下：

  Query query=session.createQuery(“from User user where user.name=:customername and user.customerage=:age ”);
  query.setString(“customername”,name);
  query.setInteger(“customerage”,age);

上面代码中用:customername和:customerage分别定义了命名参数customername和customerage，然后用Query接口的setXXX()方法设定名参数值，setXXX()方法包含两个参数，分别是命名参数名称和命名参数实际值

B、按参数位置邦定：
在HQL查询语句中用”?”来定义参数位置，形式如下：

Query query=session.createQuery(“from User user where user.name=? and user.age =? ”);
query.setString(0,name);
query.setInteger(1,age);

同样使用setXXX()方法设定绑定参数，只不过这时setXXX()方法的第一个参数代表邦定参数在HQL语句中出现的位置编号（由0开始编号），第二个参数仍然代表参数实际值。

注：在实际开发中，提倡使用按名称邦定命名参数，因为这不但可以提供非常好的程序可读性，而且也提高了程序的易维护性，因为当查询参数的位置发生改变时，按名称邦定名参数的方式中是不需要调整程序代码的。

C、setParameter()方法：

在Hibernate的HQL查询中可以通过setParameter()方法邦定任意类型的参数，如下代码：

String hql=”from User user where user.name=:customername ”;
Query query=session.createQuery(hql);
query.setParameter(“customername”,name,Hibernate.STRING);

如上面代码所示，setParameter()方法包含三个参数，分别是命名参数名称，命名参数实际值，以及命名参数映射类型。对于某些参数类型setParameter()方法可以更具参数值的Java类型，猜测出对应的映射类型，因此这时不需要显示写出映射类型，像上面的例子，可以直接这样写：

query.setParameter(“customername”,name);

但是对于一些类型就必须写明映射类型，比如java.util.Date类型，因为它会对应Hibernate的多种映射类型，比如:Hibernate.DATA或者Hibernate.TIMESTAMP。

D、setProperties()方法

在 Hibernate 中可以使用 setProperties() 方法，将命名参数与一个对象的属性值绑定在一起，如下程序代码：

 Customer customer=new Customer();
 customer.setName(“pansl”);
 customer.setAge(80);
 Query query=session.createQuery(“from Customer c where c.name=:name and c.age=:age ”);
 query.setProperties(customer);

setProperties()方法会自动将customer对象实例的属性值匹配到命名参数上，但是要求命名参数名称必须要与实体对象相应的属性同名。
E、使用绑定参数的优势：

我们为什么要使用绑定命名参数？任何一个事物的存在都是有其价值的，具体到绑定参数对于HQL查询来说，主要有以下两个主要优势：

①可以利用数据库实施性能优化，因为对Hibernate来说在底层使用的PrepareStatement来完成查询，因此对于语法相同参数不同的SQL语句，可以充分利用预编译SQL语句缓存，从而提升查询效率。

②可以防止SQL Injection安全漏洞的产生：

helloDev

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习笔记之Hibernate(一)

1、框架是什么从开发的角度来说框架是用来提高开发效率的，他其实就是几个Jar包，封装好了一些功能，我们需要使用这些功能时，调用即可，不再需要手动实现，可以极大的提高开发效率。我们可以把它理解成一个工具。那么，如何使用好这个工具就成了学习框架的重点。2、Hibernate是什么Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射...
复制链接

扫一扫

专栏目录