Hibernate框架-01-02-环境搭建与创建第一个简单项目

总体步骤

---

0. 安装Eclipse、Mysql；
1. 下载Hibernate，并解压缩；
2. 使用Eclipse创建新的项目；
3. 引入Hibernate及其依赖库（jar包）；
4. 引入Mysql数据库驱动包；
5. 编写Hibernate配置文件；
6. 创建Java持久化类XXX.java；
7. 编写持久化类的映射配置文件XXX.hbm.xml；
8. 使用Hibernate API 完成对象的持久化。

步骤 0-1

下载并安装Eclipse / IDEA等java开发工具，配置Java环境，网上教程很多，我就不献丑了。

下载MySql数据库并安装，可以找网上绿色免安装版本的，都是可以用的。

步骤 2 使用开发工具创建项目

因为处于学习阶段，为了方便此处创建的是普通Java项目，而不是JavaWEB。

步骤 3 导入依赖的包

创建lib文件夹，存放jar包

打开Hibernate下载并解压后的文件夹，打开lib子文件夹，打开required的文件夹，里面的包都是必须的包，拷贝包到刚才创建的lib文件夹里。

步骤 4 引入Mysql数据库驱动包；

下载MySql的驱动包，注意与MySql的版本相适应的才可以，拷贝驱动包到lib文件夹里

选中之前拷贝的所有包，右键构建路径->配置构建路径，添加到运行库中。

步骤 5 编写Hibernate配置文件；

创建三个包，模拟分层结构，

创建主配置文件,格式为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就是一个配置项 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		<!-- dialect是方言，表明用的是什么数据库方言  -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<!-- 数据库驱动类，指定类名 -->
		<!-- 下面是链接数据库的信息，和JDBC类似 -->
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate-database?useUicode=true&amp;characterEncoding=UTF-8</property>
		<!-- &amp  是转义字符，此处是转义分号所用-->
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password"></property>
		
		<!-- 上面5个配置项是必选的，下面两个是可选的，分别是打印sql语句与格式化sql语句，便于调试-->
		<property name="hibernate.show_sql">true</property>
		<property name="hibernate.format_sql">true</property>
		
		<!-- 设置映射文件，属性值是包名+文件名，注意格式变化，点变成了斜杠-->
		<mapping resource="com/hibernate/entity/Customer.hbm.xml"/>
	</session-factory>
	
</hibernate-configuration>

数据库的字符集：utf8 -- UTF-8 Unicode
数据库中表的varchar设置字符集：utf-8

Hibernate需要从配置文件中读取数据库配置信息，配置文件一般位于项目根路径。
Hibernate配置文件两种方式：
hibernate.properties （键=值方式）
默认名字为：hibernate.propeties
hibernate.cfg.xml

步骤 6 创建Java持久化类XXX.java；

持久化类：指其实例需要被Hibernate持久化到数据库中的类即实体类

• private 类型属性；
• public 类型的 setter 和 getter 方法；
• public 或 protected 类型的无参数的构造方法。

package com.hibernate.entity;

public class Customer {
    
    
	private Integer id;
	private String name;
	private int age;

	//创建两个构造方法，一个有参数，一个无参数，缺一不可
	public Customer() {
    
    
		super();
	}
	public Customer(Integer id, String name, int age) {
    
    
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	
	
	//私有属性的get set方法
	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 int getAge() {
    
    
		return age;
	}
	public void setAge(int age) {
    
    
		this.age = age;
	}
	
	
	
	
}

步骤 7 编写持久化类的映射配置文件XXX.hbm.xml；

映射文件必须放置前面的持久化类同级文件夹下

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.hibernate.entity">
<!-- package属性值就是实体化类所处的包名 -->
	<!-- 类与表的映射 ，类名区分大小写，表名不区分大小写，为了便于区分故意表名大写-->
	<class name="Customer" table="CUSTOMER">
		<!-- 主键的映射，必选 -->
		<id name="id" column="ID"><!-- name是类的属性名，column是数据库表的主键名 -->
			<generator class="native"/>
		</id>	
		
		<!-- 下面是非主键的映射 -->
		<property name="name" column="NAME"></property>
		<property name="age" column="AGE"></property>	
	</class>
	
</hibernate-mapping>

• id 子元素设定持久化类的OID和表的主键的映射关系。

column – 指定表字段的名称；
generator – 元素指定OID的生成器。

• property 子元素设定类的其他属性和表的字段的映射关系。

name – 对应类的属性名称；
type – 指定属性的类型；
column – 指定表字段的名称；
not-null – 指定属性是否允许为空。

步骤 8 使用Hibernate API 完成对象的持久化。

package com.hibernate.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;

public class HibernateUtil {
    
    
	//HibernateUtil ������
	
	private static SessionFactory sessionFactory;
	
	
	//静态初始化Hibernate，只需要构建一次就好
	static {
    
    
		//1. 创建ServiceRegistry对象，通过build模式创建
		// 从 hibernate.cfg.xml 读取配置信息并存储到对象当中，是整个API程序的入口
		StandardServiceRegistry register=new StandardServiceRegistryBuilder()
				.configure().build();//读取hibernate.cfg.xml文件，因为build（）没有参数，所以采用默认的固定位置固定名称。
				//调用config方法
		try {
    
    
			//2. 创建SessionFactory对象
			sessionFactory=new MetadataSources(register)
					.buildMetadata()//构建源数据
					.buildSessionFactory();//构建SessionFactory
		} catch (Exception e) {
    
    
			e.printStackTrace();//打印异常
			//手动释放StandardServiceRegistry对象
			StandardServiceRegistryBuilder.destroy(register);
		}
	}
	
	/*
		创建Session对象，里面可以包含很多数据库操作
	*/
	public static Session openSession() {
    
    
		return sessionFactory.openSession();
	}
	
	/*
	 	关闭sessionFactory，释放资源
	*/
	public static void closeSessionFactory() {
    
    
		sessionFactory.close();
	}
}

创建测试类，完场测试

package com.hibernate.ui;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.hibernate.entity.Customer;
import com.hibernate.util.HibernateUtil;

public class Test {
    
    

	public static void main(String[] args) {
    
    
		saveCustomer();
		//关闭SessionFactory
		HibernateUtil.closeSessionFactory();

	}
	
	public static void saveCustomer() {
    
    
		//1. 打开Session
		Session session=HibernateUtil.openSession();
		
		//2. 开启一个数据库事务
		Transaction tx = session.beginTransaction();
		
		//3. 拿到事务，开始保存操作
		Customer c = new Customer();
		c.setName("法外狂徒张三");
		c.setAge(15);		
		session.save(c);
		
		//4. 提交事务
		tx.commit();
		
		//5.关闭Session
		session.close();


/*
 *步骤1创建Session对象时，一但使用了自定义的openSession方法，就会调用静态代码块完场session的对象创建与实现操作
 *所有关于数据库的操作都在Session工具类里
 * */
 


	}

}

运行结果正常