Hibernate学习笔记

于 2020-07-29 16:56:31 发布
阅读量282 收藏
点赞数 1
分类专栏： Hibernate学习笔记 文章标签： hibernate java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SmallSinkHole/article/details/107665605
版权

HIbernate学习笔记


最近在学习Hibernate框架，好记性不如烂笔头，记下笔记方便自己以后复习。

b站上的Hibernate框架-黑马程序员：https://www.bilibili.com/video/BV1Cx411s7cK?from=search&seid=16089186901542258123

day01-入门和基本操作

1.Hibernate框架是什么？

  1. Hibernate框架属于JavaEE三层架构种的Dao层架构。
  2. Hibernate底层代码就是jdbc，实现了对jdbc的封装，使用Hibernate可以让我们不需要再写复杂的jdbc代码，不用写sql语句实现。
  3. Hibernate是开源的轻量级框架。
  4. Hibernate是一种ORM框架，全称为 Object_Relative DateBase-Mapping，在Java对象与关系数据库之间建立某种映射，以实现直接存取Java对象！
  5. 在DAO层操作XML，将数据封装到XML文件上，读写XML文件数据实现CRUD

2.Hibernate的ORM思想

  1. O代表的是Objcet，R代表的是Relative，M代表的是Mapping。ORM（Object Relative
    Mapping）对象关系映射。ORM关注的是对象和数据库种的列的关系。

  2. 操作条件：
    2.1. 表和实体类一一对应
    2.2表和类对应，表字段和类属性一一对应
    2.3类型的对应

  3. 使用配置文件方式完成。不需要操作表，操作表对应的实体类对象就可以了。

3. 引入相关的JAR包

  1. 我使用的是 hibernate-release-5.4.18.Final 版本。

  2. lib里面的required包以及jpa包是必须要的Hibernate的lib目录结构

  3. 还需要导入相关的数据库连接包

  4. hibernate有日志信息输出，但是hibernate本身没有日志输出的jar包，导入其他日志的jar包。 数据库连接包和日志输出包

4.创建实体类和配置文件

  1. 使用Hibernate时，不需要自己手动创建表，Hibernate可以帮忙把表创建。（但是数据库还是要自己创建）

  2. Hibernate要求实体类有一个属性唯一的。

    package com.landray.entity;

public class User {
	/*
	 * hibernate要求实体类有一个属性唯一的
	 */
	private Integer uid;
	private String username;
	private String password;
	private String address;
	public Integer getUid() {
		return uid;
	}
	public void setUid(Integer uid) {
		this.uid = uid;
	}
	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;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	@Override
	public String toString() {
		return "User [uid=" + uid + ", username=" + username + ", password=" + password + ", address=" + address + "]";
	}	
}

  3. 配置实体类和数据库表一一对应关系（映射）
    3.1创建xml格式的配置文件User.hbm.xml
    映射配置文件名称和位置没有固定的要求
    建议：一般是在实体类包里面创建，名称一般为：实体类名称.hbm.xml
    3.2配置是xml格式，在配置文件中首先引入xml约束
    在Hibernate里面引入的约束为dtd约束
    Hibernate映射约束

    <?xml version="1.0" encoding="UTF-8"?>
<!-- dtd约束 -->
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 配置映射关系 -->
<hibernate-mapping>
	<!-- 1.配置类和表对应 -->
	<!-- name属性：实体类的全路径 table属性：数据库表名称 -->
	<class name="com.landray.entity.User" table="t_user">
		<!-- 2.配置实体类id和表id对应 hibernate要求实体类有一个属性唯一值 hibernate要求表有字段作为唯一值 -->
		<!-- id标签 name属性：实体类里面id属性名称 column属性：生成的表字段名称 -->
		<id name="uid" column="uid">
			<!-- 设置数据库表id的增长策略 native:生成表id值就是主键自动增长 -->
			<generator class="native"></generator>
		</id>
		<!-- 配置其他属性和表字段对应 name属性：实体类属性名称 column属性：生成的表字段名称 -->
		<property name="username" column="username" ></property>
		<property name="password" column="password" ></property>
		<property name="address" column="address" ></property>
	</class>
</hibernate-mapping>

  4. 创建Hibernate的核心配置文件
    5.1核心配置文件格式xml，但是位置和名称都是固定的
    名称：必须hibernate.hbm.cml
    位置：在src下面
    5.2引入dtd约束
    Hibernate核心配置文件的dtd约束

    5.3Hibernate操作过程中，只会加载核心配置文件，其他配置文件不会加载。

    <?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>
		<!-- 1.配置数据库信息 /必须的 -->
		<property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_day01?useSSL=false&amp;serverTimezone=UTC</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">mgd007</property>

		<!-- 2.配置hibernate信息 /可选的 -->
		<!-- 2.1输出底层的sql语句 -->
		<property name="hibernate.show_sql">true</property>
		<!-- 2.2格式化sql语句 -->
		<property name="hibernate.format_sql">true</property>
		<!-- 2.3hibernate帮创建表，需要配置之后 update：如果已经有表，更新。如果没有，创建 -->
		<property name="hibernate.hbm2ddl.auto">update</property>
		<!-- 2.4配置数据库方言 在mysql里面实现分页 关键字limit，只能使用mysql里面;在oracle数据库，实现分页rownum 
			让hibernate框架识别不同数据库的语句 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>

		<!-- 3.把映射文件放在核心配置文件中 /必须的 -->
		<mapping resource="com/landray/entity/User.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

5.实现操作的步骤

  1. 加载Hibernate核心配置文件

  2. 创建SessionFactory

  3. 使用SessionFactory创建session对象

  4. 开启事务

  5. 具体的CRUD

  6. 提交事务

  7. 关闭资源

    package com.landray.hibernatetest;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.jupiter.api.Test;

import com.landray.entity.User;


public class HibernateDemo {

	@Test
	public void testadd() {
		//1.加载Hibernate核心配置文件
		/*
		 * 默认到src下面找到名称是hibernate.cfg.xml
		 * 在hibernate里面封装对象
		 */
		Configuration cfg=new Configuration();
		cfg.configure();
		//2.创建SessionFactory对象
		/*
		 * 读取hibernate核心配置文件内容，创建SessionFactory
		 * 在过程中，根据映射关系，在配置数据库里面把表创建
		 */
		SessionFactory sFactory=cfg.buildSessionFactory();
		//3.使用SessionFactory创建Session
		Session session=sFactory.openSession();
		//4.开启事务
		Transaction transaction=session.beginTransaction();
		//5.写具体的逻辑，CRUD
		/*
		 * 添加功能-调用Session的方法实现添加
		 */
		User user=new User();
		user.setUsername("tom");
		user.setPassword("456");
		user.setAddress("USA");

		session.save(user);
		//6.提交事务
		transaction.commit();
		//7.关闭连接
		session.close();
		sFactory.close();

	}
	
}

    运行效果图：
    运行结果

6.配置文件详解

  1. 映射配置文件
    1.1映射配置文件名称和位置没有固定要求。
    1.2映射配置文件中，标签name属性值写实体类相关内容。

    （1）class标签name属性值实体类全路径。
（2）id标签和property标签name属性值 实体类属性名称。

    1.3id标签和property标签，column属性可以省略的（不写值和name属性值一样）。
    1.4 property标签type属性，设置生成表字段的类型，自动对应类型。

  2. 核心配置文件
    2.1位置和名称固定
    2.2配置三部分要求

    （1）数据库部分必须的
（2）hibernate部分可选的
（3）映射文件必须的

7.Hibernate核心api

  1. Configuration

    //到src下面找到名称hibernate.cfg.xml配置文件，创建对象
//把配置文件放到对象里面（加载核心配置文件）
Configuration cfg=new Configuration();
cfg.configure();

  2. SessionFactory

  • 2.1使用configuration对象创建sessionFactory对象 创建sessionfactory过程中做事情：根据核心配置文件中，有数据库配置，有映射文件部分，到数据库里面根据映射关系把表创建。

       <!--hibernate帮创建表，需要配置之后 update：如果已经有表，更新。如果没有，创建 -->
   <property name="hibernate.hbm2ddl.auto">update</property>

  • 2.2创建sessionFactory过程中，这个过程特别耗资源的，所以一般建议一个项目一般创建一个SessionFactory对象。这里可以选择单例模式或者写工具类。
    我这里选择写了一个工具类。通过写静态代码块实现。（静态代码块在类加载的时候执行，只执行一次）。

    package com.landray.utils;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {
	
	static Configuration configuration=null;
	static SessionFactory sessionFactory=null;
	
	//静态代码块实现 
	static {
		//加载配置文件
		configuration=new Configuration();
		configuration.configure();
		sessionFactory=configuration.buildSessionFactory();		
	}
	//提供方法返回sessionfactory
	public static SessionFactory getSessionFactory() {
		return sessionFactory;	
	}
	public static void main(String[] args) {
	}		
}

  1. Session
    3.1Session类似与jdbc里面的connection
    3.2调用session里面不同的方法实现crud操作
    3.3session对象是单线程对象，不能共用，只能自己使用

  2. Transaction
    4.1事务对象

    Transaction transaction=session.beginTransaction();

    4.2事务概念-事务的4个特性

    原子性，一致性，隔离性，持久性。

    4.3事务提交和回滚方法

    commit（）
rollback（）

8.配置文件设置提示

  1. 可以上网

  2. 把约束文件引入到eclipse中

    Windows-->Preferences-->搜索xml c-->选择XML Catalog-->Add-->将对应的约束网址复制到key里面，key type选择URI，在系统里面找到对应的约束文件。

    引入约束到eclipse
    添加约束条件

day02-Hibernate概念和api使用

1.实体类主键生成策略

  1. 实体类里面属性是私有的
  2. 私有属性使用公开的set，get方法进行操作
  3. 秋实体类有属性作为唯一值（一般使用id值）
  4. 实体类属性建议不使用基本数据类型，而是使用对应的基本数据类型的包装类。
    1.八个基本数据类型对应的包装类
    八个基本数据类型对应的包装类
    2.比如 表示学生的分数，假如 int score;比如学生得了0分 ，int score = 0;如果表示学生没有参加考试，int score = 0;不能准确表示学生是否参加考试
    解决：
使用包装类可以了，
Integer score = 0，表示学生得了0分；
表示学生没有参加考试，Integer score = null;

2.Hibernate主键生成策略

  1. hibernate要求实体类里面有一个属性作为唯一值，对应表主键，主键可以不同生成策略

  2. Hibernate提供相应的API能自动生成数据库表，说到表，一定会设计到的一个概念就是主键，主键是由程序自动生成的，不应该由用户自己输入

    <id name="id">
    <generator class="主键生成策略名称" />      
</id>

  3. 主键生成策略
    主键生成策略

  4. 演示生成策略值 uuid

    • 使用uuid生成策略，实体类id属性类型 必须 字符串类型
    		private String uid;
    • 配置部分写出uuid值
    		<generator class="uuid"></generator>

    演示生成策略值 uuid
    演示生成策略值 uuid

3.实体类操作

对实体类进行crud操作

  1. 添加操作
		//调用session里面的save方法实现
		//添加功能
		User user=new User();
		user.setUsername("susu");
		user.setPassword("god");
		user.setAddress("earth");
		//调用session的方法实现添加
		session.save(user);
  1. 根据id进行查询
		//4.根据id查询功能		
		/*
		 *调用Session里面的get方法
		 *第一个参数：实体类的Class
		 *第二个参数：id值 
		 */
		User user=session.get(User.class, 1);
  1. 修改操作
		//4.修改操作--修改id为2记录的username
		//4.1根据id进行查询
		User user=session.get(User.class, 2);
		//4.2设置返回user对象要修改的值
		user.setUsername("Koo");
		//4.3调用session的update方法
		//执行过程：到user对象里面找到uid值，根据uid进行修改
		session.update(user);
  1. 删除操作
		//4.删除操作
		//调用session中的delte方法
		//第一种：根据id查询对象
		User user1=session.get(User.class, 2);
		session.delete(user1);
		//第二种：
		User user2=new User();
		user2.setUid(3);
		session.delete(user2);

4.实体类对象状态（概念）

  1. 瞬时态：对象里面没有id值，对象与session没有关联

    		User user=new User();
		user.setUsername("susu");
		user.setPassword("god");
		user.setAddress("earth");

  2. 持久态：对象里面有id值，对象与session关联

    		User user=session.get(User.class, 1);

  3. 托管态：对象有id值，对象与session没有关联

    		User user2=new User();
		user2.setUid(3);

5.Hibernate的一级缓存

  1. 缓存
    数据存到数据库里面，数据库本身是文件系统，使用流方式操作文件效率不是很高。
    （1）把数据存到内存里面，不需要使用流方式，可以直接读取内存中数据
    （2）把数据放到内存中，提供读取效率

  2. Hibernate缓存
    （1） hibernate框架中提供很多优化方式，hibernate的缓存就是一个优化方式
    （2）hiber缓存特点

    第一类 hibernate的一级缓存
（1）hibernate的一级缓存默认打开的
（2）hibernate的一级缓存使用范围，是session范围，从session创建到session关闭范围
（3）hibernate的一级缓存中，存储数据必须 持久态数据

第二类 hibernate的二级缓存
（1）目前已经不使用了，替代技术 redis
（2）二级缓存默认不是打开的，需要配置
（3）二级缓存使用范围，是sessionFactory范围

  3. 验证一级缓存存在

    	/*
	 *验证一级缓存存在
	 *1.当进行查询时，首先查询一级缓存操作 
	 *2.当一级缓存没有数据时，才会去查询数据库，返回user对象（持久态）
	 *3.然后将user对象（持久态）放到一级缓存中
	 */
		// 4.根据id查询
		// (1)根据uid=5进行查询，执行第一个get方法是否查询数据库，是否发送了sql语句
		User user = session.get(User.class, 5);
		System.out.println(user);
		// (2)再次根据uid=5进行查询，执行第二个get方法是否查询数据库，是否发送了sql语句
		User user2 = session.get(User.class, 5);
		System.out.println(user2);

验证一级缓存

  1. HIbernate一级缓存—— 持久态自动更新数据库
    		// 4.修改操作
		// 4.1根据id查询
		/*
		 * 1. 把返回user持久态对象放到一级缓存中
		 * 2.把user对象放在一级缓存对应的快照区里面
		 */
		User user = session.get(User.class, 5);
		// 4.2设置返回对象值
		/*
		 * 1.修改user持久态对象里面的值 
		 * 2.同时修改一级缓存中内容（修改一级缓存内容，但是不会修改一级缓存对应的快照区内容）
		 */
		user.setUsername("liHua");
		// 4.3调用方法实现
		// session.update(user);

6.Hibernate事务代码规范写法

代码结构
try {
  开启事务
  提交事务
}catch() {
  回滚事务
}finally {
  关闭
}


	/*
	 * 事务规范代码
	 */
	@Test
	public void testTx() {
//		SessionFactory sFactory=null;
		Session session = null;
		Transaction transaction = null;
		try {
			// 1.使用工具类，得到SessionFactory
//			sFactory=HibernateUtils.getSessionFactory();
			// 2.使用SessionFactory创建Session
//			session=sFactory.openSession();		
			// 和本地线程绑定的session
			session = HibernateUtils.getSessionobject();
			// 3.开启事务
			transaction = session.beginTransaction();
			// 4.添加操作
			User user = new User();
			user.setUsername("xiaomama");
			user.setPassword("nana");
			user.setAddress("chengdu");

			session.save(user);

//			int i=10/0;
			// 5.提交事务
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			// 5.出现异常，回滚事务
			transaction.rollback();
		} finally {
			// 6.关闭连接
//			session.close();
//			sFactory.close();
		}

	}

7.Hibernate绑定Session

  1. 在hibernate核心配置文件中配置在hibernate核心配置文件中配置

  2. 调用sessionFactory里面的方法得到

    package com.landray.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {
	
	static Configuration configuration=null;
	static SessionFactory sessionFactory=null;
	
	//静态代码块实现 
	static {
		//加载配置文件
		configuration=new Configuration();
		configuration.configure();
		sessionFactory=configuration.buildSessionFactory();		
	}
	//提供返回与本地线程绑定的session的方法
	//注意：获取与本地线程绑定session时候，关闭session报错，不需要手动关闭了
	public static Session getSessionobject() {
		//getCurrentSession方法会自动关闭Session
		return sessionFactory.getCurrentSession();
		//Opensession需要手动关闭Session
		//return sessionFactory.openSession();
	}
	//提供方法返回sessionfactory
	public static SessionFactory getSessionFactory() {
		return sessionFactory;	
	}
	public static void main(String[] args) {
		
		
	}
	
}

8.Hibernate中的api的使用

  1. Query对象

    1 使用query对象，不需要写sql语句，但是写hql语句
（1）hql：hibernate query language，hibernate提供查询语言，这个hql语句和普通sql语句很相似
（2）hql和sql语句区别：
- 使用sql操作表和表字段
- 使用hql操作实体类和属性

2 查询所有hql语句：
（1）from 实体类名称

3 Query对象使用
（1）创建Query对象
（2）调用query对象里面的方法得到结果

  2. Criteria对象

    1 使用这个对象查询操作，但是使用这个对象时候，不需要写语句，直接调用方法实现

2 实现过程
（1）创建criteria对象
（2）调用对象里面的方法得到结果

  3. SQLQuery对象

    1 使用hibernate时候，调用底层sql实现

2 实现过程
（1）创建对象
（2）调用对象的方法得到结果

day03-HIbernate配置一对多和多对多

1.Hibernate的一对多操作

以客户和联系人为例：客户是一，联系人是多。

（1）一对多映射配置

  1. 创建客户和联系人实体类，并且让他们互相表示
    （1）一个客户里面有多个联系人

    package com.landray.entity;

import java.util.HashSet;
import java.util.Set;

public class Customer {
private Integer cid;
private String custName;
private String custLevel;
private String custSource;
private String custPhone;
private String custMobile;
//hibernate要求使用集合表示多的数据，使用set集合
private Set<Linkman> setLinkman=new HashSet<Linkman>();
public Integer getCid() {
	return cid;
}
public void setCid(Integer cid) {
	this.cid = cid;
}
public String getCustName() {
	return custName;
}
public void setCustName(String custName) {
	this.custName = custName;
}
public String getCustLevel() {
	return custLevel;
}
public void setCustLevel(String custLevel) {
	this.custLevel = custLevel;
}
public String getCustSource() {
	return custSource;
}
public void setCustSource(String custSource) {
	this.custSource = custSource;
}
public String getCustPhone() {
	return custPhone;
}
public void setCustPhone(String custPhone) {
	this.custPhone = custPhone;
}
public String getCustMobile() {
	return custMobile;
}
public void setCustMobile(String custMobile) {
	this.custMobile = custMobile;
}
public Set<Linkman> getSetLinkman() {
	return setLinkman;
}
public void setSetLinkman(Set<Linkman> setLinkman) {
	this.setLinkman = setLinkman;
}
@Override
public String toString() {
	return "Customer [cid=" + cid + ", custName=" + custName + ", custLevel=" + custLevel + ", custSource="
			+ custSource + ", custPhone=" + custPhone + ", custMobile=" + custMobile + ", setLinkman=" + setLinkman
			+ "]";
}
}

    （2）一个联系人只能属于一个客户

    package com.landray.entity;

public class Linkman {
	private Integer lkm_id;
	private String lkm_name;
	private String lkm_gender;
	private String lkm_phone;
	private Customer customer;
		
	public Customer getCustomer() {
		return customer;
	}
	public void setCustomer(Customer customer) {
		this.customer = customer;
	}
	public Integer getLkm_id() {
		return lkm_id;
	}
	public void setLkm_id(Integer lkm_id) {
		this.lkm_id = lkm_id;
	}
	public String getLkm_name() {
		return lkm_name;
	}
	public void setLkm_name(String lkm_name) {
		this.lkm_name = lkm_name;
	}
	public String getLkm_gender() {
		return lkm_gender;
	}
	public void setLkm_gender(String lkm_gender) {
		this.lkm_gender = lkm_gender;
	}
	public String getLkm_phone() {
		return lkm_phone;
	}
	public void setLkm_phone(String lkm_phone) {
		this.lkm_phone = lkm_phone;
	}
	@Override
	public String toString() {
		return "Linkman [lkm_id=" + lkm_id + ", lkm_name=" + lkm_name + ", lkm_gender=" + lkm_gender + ", lkm_phone="
				+ lkm_phone + ", customer=" + customer + "]";
	}	
}

  2. 配置映射关系
    （1）一般一个实体类对应一个映射文件
    （2）把映射最基本配置完成
    （3）在映射文件中，配置一对多关系。

    在客户的映射文件中，表示所有联系人：

    <?xml version="1.0" encoding="UTF-8"?>
<!-- dtd约束 -->
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 配置映射关系 -->
<hibernate-mapping>
	<!-- 1.配置类和表对应 -->
	<!-- name属性：实体类的全路径 table属性：数据库表名称 -->
	<class name="com.landray.entity.Customer" table="cust">
		<!-- 2.配置实体类id和表id对应 hibernate要求实体类有一个属性唯一值 hibernate要求表有字段作为唯一值 -->
		<!-- id标签 name属性：实体类里面id属性名称 column属性：生成的表字段名称 -->
		<id name="cid" column="cid">
			<!-- 设置数据库表id的增长策略 native:生成表id值就是主键自动增长 -->
			<generator class="native"></generator>
		</id>
		<!-- 配置其他属性和表字段对应 name属性：实体类属性名称 column属性：生成的表字段名称 -->		
		<property name="custName" column="custName" ></property>
		<property name="custLevel" column="custLevel" ></property>
		<property name="custSource" column="custSource" ></property>
		<property name="custPhone" column="custPhone" ></property>
		<property name="custMobile" column="custMobile" ></property>
		<!-- 表示所有的联系人
		使用set标签表示所有人
		set标签里面有name属性：
		属性值写在客户实体类里面表示 联系人的set集合名称
		cascade="save-update,delete"
		inverse属性默认值是false
		-->
		<set name="setLinkman"  >
		<!-- 一对多建表，有外键
		hibernate机制：双向维护外键，在一和多那一方都要配置外键 -->
		<key column="clid"></key>	
		<!-- 客户所有的联系人，class里面写联系人实体类全路径 -->
		<one-to-many class="com.landray.entity.Linkman"/>
		</set>
	</class>
</hibernate-mapping>

    在联系人映射文件中，表示所属客户:

    <?xml version="1.0" encoding="UTF-8"?>
<!-- dtd约束 -->
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 配置映射关系 -->
<hibernate-mapping>
	<!-- 1.配置类和表对应 -->
	<!-- name属性：实体类的全路径 table属性：数据库表名称 -->
	<class name="com.landray.entity.Linkman" table="linkman">
		<!-- 2.配置实体类id和表id对应 hibernate要求实体类有一个属性唯一值 hibernate要求表有字段作为唯一值 -->
		<!-- id标签 name属性：实体类里面id属性名称 column属性：生成的表字段名称 -->
		<id name="lkm_id" column="lkm_id">
			<!-- 设置数据库表id的增长策略 native:生成表id值就是主键自动增长 -->
			<generator class="native"></generator>
		</id>
		<!-- 配置其他属性和表字段对应name属性：实体类属性名称 column属性：生成的表字段名称 -->
		<property name="lkm_name" column="lkm_name"></property>
		<property name="lkm_gender" column="lkm_gender"></property>
		<property name="lkm_phone" column="lkm_phone"></property>
		<!-- 表示联系人所属客户 
		name属性：因为在联系人实体类使用customer对象表示，写customer名称 
		class属性：customer全路径 
		column属性：外键名称 -->
		<many-to-one name="customer"
			class="com.landray.entity.Customer" column="clid"></many-to-one>
	</class>
</hibernate-mapping>

    （4）创建核心配置文件，把映射文件引入到核心配置文件中

    <!-- 3.把映射文件放在核心配置文件中 /必须的 -->
		<mapping resource="/com/landray/entity/Customer.hbm.xml"/>
		<mapping resource="com/landray/entity/Linkman.hbm.xml"/>

    一对多建表

（2）一对多级联保存

	/*
	 * 演示一对多级联保存-复杂写法
	 */
	@Test
	public void testAddDemo1() {
		Session session = null;
		Transaction transaction = null;
		try {		
			session = HibernateUtils.getSessionobject();
			// 开启事务
			transaction = session.beginTransaction();
			//添加一个客户，为这个客户添加联系人
			// 1.创建客户和联系人对象
			Customer customer=new Customer();
			customer.setCustName("heima");
			customer.setCustLevel("vip");
			customer.setCustSource("internet");
			customer.setCustPhone("12123");
			customer.setCustMobile("12306");
			
			Linkman linkman=new  Linkman();
			linkman.setLkm_name("xiaomei");
			linkman.setLkm_gender("boy");
			linkman.setLkm_phone("123456");

			// 2.在客户里面表示联系人，在联系人表示客户
			//建立客户对象和联系人对象关系
			//2.1把联系人对象放在客户对象的set集合里面
			customer.getSetLinkman().add(linkman);
			//2.2把客户对象放在联系人里面
			linkman.setCustomer(customer);
			//3.保存到数据库
			session.save(customer);
			session.save(linkman);

			// 提交事务
			transaction.commit();

		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			// 关闭操作
			//session.close();
		}
	}

	/*
	 * 演示一对多级联保存-简化写法
	 * 第一步 在客户映射文件中进行配置:在客户映射文件里面set标签进行配置
	 * <set name="setLinkman" cascade="save-update">
	 * 第二步 创建客户和联系人对象，只需要把联系人放到客户里面就可以了，最终只需要保存客户就可以了
	 */
	@Test
	public void testAddDemo2() {
		Session session = null;
		Transaction transaction = null;
		try {		
			session = HibernateUtils.getSessionobject();
			// 开启事务
			transaction = session.beginTransaction();
			//添加一个客户，为这个客户添加联系人
			// 1.创建客户和联系人对象
			Customer customer=new Customer();
			customer.setCustName("nana");
			customer.setCustLevel("normal");
			customer.setCustSource("internet");
			customer.setCustPhone("12123");
			customer.setCustMobile("12306");
			
			Linkman linkman=new  Linkman();
			linkman.setLkm_name("meimei");
			linkman.setLkm_gender("boy");
			linkman.setLkm_phone("123456");

			// 2.把联系人放在客户里面
			customer.getSetLinkman().add(linkman);
			
			// 3.保存到数据库
			session.save(customer);

			// 提交事务
			transaction.commit();

		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			// 关闭操作
			//session.close();
		}
	}

（3）一对多级联删除

/*
	 * 一对多级联删除---删除某个客户，把客户里面所有的联系人删除
	 * 第一步 在客户映射文件set标签，进行配置
	 *  <set name="setLinkman" cascade="save-update,delete">
	 * 第二步 在代码中直接删除客户
	 */
	@Test
	public void testAddDemo3() {
		Session session = null;
		Transaction transaction = null;
		try {		
			session = HibernateUtils.getSessionobject();
			// 开启事务
			transaction = session.beginTransaction();
			//删除操作
			//1.根据id查询客户对象
			Customer customer=session.get(Customer.class, 1);
			// 2.调用方法删除
			session.delete(customer);
			// 提交事务
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			// 关闭操作
			//session.close();
		}
	}

		执行过程：
		1.根据id查询客户
		2.根据外键id值查询联系人
		3.把联系人外键设置为null
		4.删除联系人和客户

（4）inverse属性

  1. 因为hibernate双向维护外键，在客户和联系人里面都需要维护外键，修改客户时候修改一次外键，修改联系人时候也修改一次外键，造成效率问题

  2. 解决方式：让其中的一方不维护外键
    一对多里面，让其中一方放弃外键维护

  3. 在放弃关系维护映射文件中，进行配置，在set标签上使用inverse属性

    <set name="setLinkman"  inverse="true">

inverse属性默认值

/*
	 * 一对多级联修改
	 */
	@Test
	public void testAddDemo4() {
		Session session = null;
		Transaction transaction = null;
		try {		
			session = HibernateUtils.getSessionobject();
			// 开启事务
			transaction = session.beginTransaction();
			//修改操作
			//1.根据id查询itma客户，根据id查询xiaomeimei联系人
			Customer customer=session.get(Customer.class, 3);
			Linkman linkman=session.get(Linkman.class, 3);
			//2.设置持久态对象值
			//把联系人放在客户里面
			customer.getSetLinkman().add(linkman);
			//把客户放在联系人里面
			linkman.setCustomer(customer);
			// 提交事务
			transaction.commit();

		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			// 关闭操作
			//session.close();
		}
	}

2.Hibernate的多对多操作

以用户和角色为例演示

（1）多对多映射配置

  1. 让用户和角色两个实体之间互相表示
    用户：

    package com.landray.entity;

import java.util.HashSet;
import java.util.Set;

public class User {
	private Integer user_id;//用户id
	private String user_name;//用户名
	private String user_password;//用户密码
	//一个用户有多个角色
	private Set<Role> setRole=new HashSet<>();
	public Integer getUser_id() {
		return user_id;
	}
	public void setUser_id(Integer user_id) {
		this.user_id = user_id;
	}
	public String getUser_name() {
		return user_name;
	}
	public void setUser_name(String user_name) {
		this.user_name = user_name;
	}
	public String getUser_password() {
		return user_password;
	}
	public void setUser_password(String user_password) {
		this.user_password = user_password;
	}
	public Set<Role> getSetRole() {
		return setRole;
	}
	public void setSetRole(Set<Role> setRole) {
		this.setRole = setRole;
	}
	@Override
	public String toString() {
		return "User [user_id=" + user_id + ", user_name=" + user_name + ", user_password=" + user_password
				+ ", setRole=" + setRole + "]";
	}
	
	
}

    角色：

    package com.landray.entity;

import java.util.HashSet;
import java.util.Set;

public class Role {
	private Integer role_id;//角色id
	private String role_name;//角色名称
	private String role_memo;//角色描述
	//一个角色有多个用户
	private Set<User> setUser=new HashSet<>();
	public Integer getRole_id() {
		return role_id;
	}
	public void setRole_id(Integer role_id) {
		this.role_id = role_id;
	}
	public String getRole_name() {
		return role_name;
	}
	public void setRole_name(String role_name) {
		this.role_name = role_name;
	}
	public String getRole_memo() {
		return role_memo;
	}
	public void setRole_memo(String role_memo) {
		this.role_memo = role_memo;
	}
	public Set<User> getSetUser() {
		return setUser;
	}
	public void setSetUser(Set<User> setUser) {
		this.setUser = setUser;
	}
	@Override
	public String toString() {
		return "Role [role_id=" + role_id + ", role_name=" + role_name + ", role_memo=" + role_memo + ", setUser="
				+ setUser + "]";
	}
	
}

  2. 配置映射关系
    （1）在用户里面进行配置

    <?xml version="1.0" encoding="UTF-8"?>
<!-- dtd约束 -->
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 配置映射关系 -->
<hibernate-mapping>
	<!-- 1.配置类和表对应 -->
	<!-- name属性：实体类的全路径 table属性：数据库表名称 -->
	<class name="com.landray.entity.User" table="user">
		<!-- 2.配置实体类id和表id对应 hibernate要求实体类有一个属性唯一值 hibernate要求表有字段作为唯一值 -->
		<!-- id标签 name属性：实体类里面id属性名称 column属性：生成的表字段名称 -->
		<id name="user_id" column="user_id">
			<!-- 设置数据库表id的增长策略 native:生成表id值就是主键自动增长 -->
			<generator class="native"></generator>
		</id>
		<!-- 配置其他属性和表字段对应 name属性：实体类属性名称 column属性：生成的表字段名称 -->
		<property name="user_name" column="user_name"></property>
		<property name="user_password" column="user_password"></property>
		<!-- 在用户里面表示所 有的角色，使用set标签 name属性：角色set集合名称 table属性：第三张表名称 -->
		<set name="setRole" table="user_role">
			<!-- key标签里面配置 配置当前映射文件在第三张表外键的名称 -->
			<key column="user_id"></key>
			<!-- class：角色实体类全路径 column：校色在第三张表外键名称 -->
			<many-to-many class="com.landray.entity.Role"
				column="role_id"></many-to-many>
		</set>
	</class>
</hibernate-mapping>

    （2）在角色里面进行配置

    <?xml version="1.0" encoding="UTF-8"?>
<!-- dtd约束 -->
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 配置映射关系 -->
<hibernate-mapping>
	<!-- 1.配置类和表对应 -->
	<!-- name属性：实体类的全路径 table属性：数据库表名称 -->
	<class name="com.landray.entity.Role" table="role">
		<!-- 2.配置实体类id和表id对应 hibernate要求实体类有一个属性唯一值 hibernate要求表有字段作为唯一值 -->
		<!-- id标签 name属性：实体类里面id属性名称 column属性：生成的表字段名称 -->
		<id name="role_id" column="role_id">
			<!-- 设置数据库表id的增长策略 native:生成表id值就是主键自动增长 -->
			<generator class="native"></generator>
		</id>
		<!-- 配置其他属性和表字段对应 name属性：实体类属性名称 column属性：生成的表字段名称 -->
		<property name="role_name" column="role_name"></property>
		<property name="role_memo" column="role_memo"></property>
		<!-- 在角色里面表示所有的用户，使用set标签 name属性：角色set集合名称 table属性：第三张表名称 -->
		<set name="setUser" table="user_role">
			<!-- key标签里面配置 配置当前映射文件在第三张表外键的名称 -->
			<key column="role_id"></key>
			<!-- class：角色实体类全路径 column：校色在第三张表外键名称 -->
			<many-to-many class="com.landray.entity.User"
				column="user_id"></many-to-many>
		</set>
	</class>
</hibernate-mapping>

  3. 在核心配置文件中引入

    		<!-- 3.把映射文件放在核心配置文件中 /必须的 -->
		<mapping resource="com/landray/entity/User.hbm.xml"/>
		<mapping resource="com/landray/entity/Role.hbm.xml"/>

（2）多对多级联保存

  1. 在用户配置文件中set标签进行配置，cascade值save-update

    <!-- 在用户里面表示所 有的角色，使用set标签 name属性：角色set集合名称 table属性：第三张表名称 -->
		<set name="setRole" table="user_role" cascade="save-update">
			<!-- key标签里面配置 配置当前映射文件在第三张表外键的名称 -->
			<key column="user_id"></key>
			<!-- class：角色实体类全路径 column：校色在第三张表外键名称 -->
			<many-to-many class="com.landray.entity.Role"
				column="role_id"></many-to-many>
		</set>

  2. 创建用户和角色对象，把角色放到用户里面，最终保存用户就可以了

    /*
	 * 演示多对多级联保存
	 */
	@Test
	public void testAddDemo1() {
		Session session = null;
		Transaction transaction = null;
		try {		
			session = HibernateUtils.getSessionobject();
			// 开启事务
			transaction = session.beginTransaction();
			//添加2个用户，为每个用户添加2个角色
			// 1.创建对象
			User user1=new User();
			user1.setUser_name("mary");
			user1.setUser_password("123");
			User user2=new User();
			user2.setUser_name("tom");
			user2.setUser_password("456");
			
			Role role1=new Role();
			role1.setRole_name("总经理");
			role1.setRole_memo("这是总经理");
			Role role2=new Role();
			role2.setRole_name("服务员");
			role2.setRole_memo("这是服务员");
			Role role3=new Role();
			role3.setRole_name("保洁");
			role3.setRole_memo("这是保洁");
			
			//2.建立关系，把角色放到用户里面
			//user1---role1+role2
			user1.getSetRole().add(role1);
			user1.getSetRole().add(role2);
			
			//user2---role2+role3
			user2.getSetRole().add(role2);
			user2.getSetRole().add(role3);
			
			//3.保存用户
			session.save(user1);
			session.save(user2);
			// 提交事务
			transaction.commit();

		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			// 关闭操作
			//session.close();
		}
	}

（3）多对多级联删除

  1. 在set标签进行配置，cascade值delete

    <!-- 在用户里面表示所 有的角色，使用set标签 name属性：角色set集合名称 table属性：第三张表名称 -->
		<set name="setRole" table="user_role" cascade="save-update,delete">
			<!-- key标签里面配置 配置当前映射文件在第三张表外键的名称 -->
			<key column="user_id"></key>
			<!-- class：角色实体类全路径 column：校色在第三张表外键名称 -->
			<many-to-many class="com.landray.entity.Role"
				column="role_id"></many-to-many>
		</set>

  2. 删除用户

    /*
	 * 演示多对多级联删除
	 */
	@Test
	public void testAddDemo2() {
		Session session = null;
		Transaction transaction = null;
		try {		
			session = HibernateUtils.getSessionobject();
			// 开启事务
			transaction = session.beginTransaction();
			//删除操作
			User user=session.get(User.class, 6);
			session.delete(user);
			// 提交事务
			transaction.commit();

		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			// 关闭操作
			//session.close();
		}
	}

（4）维护第三张表关系

  1. 用户和角色多对多关系，维护关系通过第三张表维护

  2. 让某个用户有某个角色

    • 根据id查询用户和角色
    • 把角色放到用户里面—把角色对象放到用户set集合
      /*
	 * 演示多对多维护第三张表
	 */
	@Test
	public void testAddDemo3() {
		Session session = null;
		Transaction transaction = null;
		try {		
			session = HibernateUtils.getSessionobject();
			// 开启事务
			transaction = session.beginTransaction();
			//让某个用户具有某个角色
			//1让mary有保洁的角色
			User user=session.get(User.class, 7);
			Role role=session.get(Role.class, 9);
			
			//2.把角色放到用户的set集合里面
			user.getSetRole().add(role);				
			// 提交事务
			transaction.commit();

		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			// 关闭操作
			//session.close();
		}
	}

  3. 让某个用户没有某个角色

    • 根据id查询用户和角色
    • 从用户里面把角色去掉—从set集合里面把角色移除
      /*
	 * 演示多对多维护第三张表
	 */
	@Test
	public void testAddDemo4() {
		Session session = null;
		Transaction transaction = null;
		try {		
			session = HibernateUtils.getSessionobject();
			// 开启事务
			transaction = session.beginTransaction();
			//让某个用户没有某个角色
			//1让mary有保洁的角色
			User user=session.get(User.class, 7);
			Role role=session.get(Role.class, 9);
			
			//2.把角色放到用户的set集合里面
			user.getSetRole().remove(role);		
			// 提交事务
			transaction.commit();

		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			// 关闭操作
			//session.close();
		}

day04-Hibernate查询操作

1.Hibernate的查询方式

  1. 对象导航查询
    根据id查询某个客户，在查询这个客户里面的所有联系人。
  2. OID查询
    根据id查询某一条记录，返回对象。
  3. HQL查询
    Queryu对象，写HQL语句实现查询。
    • 查询所有
    • 条件查询
    • 排序查询
    • 分页查询
    • 投影查询
    • 聚集函数使用
  4. QBC查询
    Criteria对象。
    • 查询所有
    • 条件查询
    • 排序查询
    • 分页查询
    • 统计查询
    • 离线查询
  5. 本地sql查询
    SQLQuery对象，使用普通sql实现查询。
  6. hql多表查询
    • 内连接
    • 迫切内连接
    • 左外连接
    • 迫切左外连接
    • 右外连接

2.对象导航查询

	//演示对象导航查询
	@Test
	public void testSelect1(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtils.getSessionobject();
			transaction=session.beginTransaction();
			//根据cid=1查询客户，在根据查询这个客户所有联系人
			Customer customer=session.get(Customer.class, 1);
			//在查询这个客户里面所有联系人
			//直接得到客户里面联系人的set集合
			Set<Linkman> linkmans=customer.getSetLinkman();
			System.out.println(linkmans.size());
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally {
			session.close();
		}
		
	}

3.OID查询

//OID查询
	@Test
	public void testSelect2(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtils.getSessionobject();
			transaction=session.beginTransaction();
			//根据cid=1查询客户，在根据查询这个客户所有联系人
			Customer customer=session.get(Customer.class, 1);
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally {
			session.close();
		}
		
	}

4.HQL查询

hql：hibernate query language，hibernate提供一种查询语言，hql语言和普通sql很相似，区别：普通sql操作数据库表和字段，hql操作实体类和属性。使用hql查询操作时候，使用Query对象：创建Query对象，写hql语句；调用query对象里面的方法得到结果。

  1. 常用的hql语句

    • 查询所有：from 实体类名称
    • 条件查询：from 实体类名称 where 属性名称=?
    • 排序查询：from 实体类名称 order by 实体类属性名称 asc/desc

  2. 查询所有

    	//演示查询所有
	@Test
	public void testSelect1(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtils.getSessionobject();
			transaction=session.beginTransaction();
			//1.创建query对象
			//List<Customer> list
			Query createQuery = session.createQuery("from Customer");
			List<Customer> list = createQuery.list();
			for (Customer customer : list) {
				System.out.println(customer);
			}
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally {
			session.close();
		}
		
	}

  3. 条件查询

    	//演示条件查询
	@Test
	public void testSelect2(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtils.getSessionobject();
			transaction=session.beginTransaction();
			
			//1.创建query对象
			Query createQuery = session.createQuery("from Customer c where c.cid=?0 and c.custName=?1");
			//2.设置条件值
			//像？里面设置值
			/*
			 * setparameter方法两个参数
			 * 第一个参数：int类型是？位置，位置从0开始
			 * 第二个参数：具体参数值
			 */
			//设置第一个？值
			createQuery.setParameter(0, 1);
			//设置第二个？值
			createQuery.setParameter(1, "xiaoma");
			//3.调用方法得到结果
			List<Customer> list = createQuery.list();
			for (Customer customer : list) {
				System.out.println(customer);
			}
			
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally {
			session.close();
		}
		
	}
	
	//模糊条件查询-模糊查询
		@Test
		public void testSelect3(){
			Session session=null;
			Transaction transaction=null;
			try {
				session=HibernateUtils.getSessionobject();
				transaction=session.beginTransaction();
				//1.创建query对象
				Query createQuery = session.createQuery("from Customer c where c.custName like ?0");
				//设置？值
				List<Customer> list = createQuery.setParameter(0, "%xiao%").list();
				for (Customer customer : list) {
					System.out.println(customer);
				}
				transaction.commit();
			} catch (Exception e) {
				e.printStackTrace();
				transaction.rollback();
			}finally {
				session.close();
			}
			
		}

  4. 排序查询

    	//演示排序查询
	@Test
	public void testSelect4(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtils.getSessionobject();
			transaction=session.beginTransaction();
			//1.创建query对象
			Query createQuery = session.createQuery("from Customer order by cid asc");
			//2.调用方法得到结果
			List<Customer> list = createQuery.list();
			for (Customer customer : list) {
				System.out.println(customer);
			}
			
			//1.创建query对象
			Query createQuery1 = session.createQuery("from Customer order by cid desc");
			//2.调用方法得到结果
			List<Customer> list1 = createQuery1.list();
			for (Customer customer : list1) {
				System.out.println(customer);
			}
			
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally {
			session.close();
		}
		
	}

  5. 分页查询

    	//演示分页查询
	@Test
	public void testSelect5(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtils.getSessionobject();
			transaction=session.beginTransaction();
			//1.创建query对象
			//在hql操作中，在语句里面不能写limit，hibernate的Query对象封装了两个方法实现分页操作
			//查询所有数据
			Query createQuery = session.createQuery("from Customer ");
			//2.设置分页数据
			//2.设置开始/结束位置
			createQuery.setFirstResult(0).setMaxResults(2);
			//2.调用方法得到结果
			List<Customer> list = createQuery.list();
			for (Customer customer : list) {
				System.out.println(customer);
			}			
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally {
			session.close();
		}
		
	}

  6. 投影查询

    	// 演示投影查询
	@Test
	public void testSelect6() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();
			// 1.创建query对象

			Query createQuery = session.createQuery("select custName from Customer");
			List<Object> list = createQuery.list();
			for (Object object : list) {
				System.out.println(object);
			}
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}

  7. 聚集函数使用

    • 常用的聚集函数-count，sun，avg，max，min。
    • hql聚集函数语句写法
      查询表记录数—select count(*) from 实体类名称
    	// 演示查询-聚集函数的使用
	@Test
	public void testSelect7() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();
			// 1.创建query对象

			Query createQuery = session.createQuery("select count(*) from Customer");

			// 2.调用方法得到结果
			Object uniqueResult = createQuery.uniqueResult();
			System.out.println(uniqueResult);

			/*
			 * 返回int类型 不能直接从obj转换成int，要先转换成long在转换成int
			 */
			Long count_l = (Long) uniqueResult;
			int count = count_l.intValue();
			System.out.println(count);

			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}

5.QBC查询

使用hql查询需要写hql语句实现，但是使用qbc时候，不需要写语句了，使用方法实现。使用qbc时候，操作实体类和属性，用Criteria对象实现。

  1. 查询所有

    	// 演示查询所有
	@Test
	public void testSelect1() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();
			// 1.创建CriteriaBuilder对象
			CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
			// 2.获取criteriaQuery对象
			CriteriaQuery<Customer> createQuery = criteriaBuilder.createQuery(Customer.class);
			// 3.指定根条件
			createQuery.from(Customer.class);
			// 4.执行查询
			List<Customer> resultList = session.createQuery(createQuery).getResultList();
			for (Customer customer : resultList) {
				System.out.println(customer);
			}
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}

  2. 条件查询

    	// 条件查询
	@Test
	public void testSelect3() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();
			// 1.创建CriteriaBuilder对象
			CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
			// 2.获取criteriaQuery对象
			CriteriaQuery<Customer> createQuery = criteriaBuilder.createQuery(Customer.class);
			// 3.指定根条件
			Root<Customer> root = createQuery.from(Customer.class);
			// root.get("name") "name"是实体类的属性名称
			createQuery.where(criteriaBuilder.equal(root.get("cid"), 2));
			createQuery.where(criteriaBuilder.equal(root.get("custName"), "xiaoluo"));

			// 4.执行查询
			List<Customer> resultList = session.createQuery(createQuery).getResultList();
			for (Customer customer : resultList) {
				System.out.println(customer);
			}

			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}

	// 模糊查询
	@Test
	public void testSelect2() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();
			// 1.创建CriteriaBuilder对象
			CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
			// 2.获取criteriaQuery对象
			CriteriaQuery<Customer> createQuery = criteriaBuilder.createQuery(Customer.class);
			// 3.指定根条件
			Root<Customer> root = createQuery.from(Customer.class);
			// root.get("name") "name"是实体类的属性名称
			createQuery.where(criteriaBuilder.like(root.get("custName"), "%xiao%"));

			// 4.执行查询
			List<Customer> resultList = session.createQuery(createQuery).getResultList();
			for (Customer customer : resultList) {
				System.out.println(customer);
			}

			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}

  3. 排序查询

    // 排序查询
	@Test
	public void testSelect4() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();
			// 1.创建CriteriaBuilder对象
			CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
			// 2.获取criteriaQuery对象
			CriteriaQuery<Customer> createQuery = criteriaBuilder.createQuery(Customer.class);
			// 3.指定根条件
			Root<Customer> root = createQuery.from(Customer.class);
			// root.get("name") "name"是实体类的属性名称
			createQuery.orderBy(criteriaBuilder.asc(root.get("cid")));
			createQuery.orderBy(criteriaBuilder.desc(root.get("cid")));
			// 4.执行查询
			List<Customer> resultList = session.createQuery(createQuery).getResultList();
			for (Customer customer : resultList) {
				System.out.println(customer);
			}

			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}

  4. 分页查询

    // 分页查询
	@Test
	public void testSelect5() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();
			// 1.创建CriteriaBuilder对象
			CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
			// 2.获取criteriaQuery对象
			CriteriaQuery<Customer> createQuery = criteriaBuilder.createQuery(Customer.class);
			// 3.指定根条件
			Root<Customer> root = createQuery.from(Customer.class);
			// 4.执行查询
			List<Customer> resultList = session.createQuery(createQuery).setFirstResult(0).setMaxResults(2)
					.getResultList();
			for (Customer customer : resultList) {
				System.out.println(customer);
			}

			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}

  5. 统计查询（未掌握）

  6. 离线查询（未掌握）

List item

6.HQL多表查询

  1. 内连接

    	// 演示hql内连接查询
	/*
	 * 以客户和联系人为例
	 * hql语句写法：from  Customer  c  inner  join  c.setLinkMan
	 */
	@Test
	public void testSelect1() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();

			// 1.创建query对象
			Query createQuery = session.createQuery("from Customer c inner join c.setLinkman");
			//2.返回的list里面每部分是数组形式
			List list = createQuery.list();
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}

  2. 迫切内连接

    	// 演示hql迫切内连接查询
	/*
	 * 和内连接的区别： 内连接返回list中，每部分是数组 
	 * 迫切内连接返回list中，每部分是对象
	 * hql语句写法： from  Customer  c  inner  join  fetch  c.setLinkMan
	 */
	@Test
	public void testSelect2() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();

			// 1.创建query对象
			Query createQuery = session.createQuery("from Customer c inner join fetch c.setLinkman");
			List list = createQuery.list();
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}

  3. 左外连接

    	// 演示hql左外连接查询
	// hql语句写法：from  Customer  c  left  outer  join  c.setLinkMan
	@Test
	public void testSelect3() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();

			// 1.创建query对象
			Query createQuery = session.createQuery("from Customer c left outer join c.setLinkman");
			List list = createQuery.list();
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}

  4. 迫切左外连接

    // 演示hql迫切左外连接查询
	/*
	 * 和左外连接的区别： 左外连接返回list中，每部分是数组 
	 * 迫切左外连接返回list中，每部分是对象
	 * hql语句写法：from  Customer  c  left  outer  join  fetch  c.setLinkMan
	 */
	@Test
	public void testSelect4() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();

			// 1.创建query对象
			Query createQuery = session.createQuery("from Customer c left outer join fetch c.setLinkman");
			List list = createQuery.list();
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}

  5. 右外连接（没有迫切右外连接）

    	// 演示hql右外连接查询
	// hql语句写法：from  Customer  c  right  outer  join  c.setLinkMan
	@Test
	public void testSelect5() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();

			// 1.创建query对象
			Query createQuery = session.createQuery("from Customer c right outer join c.setLinkman");
			List list = createQuery.list();
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}

7.HIbernate检索策略

  1. 检索策略的两种类别

    	//演示检索策略
	/*
	 * hibernate检索策略分为两类：
	 * 1.立即查询：根据id查询，调用get方法，一调用get方法马上发送语句查询数据库
	 * 2.延迟查询：根据id查询，还有load方法，调用load方法不会马上发送语句查询数据，
	 * 	只有得到对象里面的值时候才会发送语句查询数据库
	 * 	延迟查询分为两类：
	 * 2.1.类级别延迟：根据id查询返回实体类对象，调用load方法不会马上发送语句
	 * 2.2.关联级别延迟：查询某个客户，在查询这个客户的所有联系人，
	 * 	查询客户的所有联系人的过程是否需要延迟，这个过程陈伟关联级别延迟
	 */
	
	//演示立即查询检索策略
	@Test
	public void testSelect3(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtils.getSessionobject();
			transaction=session.beginTransaction();
			//根据cid=1客户
			//执行get方法之后，是否发生sql语句
			//调用get方法，马上发送sql语句查询数据库
			Customer customer=session.get(Customer.class, 1);
			
			System.out.println(customer.getCid());
			
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally {
			session.close();
		}
		
	}
	
	//演示延迟查询检索策略-类级别延迟
	@Test
	public void testSelect4(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtils.getSessionobject();
			transaction=session.beginTransaction();
			//根据cid=2客户
			/*
			 * 1.调用load方法之后，不会马上发送sql语句（返回对象里面只有id值）
			 * 2.得到对象里面不是id的其他值时才会发送sql语句
			 * 
			 */
			Customer customer=session.load(Customer.class, 2);
			
			System.out.println(customer.getCid());
			System.out.println(customer.getCustName());
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally {
			session.close();
		}
		
	}
	
	//演示延迟查询检索策略-关联级别延迟
	@Test
	public void testSelect5(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtils.getSessionobject();
			transaction=session.beginTransaction();
			//根据cid=1客户，在查询这个客户里面所有联系人
			Customer customer=session.load(Customer.class, 1);
			//在查询这个客户里面所有联系人
			//直接得到客户里面联系人的set集合
			
			//得到set集合，没有发送sql语句
			Set<Linkman> setLinkman = customer.getSetLinkman();
			//发送sql语句
			System.out.println(setLinkman.size());
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally {
			session.close();
		}
		
	}

  2. 关联级别延迟操作
    映射文件配置：

    <?xml version="1.0" encoding="UTF-8"?>
<!-- dtd约束 -->
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 配置映射关系 -->
<hibernate-mapping>
	<!-- 1.配置类和表对应 -->
	<!-- name属性：实体类的全路径 table属性：数据库表名称 -->
	<class name="com.landray.entity.Customer" table="cust">
		<!-- 2.配置实体类id和表id对应 hibernate要求实体类有一个属性唯一值 hibernate要求表有字段作为唯一值 -->
		<!-- id标签 name属性：实体类里面id属性名称 column属性：生成的表字段名称 -->
		<id name="cid" column="cid">
			<!-- 设置数据库表id的增长策略 native:生成表id值就是主键自动增长 -->
			<generator class="native"></generator>
		</id>
		<!-- 配置其他属性和表字段对应 name属性：实体类属性名称 column属性：生成的表字段名称 -->		
		<property name="custName" column="custName" ></property>
		<property name="custLevel" column="custLevel" ></property>
		<property name="custSource" column="custSource" ></property>
		<property name="custPhone" column="custPhone" ></property>
		<property name="custMobile" column="custMobile" ></property>
		<!-- 表示所有的联系人
		使用set标签表示所有人
		set标签里面有name属性：
		属性值写在客户实体类里面表示 联系人的set集合名称
		cascade="save-update,delete"
		inverse属性默认值是false
		-->
		<!-- 演示延迟查询检索策略——关联级别延迟操作
		 	1.在映射文件中进行配置实现——根据客户得到所有的联系人，在客户映射文件中配置
	  		2.在set标签上使用属性
	  			2.1 fetch：值 select(默认)
	  			2.2 lazy：值 true-延迟(默认)；false：不延迟；extra：及其延迟
	  	-->	
		<set name="setLinkman"  fetch="select" lazy="true">
		<!-- 一对多建表，有外键
		hibernate机制：双向维护外键，在一和多那一方都要配置外键 -->
		<key column="clid"></key>
		
		<!-- 客户所有的联系人，class里面写联系人实体类全路径 -->
		<one-to-many class="com.landray.entity.Linkman"/>
		</set>
	</class>
</hibernate-mapping>

    演示测试方法：

    //演示延迟查询检索策略-关联级别延迟操作
	/*
	 * 1.在映射文件中进行配置实现--根据客户得到所有的联系人，在客户映射文件中配置
	 * 2.在set标签上使用属性
	 * 	2.1 fetch：值 select(默认)
	 * 	2.2 lazy：值 true-延迟(默认)；
	 * 		false：不延迟；直接发送两条sql语句
	 * 		extra：及其延迟；要什么值给什么值
	 * 
	 */
	@Test
	public void testSelect6(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtils.getSessionobject();
			transaction=session.beginTransaction();
			//根据cid=1客户，在查询这个客户里面所有联系人
			Customer customer=session.load(Customer.class, 1);
			//在查询这个客户里面所有联系人
			//直接得到客户里面联系人的set集合
			
			//得到set集合，没有发送sql语句
			Set<Linkman> setLinkman = customer.getSetLinkman();
			//发送sql语句
			System.out.println(setLinkman.size());
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally {
			session.close();
		}
		
	}

  3. 批量抓取
    配置文件：

    <?xml version="1.0" encoding="UTF-8"?>
<!-- dtd约束 -->
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 配置映射关系 -->
<hibernate-mapping>
	<!-- 1.配置类和表对应 -->
	<!-- name属性：实体类的全路径 table属性：数据库表名称 -->
	<class name="com.landray.entity.Customer" table="cust">
		<!-- 2.配置实体类id和表id对应 hibernate要求实体类有一个属性唯一值 hibernate要求表有字段作为唯一值 -->
		<!-- id标签 name属性：实体类里面id属性名称 column属性：生成的表字段名称 -->
		<id name="cid" column="cid">
			<!-- 设置数据库表id的增长策略 native:生成表id值就是主键自动增长 -->
			<generator class="native"></generator>
		</id>
		<!-- 配置其他属性和表字段对应 name属性：实体类属性名称 column属性：生成的表字段名称 -->		
		<property name="custName" column="custName" ></property>
		<property name="custLevel" column="custLevel" ></property>
		<property name="custSource" column="custSource" ></property>
		<property name="custPhone" column="custPhone" ></property>
		<property name="custMobile" column="custMobile" ></property>
		<!-- 表示所有的联系人
		使用set标签表示所有人
		set标签里面有name属性：
		属性值写在客户实体类里面表示 联系人的set集合名称
		cascade="save-update,delete"
		inverse属性默认值是false
		-->
		<!-- 演示延迟查询检索策略——关联级别延迟操作
		 	1.在映射文件中进行配置实现——根据客户得到所有的联系人，在客户映射文件中配置
	  		2.在set标签上使用属性
	  			2.1 fetch：值 select(默认)
	  			2.2 lazy：值 true-延迟(默认)；false：不延迟；extra：及其延迟
	  			2.3batch-size值越大发送语句越少
	  	-->	
		<set name="setLinkman"  inverse="true" batch-size="10">
		<!-- 一对多建表，有外键
		hibernate机制：双向维护外键，在一和多那一方都要配置外键 -->
		<key column="clid"></key>
		
		<!-- 客户所有的联系人，class里面写联系人实体类全路径 -->
		<one-to-many class="com.landray.entity.Linkman"/>
		</set>
	</class>
</hibernate-mapping>

    测试方法：

    	// 演示批量抓取
	/*
	 * 常规会多次发送sql语句，性能不高 
	 * 优化方法： 在配置文件中对set进行配置 batch-size 值越大性能越好（int型）
	 */
	@Test
	public void testSelect7() {
		Session session = null;
		Transaction transaction = null;
		try {
			session = HibernateUtils.getSessionobject();
			transaction = session.beginTransaction();
			// 查询所有客户
			// 1.创建CriteriaBuilder对象
			CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
			// 2.获取criteriaQuery对象
			CriteriaQuery<Customer> createQuery = criteriaBuilder.createQuery(Customer.class);
			// 3.指定根条件
			createQuery.from(Customer.class);
			// 4.执行查询,得到每个客户里面的所有联系人
			List<Customer> resultList = session.createQuery(createQuery).getResultList();
			for (Customer customer : resultList) {
				System.out.println(customer.getCid() + "::" + customer.getCustName());
				// 每个客户里面所有的联系人
				Set<Linkman> setLinkman = customer.getSetLinkman();
				for (Linkman linkman : setLinkman) {
					System.out.println(linkman.getLkm_id() + "::" + linkman.getLkm_name());
				}	
			}	
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			session.close();
		}

	}
SmallSinkHole
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate的日志记录
Howinfun的博客
12-26 571
1.Hibernate的日志记录: 日志:程序开发中的一些信息.   常用信息输出:System.out.println(“”); * 这种方式不好: * 如果输出内容比较多,项目已经开发完毕,不想使用输出.需要打开每个类,将输出的代码注释.   日志:Hibernate中使用slf4j技术. slf4j:SLF4J，即简单日志门面（Simple Logging Facad
从零开始 Spring Boot 59：Hibernate 日志
最新发布
梦幻天空
07-05 616
Hibernate 支持多种日志模块，本文介绍如何在 Spring Boot 中使用 Log4j2记录 Hibernate 日志。实际上本文是我在写时遇到的各种坑和最终解决的记录。首先需要添加 Log4j2 的依赖，并排除 Spring Boot 默认使用的 logging common 日志模块：
灵活控制 Hibernate 的日志或 SQL 输出，以便于诊断
03-29 1079
我们在使用 Hibernate 时一般只会关注是否显示生成的 SQL 语句，不过有些时候还不够。默认时 Hibernate 执行的 SQL 语句是打印在控制台上的，它也可以配置为输出给 Log4J 或是 Log4Back，还能显示出更详细的参数和取值信息。这里简单讲来。 Hibernate 的配置文件 hibernate.cfg.xml 里提供有三个有关显示 SQL 的配置项，如果是与 Spri
Hibernate4日志打印_log
红桃峰峰 的博客
07-12 2803
日志记录对于java应用是很重要的，现在已经有很多记录日志的库，我们可以直接拿过来使用，省去了写一个日志系统以及维护的繁琐。 常见的日志库有java.util.logging，Apache的log4j以及logback，这几个日志库都是日志记录的实现，提供了具体的日志解决方案，是一个具体的日志记录系统，我们可以通过配置文件灵活的配置日志的记录格式、记录级别、输出格式等。 而slf4j（Simple Logging Facade for Java），简单日志门面，并没有实现日志记
在Hibernate中开启日志
热门推荐
chszs的专栏
06-13 1万+
在Hibernate中开启日志作者：chszs，转载需注明。博客主页：http://blog.csdn.net/chszs在项目中，如果要排查故障，找出Bug，离不开日志信息。那么在Hibernate项目中如何开启日志输出呢？本文讲述如何在Hibernate中开启日志，以及Hibernate的日志级别。一、项目开发环境具体以一个示例项目为例，我们的项目使用了： Maven 3.2.3 http://
hibernate学习笔记1
08-08
【hibernate学习笔记1】 一、理解Hibernate Hibernate是一个流行的Java对象关系映射（ORM）框架，它的主要目的是简化数据库操作，通过将Java对象与数据库表进行映射，使得开发者能够以面向对象的方式处理数据，而...
Hibernate--深入理解hibernate日志
执子之手
10-16 4424
一开始对hibernate日志信息不是很了解，日志也就是在运行的时候把关于hibernate的一下信息以日志的形式显示出来。 Hibernate使用Apache commons-logging来为各种事件记录日志. 先熟悉一下Hibernate的日志消息. 在不失可读性的前提下，使Hibernate的日志可能地详细. 这是必要的查错利器. 最令人感兴趣的日志分类有如下这些:
hibernate日志
refire
12-23 489
原文地址：https://docs.jboss.org/hibernate/orm/3.5/reference/zh-CN/html/session-configuration.html 3.5. 日志 Hibernate 利用 Simple Logging Facade for Java (SLF4J) 来记录不同系统事件的日志。SLF4J 可以根据你选择的绑定把日志输出到几个日
如何关闭hibernate产生的大量日志
gaoligaoli的专栏
10-12 1万+
要关闭hibernate的日志，首先要把hibernate.show_sql设置为false;然后设置log4j.properties。# Control logging for other open source packageslog4j.logger.com.opensymphony.oscache=ERRORlog4j.logger.net.sf.navigator=ERRORlog4j.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值