22-Java-Hibernate框架(二)

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

Hibernate的了解、Hibernate的搭建、Hibernate的基本使用流程等内容请阅读21-Java-Hibernate框架(一)

五、Hibernate的Query查询接口(重中之重)

1.HQL语言了解：Hibernate Query Language(HQL)，是hibernate的查询语言，和SQL语句结构一样，不同点注意点如下：

(1)HQL是面向对象查询，SQL是面向结构查询

(2)在HQL使用类名和属性名，替代了原有的表名和字段名

(3)在HQL语句中类型名和属性名大小写敏感

(4)如果需要select * 查询所有字段的值，在HQL语句中可以省略select *语句。例如：from User;

(5)如果需要join...on表连接，需要建立关联映射关系使用，不支持on子句

(6)不要使用数据库提供的字符串函数、日期函数和一些特有的函数。一些基础的函数可以使用，例如：max()，min()，sum()，avg()，count()等。

(7)若只查询字体类中某几个字段，返回的结果是泛型，值的集合

2.具体Query常用的相关接口看代码演示

package com.hibernatetest.test; import java.util.List; import org.hibernate.Query;
import org.hibernate.Session;
import com.hibernatetest.entity.User;
import HibernatenateUtils.hibernateUtils;
/*
* Query接口的常用方法：
* 1.setXXX():用于设置HQL语句中问号或变量的值
* 2.uniqueResult()：得到单个对象(返回Object类型)，在已知查询结果中只有一个或零个才能用此函数，若有多个满足条件的结果则报异常
* 3.executeUpdate():执行更新和删除语句(返回int型作为操作成功的次数)
* 4.分页查询
* 5.list():获取结果集(返回List类型)
* 6.iterate():获取结果集(返回Iterator类型)
* */
public class QueryTest {
public static void main(String[] args) {
//第一步：Query对象是通过Session获取的，所以先要通过之前写hibernate工具类获取Session对象
Session session = hibernateUtils.getSession(); //第二步：CreateQuery("HQL语句")：用于创建Query对象。
Query query = session.createQuery("from User where uname='zhangsan'"); /*查询参数设值setXXX(): (两种方式)
* 1.问号设值
* Query query = session.createQuery("from User where uid between ? and ?");
* query.setInteger(0,5);//给第一个问号处赋值5
* query.setInteger(1,10);//给第一个问号处赋值10
*
* 2.变量设值
* Query query = session.createQuery("from User where uname=:name");
* query.setString(name,"zhangsan");//给name变量赋值
*
* 3.模糊查询
* Query query = session.createQuery("from User where uname likt %?%");错！！！！！
* Query query = session.createQuery("from User where uname like ?");对！！！！
* query.setString(0,"%" +"zhang"+ "%");
*
* 4.分页查询
* Query query = session.createQuery("from User where uname='zhangsan'");
* query.setFirstResult(0);从满足条件的数据中的第一条数据开始抓取
* query.setMaxResult(2);从满足条件的数据中只抓取前两条数据
*
* 5.获取单个对象
* Query query = session.createQuery("select count(*) from User where uname='zhangsan'");
* Object object = query.uniqueResult();
*
* 6.构造查询
* Query query = session.createQuery("select new User(5,"zhangsan") from User where uname='zhangsan'");
* Object object = query.uniqueResult();
* */ /*数据库更新和删除操作executeUpdate()
* 1.删除
* Query query = session.createQuery("delete from User where uid in(1,6)");//删除id为1和6的数据,即使数据库中没有符合条件的数据也不会报错
* int execute = query.executeUpdate();//返回成功操作的次数
* */ //第三步：Query获取结果集
//1.list()获取
List<?> list = query.list();
for(Object u:list){
User user = (User)u;
System.out.println(user);
}
/*2.iterate()获取
* Iterator<?> iterator = query.iterate();
* while(iterator.hasNext()){
* User user = (User)iterator.next();
* System.out.println(user);
* }
* */
/*面试要考：list()和iterate()获取结果集的区别：
* list()：一次把所有数据从数据库中取出来
* iterate():先从数据库中查询满足条件的id,如果缓存中包含全部要查询的id的数据，就无需再查数据库，直接从缓存中取数据，否则，根据id从数据库中取
* */ //第四步：记得将Session关闭
session.close();
}
}

六、Hibernate的三个状态

对象(持久化类的实例)处于session对象的管理中才能与数据库发生联系。在Hibernate框架应用中，我们依据对象对象与session对象的关系不同情况，

把对象的状态分为人的三种:瞬时状态、游离状态、持久状态。

Transient(瞬时状态|临时状态)：在new之后，save()之前，数据库没有应用的数据

如果对象未与session对象关联过，我们称该对象处于瞬时状态

Persistent(持久状态)：在save()之后，在session关闭之前，数据库有相对应的数据

如果对象与session关联起来了，且该对象对应到数据库记录，则称该对象处于持久状态

三状态结构图：

三状态转换关系：

1.瞬时状态转换为持久状态：

使用session的save()或saveOrUpdate()方法保存对象后，该对象的状态由瞬时状态转换为持久状态

使用session的get()或load()方法获取对象后，该对象的状态为持久状态

2.持久状态转换为瞬时状态

执行session对象的delete()方法后，对象由原来的持久状态变为瞬时状态，因此该对象没有与任何的数据库数据有关联

3.持久状态变为游离状态

执行session对象的evict()、clear()、close()方法，对象由原来的持久状态变为游离状态。

4.游离状态变为持久状态

重新获取对象session对象，执行session对象的update()或saveOrUpdate方法，由游离状态转换为持久状态，该对象再次与session关联

5.游离状态转换为瞬时状态

执行session的delete()方法，对象有游离状态变为瞬时状态

对瞬时状态或游离状态的对象不再被其他对象引用时，会被Java虚拟机按照垃圾回收机制处理

七、Hibernate根据实体自动构建生成表

第一步：在hibernate.cfg.xml中添加<property name="hibernate.hbm2ddl.auto">update</property>，设置自动生成表

<?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="dialect">org.hibernate.dialect.MySQLDialect</property>

<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://127.0.0.1:3306/hibernatetest</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property> 
<property name="hibernate.hbm2ddl.auto">update</property>

<property name="show_sql">true</property>

<property name="format_sql">true</property>

<property name="connection.autocommit">true</property> 

<mapping resource="com/hibernatetest/entity/Entity.hbm.xml" />
</session-factory> </hibernate-configuration>

第二步：编写实体类

第三步：配置映射文件

<?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.hibernatetest.entity.Entity" table="hibernateEntity">

<id name="userid" type="java.lang.Integer">

<column name="userid"></column>

<generator class="native"></generator>
</id> 
<property name="username" type="java.lang.String">
<column name="username" length="32"></column>
</property>
<property name="password" type="java.lang.String" >
<column name="password" length="32"></column>
</property> </class> </hibernate-mapping>

第四步：编写测试类测试

控制台显示hibernate在数据库没找到hibernateEntity表

于是它便会在数据库自动生成一张表

八、Hibernate的关联映射

实体与实体之间有一对一、多对一、多对多的关系，Hibernate也因此需要对表与表之间进行关联映射配置。

假设：有一张表为Entity，表中有userid,username,password三个字段，另一张表Grade，表中有gradeid,userid,grade。

我现在通过userid查询对应另一张表中的grade(此处可以理解为多对一)。步骤如下：

第一步：搭建Hibernate，配置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>

<property name="dialect">org.hibernate.dialect.MySQLDialect</property>

<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://127.0.0.1:3306/hibernatetest</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property> 
<property name="hibernate.hbm2ddl.auto">update</property>

<property name="show_sql">true</property>

<property name="format_sql">true</property>

<property name="connection.autocommit">true</property>  
<mapping resource="com/hibernatetest/entity/Entity.hbm.xml" />
<mapping resource="com/hibernate/grade/Grade.hbm.xml" />
</session-factory> </hibernate-configuration>

第二步：配置两张表对应的映射文件

Entity.hbm.xml：

Grade.hbm.xml:(此处需要加入对grade表的多对一的映射关系)

<?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.hibernate.grade.Grade" table="hibernateGrade">

<id name="gradeid" type="java.lang.Integer">

<column name="gradeid"></column>

<generator class="native"></generator>
</id>  

<many-to-one name="entity" column="userid" fetch="join"></many-to-one> <property name="grade" type="java.lang.Double" >
<column name="grade"></column>
</property>
</class> </hibernate-mapping>

第三步：编写两张表对应的实体类

Entity类：

package com.hibernatetest.entity; public class Entity {
private Integer userid;
private String username;
private String password;
public Entity() {
super();
// TODO Auto-generated constructor stub
}
public Entity(Integer userid, String username, String password) {
super();
this.userid = userid;
this.username = username;
this.password = password;
}
public Integer getUserid() {
return userid;
}
public void setUserid(Integer userid) {
this.userid = userid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((password == null) ? 0 : password.hashCode());
result = prime * result + ((userid == null) ? 0 : userid.hashCode());
result = prime * result
+ ((username == null) ? 0 : username.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Entity other = (Entity) obj;
if (password == null) {
if (other.password != null)
return false;
} else if (!password.equals(other.password))
return false;
if (userid == null) {
if (other.userid != null)
return false;
} else if (!userid.equals(other.userid))
return false;
if (username == null) {
if (other.username != null)
return false;
} else if (!username.equals(other.username))
return false;
return true;
}
@Override
public String toString() {
return "Entity [userid=" + userid + ", username=" + username
+ ", password=" + password + "]";
} }

Grade类：

package com.hibernate.grade; import com.hibernatetest.entity.Entity; public class Grade {
private Integer gradeid;
private Entity entity;
private Double grade;
public Grade() {
super();
// TODO Auto-generated constructor stub
}
public Grade(Integer gradeid, Entity entity, Double grade) {
super();
this.gradeid = gradeid;
this.entity = entity;
this.grade = grade;
}
public Integer getGradeid() {
return gradeid;
}
public void setGradeid(Integer gradeid) {
this.gradeid = gradeid;
}
public Entity getEntity() {
return entity;
}
public void setEntity(Entity entity) {
this.entity = entity;
}
public Double getGrade() {
return grade;
}
public void setGrade(Double grade) {
this.grade = grade;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((entity == null) ? 0 : entity.hashCode());
result = prime * result + ((grade == null) ? 0 : grade.hashCode());
result = prime * result + ((gradeid == null) ? 0 : gradeid.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Grade other = (Grade) obj;
if (entity == null) {
if (other.entity != null)
return false;
} else if (!entity.equals(other.entity))
return false;
if (grade == null) {
if (other.grade != null)
return false;
} else if (!grade.equals(other.grade))
return false;
if (gradeid == null) {
if (other.gradeid != null)
return false;
} else if (!gradeid.equals(other.gradeid))
return false;
return true;
}
@Override
public String toString() {
return "Grade [gradeid=" + gradeid + ", entity=" + entity + ", grade="
+ grade + "]";
} }

第四步：编写HibernateUtils工具类和测试类

测试类：

package Hibernatetest;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction; import com.hibernate.grade.Grade;
import com.hibernatetest.entity.Entity; import HibernatenateUtils.hibernateUtils; public class annotationtest { public void test(){ }
public static void main(String[] args) {
Session session = hibernateUtils.getSession(); //先制造两条记录在数据库中
Transaction transaction = session.beginTransaction();
Entity user1 = new Entity(null,"zhangsan","1111");
Grade grade1 = new Grade(null,user1,Double.valueOf(85));
session.save(user1);
session.save(grade1);
transaction.commit(); transaction = session.beginTransaction();
Entity user2 = new Entity(null,"lisi","2222");
Grade grade2 = new Grade(null,user2,Double.valueOf(100));
session.save(user2);
session.save(grade2);
transaction.commit(); //查询测试
Grade grade = session.get(Grade.class,1);
System.out.println(grade);
session.close();
}
}