一：配置Hibernate
使用JDBC做数据库相关功能开发会做很多重复性的工作，比如创建连接，关闭连接，把字段逐一映射到属性中。 Hibernate把这一切都封装起来了，使得数据库访问变得轻松而简单，代码也更加容易维护。
（1）先创建数据库表
数据库：test
表product_
use test;
CREATE TABLE product_ (
id int(11) NOT NULL AUTO_INCREMENT,
name varchar(30) ,
price float ,
PRIMARY KEY (id)
) DEFAULT CHARSET=UTF8;
（2）创建一个hibernate工程：
（3）导入hibernate所依赖的jar包
在右上角下载lib.rar,并解压到hibernate的项目目录下： e:\project\hibernate\lib 这个位置。
然后为这个java project导入jar包
导包步骤： 右键project->property->java build path->libaries->add external jars
（4）创建实体：product_
实体类 Product 用于映射数据库中的表product_
放在com.how2java.pojo 包中
package com.how2java.pojo;
public class Product {
int id;
String name;
float price;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
}
（5） 配置 Product.hbm.xml
在包com.how2java.pojo下 新建一个配置文件Product.hbm.xml， 用于映射Product类对应数据库中的product_表
注: 文件名 Product.hbm.xml P一定要大写，要和类保持一致
<class name="Product" table="product_">
表示类Product对应表product_
<id name="id" column="id">
<generator class="native">
</generator>
</id>
表示属性id,映射表里的字段id
<generator class="native"> 意味着id的自增长方式采用数据库的本地方式
如果是连接oracle数据库，可以指定sequnce作为id自增长方式
<property name="name" />
这里配置的时候，只写了属性name,没有通过column="name" 显式的指定字段，那么字段的名字也是name.
<?xml version="1.0"?>
<hibernate-mapping package="com.how2java.pojo">
<class name="Product" table="product_">
<id name="id" column="id">
<generator class="native">
</generator>
</id>
<property name="name" />
<property name="price" />
</class>
</hibernate-mapping>
（6）配置 hibernate.cfg.xml
在src目录下创建 hibernate.cfg.xml
配置访问数据库要用到的驱动，url，账号密码等等
其他配置及含义：
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
这表示使用MYSQL方言。 什么方言呢？ 因为在代码层面，开发人员不用关心底层到底用Oracle还是Mysql，写的代码都是一样的。 可是Oracle和Mysql所用的sql语句的语法是有所区别的，那么这件事就交给Hibernate来做了。这个时候就需要告诉Hibernate底层用的是什么数据库，它才知道应该用什么样的“方言” 去对话。
<property name="current_session_context_class">thread</property>
这是Hibernate事务管理方式，即每个线程一个事务
<property name="show_sql">true</property>
这表示是否在控制台显示执行的sql语句
<property name="hbm2ddl.auto">update</property
这表示是否会自动更新数据库的表结构，有这句话，其实是不需要创建表的，因为Hibernate会自动去创建表结构
<mapping resource="com/how2java/pojo/Product.hbm.xml" />
这表示Hibernate会去识别Product这个实体类
<?xml version='1.0' encoding='utf-8'?>
<hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://LOCALHOST:3306/test?characterEncoding=UTF-8</property>
<property name="connection.username">root</property>
<property name="connection.password">123</property>
<!-- SQL dialect -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="current_session_context_class">thread</property>
<property name="show_sql">true</property>
<property name="hbm2ddl.auto">update</property>
<mapping resource="com/how2java/pojo/Product.hbm.xml" />
</session-factory>
</hibernate-configuration>
（7）创建 测试类 TestHibernate
创建一个Product对象，并通过hibernate把这个对象，插入到数据库中
hibernate的基本步骤是：
- 获取SessionFactory
- 通过SessionFactory 对象获取一个Session
- 在Session基础上开启一个事务
- 通过调用Session的save方法把对象保存到数据库
- 提交事务
- 关闭Session
- 关闭SessionFactory
package com.how2java.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.how2java.pojo.Product;
public class TestHibernate {
public static void main(String[] args) {
SessionFactory sf = new Configuration().configure().buildSessionFactory();
//获取SessionFactory
Session s = sf.openSession();//通过SessionFactory 对象sf获取一个Session
s.beginTransaction();//在Session基础上开启一个事务
Product p = new Product();
p.setName("iphone7");
p.setPrice(7000);
s.save(p);//通过调用Session对象 s 的save方法把对象保存到数据库
s.getTransaction().commit();//提交事务
s.close();//关闭 Session
sf.close();// 关闭 SessionFactory
}
}
（10）原理
应用程序通过Hibernate把 一个 Product对象插入到数据库的product_表中
hibernate.cfg.xml 配置文件提供链接数据库的基本信息
账号 密码 驱动 数据库ip 端口
Product.hbm.xml 提供对象与表的映射关系
对应哪个表？ 什么属性，对应什么字段
成功后，控制台会显示该图
二：对象状态
（1）Session
Java应用程序与Hibernate之间的主要运行时接口。它是抽象了持久化服务概念的核心抽象API类。
Session的生命周期绑定在一个物理的事务（tansaction）上面。（长的事务可能跨越多个数据库事物。）
Session的主要功能是提供对映射的实体类实例的创建，读取和删除操作。实例可能以下面三种状态存在：
实体类
（2）Session 对象的三种状态
对象在Hibernate中有3种状态
分别是瞬时，持久和脱管
- 瞬时 指的是没有和hibernate发生任何关系，在数据库中也没有对应的记录，一旦JVM结束，这个对象也就消失了
- 持久 指得是一个对象和hibernate发生联系，有对应的session,并且在数据库中有对应的一条记录
- 脱管 指的是一个对象虽然在数据库中有对应的一条记录，但是它所对应的session已经关闭了
package com.how2java.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.how2java.pojo.Product;
public class TestHibernate {
/**
* @param args
*/
public static void main(String[] args) {
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
Product p = new Product();
p.setName("p1");
System.out.println("此时p是瞬时状态");
s.save(p);
System.out.println("此时p是持久状态");
s.getTransaction().commit();
s.close();
System.out.println("此时p是脱管状态");
sf.close();
}
}
new 了一个Product();，在数据库中还没有对应的记录，这个时候Product对象的状态是瞬时的。
通过Session的save把该对象保存在了数据库中，该对象也和Session之间产生了联系，此时状态是持久的。
最后把Session关闭了，这个对象在数据库中虽然有对应的数据，但是已经和Session失去了联系，相当于脱离了管理，状态就是脱管的
三、通过获取ID对象
调用Session的get方法，根据id获取对象。 除了id之外，还需要传递一个类对象，毕竟需要知道获取的是哪个对象
除了使用get方法，还可以使用load获取对象
package com.how2java.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.how2java.pojo.Product;
public class TestHibernate {
public static void main(String[] args) {
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
/*估计是根据类对象Product.class,ID=6,找到数据库数据，并封装，
然后转化为Product对象;
为什么这里是根据ID属性找对象的？？？
答：默认找主键
*/
Product p =(Product) s.get(Product.class, 6);
System.out.println("id=6的产品名称是: "+p.getName());
s.getTransaction().commit();
s.close();
sf.close();
}
}
四：基础操作
（1）删除一条数据
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
Product p =(Product) s.get(Product.class, 6);
s.delete(p);
（2）修改一条数据
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
Product p =(Product) s.get(Product.class, 6);
System.out.println(p.getName());
p.setName("iphone-modified");
s.update(p);
（3）查询数据库 HQL（Hibernate Query Language）
sql 面向数据库表查询
hql 面向对象查询
hql ： from 后面跟的是 类名＋类对象 where 后 用 对象的属性做条件
sql： from 后面跟的是表名 where 后 用表中字段做条件
查询
在Hibernate中使用查询时，一般使用Hql查询语句。
HQL（Hibernate Query Language），即Hibernate的查询语言跟SQL非常相像。不过HQL与SQL的最根本的区别，就是它是面向对象的。
- 首先根据hql创建一个Query对象
- 设置参数(和基1开始的PreparedStatement不一样，Query是基0的)，但两者内容很类似（PrepareStatement不懂，具体看java web那一章）
- 通过Query对象的list()方法即返回查询的结果了。
注： 使用hql的时候，用的是类名Product,而不是表名product_
注： 使用hql的时候，不需要在前面加 select *
package com.how2java.test;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.how2java.pojo.Product;
public class TestHibernate {
public static void main(String[] args) {
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
String name = "iphone";
Query q =s.createQuery("from Product p where p.name like ?");
// 这里是给 ？ 号赋值
q.setString(0, "%"+name+"%");
List<Product> ps= q.list();
for (Product p : ps) {
System.out.println(p.getName());
}
s.getTransaction().commit();
s.close();
sf.close();
}
}
（4）查询数据库Criteria
使用Criteria 查询数据（结果与hql一样）区别就是，相同的方法而产生的对象不一样
- 通过session的
createCriteria创建一个Criteria对象 - Criteria.add 增加约束。 在本例中增加一个对name的模糊查询(like)
- 调用list()方法返回查询结果的集合
除此之外，Criteria 还可以很方便的进行进行分页查询和获取总数
Criteria c= s.createCriteria(Product.class);
//通过session的createCriteria创建一个Criteria 对象
//Criteria.add 增加约束。 在本例中增加一个对name的模糊查询(like)
c.add(Restrictions.like("name", "%"+name+"%"));
//调用list()方法返回查询结果的集合
List<Product> ps = c.list();
for (Product p : ps) {
System.out.println(p.getName());
}
（5）查询数据库createSQLQuery
前两者是面向对象查询，这里是面向数据库查询
使用Session的createSQLQuery方法执行标准SQL语句
因为标准SQL语句有可能返回各种各样的结果，比如多表查询，分组统计结果等等。 不能保证其查询结果能够装进一个Product对象中，所以返回的集合里的每一个元素是一个对象数组。 然后再通过下标把这个对象数组中的数据取出来。
结果是跟前两者一样的
String sql = "select * from product_ p where p.name like '%"+name+"%'";
Query q= s.createSQLQuery(sql);//这里标准数据库语句，而hql 则不是
List<Object[]> list= q.list();
for (Object[] os : list) {
for (Object filed: os) {
System.out.print(filed+"\t");
}
System.out.println();
}
五：多表关系
（1）多对一（Product - Category）
一个Category 可以选择多个Product
一个 Product可以选择多个Category
所以:
Product 是多
Category 是 一
所以在“多“的配置文件中增加本表即product_的外键属性列
通过多对一关系，设置了id=8的产品对应 id=1的分类
product_表
Category.java
package com.how2java.pojo;
public class Category {
int id;
String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Category.xml
映射Category 类：只有 id 和 name 两个属性
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.how2java.pojo">
<class name="Category" table="category_">
<id name="id" column="id">
<generator class="native">
</generator>
</id>
<property name="name" />
</class>
</hibernate-mapping>
Product.java
加入Category 对象作为属性
（应该是多对一关系的特有的）
package com.how2java.pojo;
public class Product {
int id;
String name;
float price;
Category category;
public Category getCategory() {
return category;
}
public void setCategory(Category category) {
this.category = category;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
}
Product.hbm.xml 中设置Category 多对一关系
使用many-to-one 标签设置多对一关系
name="category" 对应Product类中的category属性
class="Category" 表示对应Category类
column="cid" 表示product_表中的外键列 cid列指向 category_表
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.how2java.pojo">
<class name="Product" table="product_">
<id name="id" column="id">
<generator class="native">
</generator>
</id>
<property name="name" />
<!--
大概意思：Product类中的属性category 和 类Category
相映射，(这样从数据库查询后接收到数据才可以放在这个属性中)，
并 在product_中设置外键 cid
-->
<many-to-one name="category" class="Category" column="cid" />
<!--<many-to-one name 下 指的是本表product_ 的外键cid ，不是指外表-->
</class>
</hibernate-mapping>
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>
<!-- Database connection settings -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost:3306/test?characterEncoding=GBK</property>
<property name="connection.username">root</property>
<property name="connection.password">admin</property>
<!-- SQL dialect -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="current_session_context_class">thread</property>
<property name="show_sql">true</property>
<property name="hbm2ddl.auto">update</property>
<mapping resource="com/how2java/pojo/Product.hbm.xml" />
<!--在hibernate.cfg.xml中增加Category的映射 -->
<mapping resource="com/how2java/pojo/Category.hbm.xml" />
</session-factory>
</hibernate-configuration>
TestHibernate.java
在这个测试例子中，增加了一个新的Category对象"c1"
并将其设置为id=8的product的category
package com.how2java.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.how2java.pojo.Category;
import com.how2java.pojo.Product;
public class TestHibernate {
public static void main(String[] args) {
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
Category c =new Category();
c.setName("c1");//创建了一个 Category 对象 c
s.save(c);// 并在数据库表category_ 中增加了一条数据：如下
/*
id name
1 c1
*/
// id 在category.xml 文件中就设置为自动增长了
Product p = (Product) s.get(Product.class, 8);//从数据库冲取出 id为8的product
p.setCategory(c);
/* 在Product 对象 p 中赋值category属性，又因为这个属性是与
Category类 相映射的，所以与之相关联的外键 cid会变成 1；
（就理解为java它固定这么做得吧，死公式样，等真正理解了再来解答）*/
s.update(p);//将 id=8 的product数据库数据，写入（更新）数据库
s.getTransaction().commit();
s.close();
sf.close();
}
}
（2）一对多：用set集合
一个Category对应多个Product
一个Product对应一个Category
所以:
Category 是 一
Product 是多
所以在“一“的配置文件中指向外表即product_的外键属性列
Category.java（增加set 集合对象 products）
package com.how2java.pojo;
import java.util.Set;
int id;
String name;
Set<Product> products;
public class Category {
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Product> getProducts() {
return products;
}
public void setProducts(Set<Product> products) {
this.products = products;
}
}
Category.xml（给 product设置映射 和一对多关系）
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.how2java.pojo">
<class name="Category" table="category_">
<id name="id" column="id">
<generator class="native">
</generator>
</id>
<property name="name" />
<set name="products" lazy="false">
<!-- 在one-to-many 下 指明外表即product_ 的外键列是 cid
（不是指本表category_的外键） -->
<key column="cid" not-null="false" />
<one-to-many class="Product" />
</set>
</class>
</hibernate-mapping>
<set 用于设置一对多(多对多也是他)关系，也可以用list，设置稍复杂点，这里使用简单的set来入门。
name="products" 对应 Category类中的products属性
lazy="false" 表示不使用延迟加载。关于延迟加载，请参考关系的延迟加载
<key column="cid" not-null="false" /> 表示外键列是cid，可以为空（cid 是在product_中）
<one-to-many class="Product" /> 表示一对多所对应的类是Product
TestHibernate.java
获取归于目录 1 的 所有产品
package com.how2java.test;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.how2java.pojo.Category;
import com.how2java.pojo.Product;
public class TestHibernate {
public static void main(String[] args) {
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
Category c = (Category) s.get(Category.class, 1);
Set<Product> ps = c.getProducts();
for (Product p : ps) {
System.out.println(p.getName());
}
s.getTransaction().commit();
s.close();
sf.close();
}
}
（3）多对多 （User - Product）
User.java
package com.how2java.pojo;
import java.util.Set;
public class User {
int id;
String name;
Set<Product> products;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Product> getProducts() {
return products;
}
public void setProducts(Set<Product> products) {
this.products = products;
}
}
User.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.how2java.pojo">
<class name="User" table="user_">
<id name="id" column="id">
<generator class="native">
</generator>
</id>
<property name="name" />
<set name="products" table="user_product" lazy="false">
<key column="uid" />
<many-to-many column="pid" class="Product" />
</set>
</class>
</hibernate-mapping>
Product.java
package com.how2java.pojo;
import java.util.Set;
public class Product {
int id;
String name;
float price;
Category category;
Set<User> users;
public Set<User> getUsers() {
return users;
}
public void setUsers(Set<User> users) {
this.users = users;
}
public Category getCategory() {
return category;
}
public void setCategory(Category category) {
this.category = category;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
}
Product.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.how2java.pojo">
<class name="Product" table="product_">
<id name="id" column="id">
<generator class="native">
</generator>
</id>
<property name="name" />
<property name="price" />
<many-to-one name="category" class="Category" column="cid" />
<set name="users" table="user_product" lazy="false">
<key column="pid" />//指向外表外键pid
<many-to-many column="uid" class="User" />//增加本表外键uid
</set>
</class>
</hibernate-mapping>
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>
<!-- Database connection settings -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost:3306/test?characterEncoding=GBK</property>
<property name="connection.username">root</property>
<property name="connection.password">admin</property>
<!-- SQL dialect -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="current_session_context_class">thread</property>
<property name="show_sql">true</property>
<property name="hbm2ddl.auto">update</property>
<mapping resource="com/how2java/pojo/Product.hbm.xml" />
<mapping resource="com/how2java/pojo/Category.hbm.xml" />
<mapping resource="com/how2java/pojo/User.hbm.xml" />
</session-factory>
</hibernate-configuration>
TestHibernate.java
这里演示了一对多的关系：
即产品1被 3个user购买了
package com.how2java.test;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.how2java.pojo.Product;
import com.how2java.pojo.User;
public class TestHibernate {
public static void main(String[] args) {
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
//在 user_表中增加3个用户
Set<User> users = new HashSet();
for (int i = 0; i < 3; i++) {
User u =new User();
u.setName("user"+i);
users.add(u);
s.save(u);
}
//peoduct_表中增加 产品1被用户1,2,3购买
Product p1 = (Product) s.get(Product.class, 1);//在product 表中拿出 id = 1的对象
// id = 1 的p对象它要对应3个user表的三个对象，所以中间表要跟着变
p1.setUsers(users);// 因为 p1中的 users 集合间接性是跟 user_表对应的
s.save(p1);
s.getTransaction().commit();
s.close();
sf.close();
}
}
运行后的 user_product 表的状态
440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
