Hibernate三种常用查询API：标准，HQL，SQL
使用工具：
hibernate的核心jar包及配置文件和映射文件
log4j打印日志文件及jar及配置文件3.eclipse开发，navicat数据库可视化工具，mysql4.连接数据库的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;
}
}
歌手的配置信息：
<?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.web.dto.Singer" table="t_singers7">
<!-- 建立类中的属性与表中的主键对应 -->
<id name="id" column="singer_id" >
<generator class="native"/>
</id>
<!-- 建立类中的普通的属性和表的字段的对应 -->
<property name="name" column="singer_name"/>
</class>
</hibernate-mapping>
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：专辑类配置信息：
<?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.web.dto.ZJ" table="t_zjs7">
<!-- 建立类中的属性与表中的主键对应 -->
<id name="id" column="zj_id" >
<generator class="native"/>
</id>
<!-- 建立类中的普通的属性和表的字段的对应 -->
<property name="datea" column="zj_datea"/>
<property name="name" column="zj_name"/>
<property name="price" column="zj_price"/>
<many-to-one name="singer" column="zj_singer_id" lazy="false" class="com.web.dto.Singer"></many-to-one>
</class>
</hibernate-mapping>
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：用户类配置信息：
<?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.web.dto.User" table="t_users7">
<!-- 建立类中的属性与表中的主键对应 -->
<id name="id" column="user_id" >
<generator class="native"/>
</id>
<!-- 建立类中的普通的属性和表的字段的对应 -->
<property name="age" column="user_age"/>
<property name="name" column="user_name"/>
</class>
</hibernate-mapping>
hibernate配置：
<?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</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</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>
<!-- 自动创建表 -->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 映射文件 -->
<mapping resource="com/web/dto/ZJ.hbm.xml"/>
<mapping resource="com/web/dto/Singer.hbm.xml"/>
<mapping resource="com/web/dto/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
使用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
转载于:https://www.cnblogs.com/yizhichenfen/p/11319681.html
