学习日志——2019/08/16

最新推荐文章于 2019-09-16 19:43:46 发布

Silent Land

最新推荐文章于 2019-09-16 19:43:46 发布

阅读量221

点赞数

文章标签： java Hibernate 入门 Hibernate 常见配置 Hibernate核心配置

本文链接：https://blog.csdn.net/weixin_44757417/article/details/99684134

版权

Hibernate的入门

下载Hibernate的开发环境

Hibernate5.0.7
https://sourceforge.net/projects/hibernate/files/hibernate-orm/5.0.7.Final/
解压

在这里插入图片描述
 documentation :Hibernate开发的文档
 lib :Hibernate开发包
 required :Hibernate开发的必须的依赖包
 optional :Hibernate开发的可选的jar包
 project :Hibernate提供的项目

创建一个项目，引入jar包

数据库驱动包
Hibernate开发的必须的包
Hibernate引入日志的包

建表

 CREATE TABLE `cst_customer` (
  `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
  `cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
  `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

创建实体类

Customer

package hibernatedemo01;
/**
 *客户管理实体类
 */
public class Customer {
	private Long cust_id;		//客户编号(主键)
	private String cust_name;	//客户名称(公司名称)
	private String cust_source; //客户信息来源
	private String cust_industry;//客户所属行业
	private String cust_level;	 //客户级别
	private String cust_phone;	 //固定电话
	private String cust_mobile;	 //移动电话
	public Long getCust_id() {
		return cust_id;
	}
	public void setCust_id(Long cust_id) {
		this.cust_id = cust_id;
	}
	public String getCust_name() {
		return cust_name;
	}
	public void setCust_name(String cust_name) {
		this.cust_name = cust_name;
	}
	public String getCust_source() {
		return cust_source;
	}
	public void setCust_source(String cust_source) {
		this.cust_source = cust_source;
	}
	public String getCust_industry() {
		return cust_industry;
	}
	public void setCust_industry(String cust_industry) {
		this.cust_industry = cust_industry;
	}
	public String getCust_level() {
		return cust_level;
	}
	public void setCust_level(String cust_level) {
		this.cust_level = cust_level;
	}
	public String getCust_phone() {
		return cust_phone;
	}
	public void setCust_phone(String cust_phone) {
		this.cust_phone = cust_phone;
	}
	public String getCust_mobile() {
		return cust_mobile;
	}
	public void setCust_mobile(String cust_mobile) {
		this.cust_mobile = cust_mobile;
	}
	
}

创建映射

映射需要通过XML的配置文件来完成，这个配置文件可以任意命名。尽量统一命名规范（类名.hbm.xml）

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<!-- 建立类与表的映射 -->
	<class name="hibernatedemo01.Customer" table="cst_customer">
		<!-- 建立类中的属性与表中的主键对应 -->
		<id name="cust_id" column="cust_id" >
			<generator class="native"/>
		</id>
		
		<!-- 建立类中的普通的属性和表的字段的对应 -->
		<property name="cust_name" column="cust_name" length="32" />
		<property name="cust_source" column="cust_source" length="32"/>
		<property name="cust_industry" column="cust_industry"/>
		<property name="cust_level" column="cust_level"/>
		<property name="cust_phone" column="cust_phone"/>
		<property name="cust_mobile" column="cust_mobile"/>
	</class>
</hibernate-mapping>

创建一个Hibernate的核心配置文件

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="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
		<property name="hibernate.connection.url"> jdbc:mysql://localhost:3306/hibernate?useSSL=false &amp;serverTimezone=Asia/Shanghai</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password"></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>
		
		
		
		<mapping resource="hibernatedemo01/Customer.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

编写测试代码

package hibernatedemo01;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.jupiter.api.Test;
/**
 * Hibernate的入门案例
 * @author Administrator
 *
 */
public class HibernateDemo01 {
	
	@Test
	//保存客户的案例
	public void demo1() {
		//1.加载Hibernate的核心配置文件
		Configuration configuration=new Configuration().configure();
		//2.创建一个SessionFactory对象，类似于JDBC中的连接池
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		//3.通过SessionFactory获取到Session对象，类似于JDBC中的Connection
		Session session = sessionFactory.openSession();
		//4.手动开启事务
		Transaction transaction = session.beginTransaction();
		
		//5.编写代码
		Customer customer = new Customer();
		customer.setCust_name("张三");
		session.save(customer);
		
		//6.事务提交
		transaction.commit();
		
		//7.资源释放
		session.close();
	}
}

Hibernate的常见配置

XML提示的配置
- 配置XML提示问题
Hibernate的映射的配置
映射的配置
【class标签的配置】

	标签用来建立类与表的映射关系
	属性：
	name		：类的全路径
	table		：表名（类名与表名一致，table可以省略）
	catalog		：数据库名

【id标签的配置】

	标签用来建立类中的属性与表中的主键的对应关系
	属性：
	name		：类中的属性名
	column		：表中的字段名（类中的属性名和表中的字段名如果一致，column可以省略）
	length		：长度
	type			：类型

【property标签的配置】

	标签用来建立类中的普通属性与表的字段的对应关系
	属性：
	name		：类中的属性名
	column		：表中的字段名
	length		：长度
	type			：类型
	not-null		：设置非空
	unique		：设置唯一

Hibernate的核心的配置

Hibernate的核心配置方式
- 一种方式:属性文件的方式

	hibernate.properties
	hibernate.connection.driver_class=com.mysql.jdbc.Driver
	…
	hibernate.show_sql=true
	属性文件的方式不能引入映射文件（手动编写代码加载映射文件）

二种方式:XML文件的方式
hibernate.cfg.xml

核心的配置

必须的配置
- 连接数据库的基本的参数

#hibernate.dialect org.hibernate.dialect.MySQLDialect
#hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect
#hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect
#hibernate.connection.driver_class com.mysql.jdbc.Driver
#hibernate.connection.url jdbc:mysql:///test
#hibernate.connection.username gavin
#hibernate.connection.password

驱动类
url路径
用户名
密码
方言

<!-- 配置Hibernate的方言 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

可选的配置

显示SQL ：hibernate.show_sql
格式化SQL ：hibernate.format_sql
自动建表：hibernate.hbm2ddl.auto

    	none		：不使用hibernate的自动建表
    	create		：如果数据库中已经有表，删除原有表，重新创建，如果没有表，新建表。（测试）
    	create-drop	：如果数据库中已经有表，删除原有表，执行操作，删除这个表。如果没有表，新建一个，使用完了删除该表。（测试）
    	update		：如果数据库中有表，使用原有表，如果没有表，创建新表（更新表结构）
    	validate	：如果没有表，不会创建表。只会使用数据库中原有的表。（校验映射和表结构）。

映射文件的引入
- 引入映射文件的位置

Hibernate的核心API

Hibernate的API一共有6个，分别为:Session、SessionFactory、Transaction、Query、Criteria和Configuration。通过这些接口，可以对持久化对象进行存取、事务控制。

Configuration：Hibernate的配置对象

Configuration 类的作用是对Hibernate 进行配置，以及对它进行启动。在Hibernate 的启动过程中，Configuration 类的实例首先定位映射文档的位置，读取这些配置，然后创建一个SessionFactory对象。虽然Configuration 类在整个Hibernate 项目中只扮演着一个很小的角色，但它是启动hibernate 时所遇到的第一个对象。

作用：
- 加载核心配置文件
  - hibernate.properties

Configuration cfg = new Configuration();

hibernate.cfg.xml

Configuration cfg = new Configuration().configure();

加载映射文件
// 手动加载映射

configuration.addResource("hibernatedemo01/Customer.hbm.xml");

SessionFactory：Session工厂

SessionFactory
SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。

配置连接池：（了解）

<!-- 配置C3P0连接池 -->
		<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
		<!--在连接池中可用的数据库连接的最少数目 -->
		<property name="c3p0.min_size">5</property>
		<!--在连接池中所有数据库连接的最大数目  -->
		<property name="c3p0.max_size">20</property>
		<!--设定数据库连接的过期时间,以秒为单位,
		如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->
		<property name="c3p0.timeout">120</property>
		 <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->
		<property name="c3p0.idle_test_period">3000</property>

抽取工具类

package hibernate.utils;


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

/**
 * Hibernate的工具类
 * @author jt
 *
 */
public class HibernateUtils {

	public static final Configuration cfg;
	public static final SessionFactory sf;
	
	static{
		cfg = new Configuration().configure();
		sf = cfg.buildSessionFactory();
	}
	
	public static Session openSession(){
		return sf.openSession();
	}
}

Session：类似Connection对象是连接对象

Session
Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句)。但需要注意的是Session对象是非线程安全的。同时，Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时，其实指的是Hibernate中的session，而以后会将HttpSession对象称为用户session。

Session中的API
- 保存方法：
   Serializable save(Object obj);
- 查询方法：
   T get(Class c,Serializable id);
   T load(Class c,Serializable id);
get方法和load方法的区别？

	package hibernatedemo01;

import java.io.Serializable;
import java.util.Arrays;
import java.util.List;

import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import hibernate.utils.HibernateUtils;

/**
 * Hibernate的工具类的测试
 * @author jt
 *
 */
public class HibernateDemo02 {

	@Test
	// 保存客户
	public void demo1(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Customer customer  = new Customer();
		customer.setCust_name("王小西");
		Serializable id = session.save(customer);
		System.out.println(id);
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 查询：
	// ***** get方法和load方法的区别
	public void demo2(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		/**
		 * get方法
		 * 	* 采用的是立即加载，执行到这行代码的时候，就会马上发送SQL语句去查询。
		 *  * 查询后返回是真实对象本身。
		 * 	* 查询一个找不到的对象的时候，返回null
		 * 
		 * load方法
		 * 	* 采用的是延迟加载（lazy懒加载），执行到这行代码的时候，不会发送SQL语句，当真正使用这个对象的时候才会发送SQL语句。
		 *  * 查询后返回的是代理对象。javassist-3.18.1-GA.jar 利用javassist技术产生的代理。
		 *  * 查询一个找不到的对象的时候，返回ObjectNotFoundException
		 */
		// 使用get方法查询
		/*Customer customer = session.get(Customer.class, 100l); // 发送SQL语句
		System.out.println(customer);*/
		
		// 使用load方法查询
		Customer customer = session.load(Customer.class, 1l);
		System.out.println(customer);
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 修改操作
	public void demo3(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		// 直接创建对象，进行修改
		/*Customer customer = new Customer();
		customer.setCust_id(1l);
		customer.setCust_name("王聪");
		session.update(customer);*/
		
		// 先查询，再修改(推荐)
		Customer customer = session.get(Customer.class, 1l);
		customer.setCust_name("王小贱");
		session.update(customer);
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 删除操作
	public void demo4(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		// 直接创建对象，删除
	/*	Customer customer = new Customer();
		customer.setCust_id(1l);
		session.delete(customer);*/
		
		// 先查询再删除(推荐)--级联删除
		Customer customer = session.get(Customer.class, 2l);
		session.delete(customer);
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 保存或更新
	public void demo5(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		/*Customer customer  = new Customer();
		customer.setCust_name("王凤");
		session.saveOrUpdate(customer);*/
		
		Customer customer = new Customer();
		customer.setCust_id(3l);
		customer.setCust_name("李如花");
		session.saveOrUpdate(customer);
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 查询所有
	public void demo6(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		// 接收HQL：Hibernate Query Language 面向对象的查询语言
		/*Query query = session.createQuery("from Customer");
		List<Customer> list = query.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}*/
		
		// 接收SQL：
		SQLQuery query = session.createSQLQuery("select * from cst_customer");
		List<Object[]> list = query.list();
		for (Object[] objects : list) {
			System.out.println(Arrays.toString(objects));
		}
		tx.commit();
		session.close();
	}
}