HIbernate常用的三种查询

Hibernate三种常用查询API：标准，HQL，SQL

使用工具：

• 1. hibernate的核心jar包及配置文件和映射文件
• 2. log4j打印日志文件及jar及配置文件
• 3.eclipse开发，navicat数据库可视化工具，mysql
• 4.连接数据库的jar包
• 注：详细信息页面最下面（本篇只是初略起稿，不足之处，望帮忙指出，谢谢）

1.标准的查询：使用hibernate封装好的方法，完成查询所需：

1.1查询所有数据：

public void SelectLike() {
// 获取session
Session session = HibernateUtil.openSession();
// 查询主表信息：
Criteria criteria = session.createCriteria(ZJ.class);
//返回查询结果并返回给集合
List list = criteria.list();
//打印信息
System.out.println(list);
}

1.2精准条件查询：

@Test
public void SelectLike() {
// 获取session
Session session = HibernateUtil.openSession();
// 查询主表信息：
Criteria criteria = session.createCriteria(ZJ.class);
//设置查询条件:查询姓名中含有‘张’字的记录
criteria.add(Restrictions.eq("name" ,"赵小花"));
//返回查询结果并返回给集合
List list = criteria.list();
//打印信息
System.out.println(list);
}

注：criteria.add（）去添加一个标准查询的限制 ,Restrictions.eq(类的属性[从查询类的属性开始书写]，值)：精准查询{相当于 字段 = 值}；

1.2模糊条件查询：

@Test
public void SelectLike() {
// 获取session
Session session = HibernateUtil.openSession();
// 查询主表信息：
Criteria criteria = session.createCriteria(ZJ.class);
//设置查询条件:查询姓名中含有‘张’字的记录
criteria.add(Restrictions.like("name" ,"%张%"));
//返回查询结果并返回给集合
List list = criteria.list();
//打印信息
System.out.println(list);
}

注：Restrictions.like(类的属性[从查询类的属性开始书写]，值)：模糊查询{相当于 字段 like 值}；

1.3分页查询：

@Test
public void SelectLimit() {
// 获取session
Session session = HibernateUtil.openSession();
// 查询主表信息：
Criteria criteria = session.createCriteria(ZJ.class);
// 放置分页查询的起始坐标
criteria.setFirstResult(0);
// 放置每页查询记录记录数
criteria.setMaxResults(3);
// 返回查询结果并返回给集合
List list = criteria.list();
}

注：hibernate 的分页 只能调用查询的setFirstResult（）和setMaxResults（）方法

1.4添加大于查询条件：

@Test
public void SelectByLtId() {
//获取session
Session session = HibernateUtil.openSession();
//查询主表信息：
Criteria criteria = session.createCriteria(ZJ.class);
//设置查询条件：id小于3的记录
criteria.add(Restrictions.gt("id" ,3));
//返回查询结果并返回给集合
List list = criteria.list();
}

1.5添加大于查询条件：

@Test
public void SelectByLtId() {
//获取session
Session session = HibernateUtil.openSession();
//查询主表信息：
Criteria criteria = session.createCriteria(ZJ.class);
//设置查询条件：id小于3的记录
criteria.add(Restrictions.lt("id" ,3));
//返回查询结果并返回给集合
List list = criteria.list();
}

1.6范围条件查询条件：

@Test
public void SelectById() {
//获取session
Session session = HibernateUtil.openSession();
//查询主表信息：
Criteria criteria = session.createCriteria(ZJ.class);
//设置查询条件：id在2-6的记录
criteria.add(Restrictions.between("id" ,2,6));
//返回查询结果并返回给集合
List list = criteria.list();
}

1.7保存信息：

@Test
public void SelectLike() {
// 获取session
Session session = HibernateUtil.openSession();
//开启事务
Transaction transaction = session.beginTransaction();

//实例一个存储的类
ZJ zj = new ZJ();
//设置属性
zj.setName("赵小花");
//保存
session.save(zj);
//提交事务
transaction.commit();
}

注：如果调用的是sessionFactory.openSession()，操作增删改时需要开启事务和提交事务，如果需要持久状态的对象可以直接提交利用session的一级缓存完成修改操作

1.8:保存信息：

public void SelectLike() {
// 获取session
Session session = HibernateUtil.openSession();
//开启事务
Transaction transaction = session.beginTransaction();

//实例一个存储的类
ZJ zj = new ZJ();
//设置属性
zj.setId(1);
zj.setName("兰花指");
//修改
session.update(zj);
//提交事务
transaction.commit();
}

1.9：保存或修改操作：

public void SelectLike() {
// 获取session
Session session = HibernateUtil.openSession();
//开启事务
Transaction transaction = session.beginTransaction();

//实例一个存储的类
ZJ zj = new ZJ();
//设置属性
zj.setId(1);
zj.setName("兰花指");
//修改
session.saveOrUpdate(zj);
//提交事务
transaction.commit();
}

注：先判断时否存在id是否存在，如果在就修改，如果不一样就添加；

1.10:通过id获取对应信息：

//方法1：通过get获取（立即加载）
Session session = HibernateUtil.openSession();
ZJ zj = (ZJ)session.get(ZJ.class,1);

//方法2：通过load获取（延迟加载）
Session session = HibernateUtil.openSession();
ZJ zj = (ZJ)session.load(ZJ.class,1);

区别：

1.get是立即加载，查询结果不存在是返回的值为null。load是延迟加载，当查询结构不存在是会报错

2.get返回的是一个该类的实例，load返回的是一个代理对象。

1.11：删除记录：

@Test
public void deleteAUser() {
// 获取session
Session session = HibernateUtil.openSession();
//开启事务
Transaction transaction = session.beginTransaction();
//实例一个存储的类
User user = new User();
//设置属性
user.setId(3);
//执行删除
session.delete(user);
//提交事务并保存到数据库
transaction.commit();
}

1.12:通过条件查询获取唯一结果：

public void SelectLike() {
// 获取session
Session session = HibernateUtil.openSession();
//查询主表信息：
Criteria criteria = session.createCriteria(ZJ.class);
//设置查询条件: 查询name为‘赵小花’的记录
criteria.add(Restrictions.eq("name" ,"赵小花"));
//获取唯一结果并强转为该类型的数据
ZJ zj = （ZJ）criteria.uniqueResult();
}
注：查询结果不唯一会报错，小心使用

Hql语句心得：

概念介绍：

HQl： Hibernate Query Langurage(hibernate查询语句)。

注：是hibernate框架的一种查询AIP；主要分为两种1.hql语句拼接，2.hql占位符：

1.Hql操作单表：

1.1查询所有记录：

代码：

/**
* 简单查询所有的user数据
* */
public void findAllUser() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
//描写hql语句
String hql = "FROM User";
//创建查询对象
Query createQuery = session.createQuery(hql);
//获取结果集
List list = createQuery.list();
//打印结果集
System.out.println(list);
}
结果显示：

1.2条件查询记录（字符串拼接）：

@Test
/**
* 条件查询之模糊查询1.字符串拼接
* */
public void findUserByLikeName1() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
String name ="张";
//描写hql语句
String hql = "FROM User WHERE name like '%" + name + "%' ";
//创建查询对象
Query createQuery = session.createQuery(hql);
//获取结果集
List list = createQuery.list();
//打印结果集
System.out.println(list);
}

结果显示：

注：使用的时候尽量避免，因为拼接过长容易出错。希望你是大声一气呵成。

1.2条件查询记录（占位符方式）：

@Test
/**
* 条件查询之模糊查询2.占位符
* */
public void findUserByLikeName2() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
//描写hql语句
String hql = "FROM User WHERE name like ? ";
//创建查询对象
Query createQuery = session.createQuery(hql)
.setString(0,"%张%");
//获取结果集
List list = createQuery.list();
//打印结果集
System.out.println(list);
}
结果显示：

注：

1.使用占位符，下标是从0开始，和底层jdbc查询对象从1开始进行区分

2.放置类型只有包装类型和String类型，不想底层的jdbc查询对象可直接放置object类型

1.3精准条件查询获取唯一结果：

@Test
/**
*精准查询获取唯一结果：占位符
* */
public void findUserGetOnlyClass() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
//描写hql语句
String hql = "FROM User WHERE name = ? ";
//创建查询对象
Query createQuery = session.createQuery(hql)
.setString(0,"张三");
//获取唯一结果并进行强制转换
User user = (User)createQuery.uniqueResult();
//打印结果集
System.out.println(user);
}
结果显示：

注:当查询的结果不唯一，而调用uniqueResult()方法会出现如下情况——方法终止，报错等

1.4：多表联查

@Test
/**
*多表联查主表所有信息
* */
public void findAllZJ() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
//描写hql语句
String hql = "SELECT z FROM ZJ z,Singer s WHERE z.singer.id = s.id ";
//创建查询对象
Query createQuery = session.createQuery(hql);
//获取唯一结果并进行强制转换
List list = createQuery.list();
//打印结果集
System.out.println(list);
}

结果显示：

注：.多表查询时需要从select 开始，否则你有多少个表底层就会帮你查多少个表的信息，其次会将其信息转为地址：以为是集合嵌套集合的形式出现的不方便使用。图下表示FROM 书写的hql的结果：

1.5JOIN 连接查询:(案例left join)

@Test
/**
*hql left join
* */
public void findAllZJ() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
//描写hql语句
String hql = " SELECT z FROM ZJ AS z LEFT JOIN z.singer ";
//创建查询对象
Query createQuery = session.createQuery(hql);
//获取唯一结果并进行强制转换
List list = createQuery.list();
//打印结果集
System.out.println(list);
}

注：

1.查询时不能使用 on 关键字， 因为HQL不能解析 on 关键字

2.使用时，从select 写起，否则会帮你查询的结果出现集合嵌套集合（即每个相关表的信息多会出现），打印信息也会变成地址，容易造成误解。

3.写入查询的主表，left join 应当书写 主表实例类中需要联合查询的对象

报错代码片段：

- unexpected token on：无法解析 on
- Path expected for join! ： 不认识left join

报错原因：无法解析 join 和 on

解决方法：规避删除 on ，检查项目，获将join换成Where条件查询

1.6删除：

代码

@Test
/**
*hql删除
* */
public void deleteUserByHql() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
//描写hql语句
String hql = "delete User WHERE id = ?";
//创建查询对象
Query createQuery = session.createQuery(hql);
//放置信息
createQuery.setInteger(0, 1);
//执行hql
createQuery.executeUpdate();
}
执行结果：

注：

1.删改使用的执行方式是executeUpdate();

2.hibernate是面向对象的因此hql不能使用insert进行添加操作

1.7修改：

代码

@Test
/**
* hql修改
* */
public void updateUserByHql() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
//描写hql语句
String hql = "update User set name = ? WHERE id = ?";
//创建查询对象
Query createQuery = session.createQuery(hql);
//放置信息
createQuery.setString(0, "赵六");
createQuery.setInteger(1, 2);
//执行hql
createQuery.executeUpdate();
}
执行结果：

Sql:

1.1查询所有记录：

代码：

@Test
/**
* 简单查询所有的user数据
* */
public void findAllUserBySql() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
//描写sql语句
String sql = "select * from t_users7 ";
//创建查询对象
SQLQuery createSQLQuery = session.createSQLQuery(sql);
//获取唯一结果并进行强制转换
List list = createSQLQuery.list();
//打印结果集
System.out.println(list);
}

结果显示：

注：
1.查询时需要注入查询对象的的映射，多表联查只需要注入主表关系，因为主表已经关联了其余表单

未加入实体类打印的信息为地址值；（如下所示）

2.和hql语句使用差不多；使用时也分为拼接和占位两种方法

1.2条件查询记录（占位符方式）：

@Test
/**
* 条件查询
* */
public void findAllUserBySql1() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
//描写sql语句
String sql = "select * from t_users7 WHERE user_name = ? ";
//创建查询对象
SQLQuery createSQLQuery = session.createSQLQuery(sql);
//链式查询（将条件全部添加到一条语句上）
createSQLQuery.addEntity(User.class)
.setString(0, "张三");

//获取唯一结果并进行强制转换
List list = createSQLQuery.list();
//打印结果集
System.out.println(list);
}
结果显示：

注：

1.和Hql 的区别是sqlQuery链式查询不能从获取查询对象开始时，即本案例的SQLQuery createSQLQuery = session.createSQLQuery(sql);；

1.3多表查询

@Test
public void findAllZJBySql1() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
//描写sql语句
String sql = " select * from t_zjs7 z , t_singers7 s where z.zj_singer_id = s.singer_id ";
//创建查询对象
SQLQuery createSQLQuery = session.createSQLQuery(sql)
.addEntity(ZJ.class);
//获取唯一结果并进行强制转换
List list = createSQLQuery.list();
//打印结果集
System.out.println(list);
}

结果显示：

1.4添加：

@Test
/**
* sql添加
* */
public void addUser() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
//描写sql语句
String sql = "insert into t_users7 (user_id,user_name,user_age)values (null,?,?)";
//创建查询对象
SQLQuery createSQLQuery = session.createSQLQuery(sql);

//放置条件
createSQLQuery.setInteger(1, 17)
.setString(0, "皮卡丘");

//执行添加语句
createSQLQuery.executeUpdate();
}
结果显示：

注：

1.增删改的方法都是executeUpdate（）方法执行

2.使用占位符输出的格式信息都能很好的保密（即客户端也无法查看完整的语句）。

使用的类

1.实例类：

1.1：歌手类：

public class Singer {
private Integer id;
private String name;
public Singer() {
super();
// TODO Auto-generated constructor stub
}
public Singer(Integer id, String name) {
super();
this.id = id;
this.name = name;
}

@Override
public String toString() {
return "Singer [id=" + id + ", name=" + name + "]";
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

歌手的配置信息：

1.2：专辑类：

public class ZJ {
private String name;
private Integer id;
private Date datea;
private Double price;
private Singer singer;
@Override
public String toString() {
return "ZJ [name=" + name + ", id=" + id + ", datea=" + datea + ", price=" + price + ", singer=" + singer + "]";
}
public ZJ(String name, Integer id, Date datea, Double price, Singer singer) {
super();
this.name = name;
this.id = id;
this.datea = datea;
this.price = price;
this.singer = singer;
}
public ZJ() {
super();
// TODO Auto-generated constructor stub
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Date getDatea() {
return datea;
}
public void setDatea(Date datea) {
this.datea = datea;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
public Singer getSinger() {
return singer;
}
public void setSinger(Singer singer) {
this.singer = singer;
}
}

1.2：专辑类配置信息：

1.3用户类：

public class User {
private Integer id;
private String name;
private Integer age;
public User() {
super();
// TODO Auto-generated constructor stub
}
public User(Integer id, String name, Integer age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}

1.3：用户类配置信息：

hibernate配置：

com.mysql.jdbc.Driver
jdbc:mysql:///hibernate
root
root

org.hibernate.dialect.MySQLDialect

true

true

update

使用jar包：

日志配置文件：log4j.properties>:

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