案例演示：
1：第一步，导包，老生常谈了都是，省略；
2：第二步，创建数据库和数据表,表结构如下所示：
3：第三步创建实体类User.java
1 package com.bie.po;
2 /**
3 * @author BieHongLi
4 * @version 创建时间：2017年3月8日 下午5:17:23
5 *
6 */
7 public class User {
8
9 private int id;
10 private String name;
11 private String password;
12 private String email;
13 private String phone;
14 public int getId() {
15 return id;
16 }
17 public void setId(int id) {
18 this.id = id;
19 }
20 public String getName() {
21 return name;
22 }
23 public void setName(String name) {
24 this.name = name;
25 }
26 public String getEmail() {
27 return email;
28 }
29 public void setEmail(String email) {
30 this.email = email;
31 }
32 public String getPhone() {
33 return phone;
34 }
35 public void setPhone(String phone) {
36 this.phone = phone;
37 }
38 public String getPassword() {
39 return password;
40 }
41 public void setPassword(String password) {
42 this.password = password;
43 }
44 @Override
45 public String toString() {
46 return "User [id=" + id + ", name=" + name + ", password=" + password + ", email=" + email + ", phone=" + phone
47 + "]";
48 }
49
50
51 }
4：第四步，完成实体类的属性和数据表字段的映射，映射的.xml如下所示，前面的博客已经介绍如何写这个映射，这里略过；
1 <?xml version="1.0"?> 2 <!DOCTYPE hibernate-mapping PUBLIC 3 "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 4 "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 5 6 <hibernate-mapping package="com.bie.po"> 7 <!-- 操作条件： 8 1：对象与表 9 2：属性与字段的对应 10 3：类型的对应,类型默认采用属性的类型，type不写的话 11 --> 12 <class name="User" table="user"> 13 <!-- 主键，映射 --> 14 <id name="id" column="id"> 15 <generator class="native"></generator> 16 </id> 17 18 <!-- 非主键，映射 --> 19 <property name="name" column="name"></property> 20 <property name="password" column="password"></property> 21 <property name="email" column="email"></property> 22 <property name="phone" column="phone"></property> 23 24 25 </class> 26 27 </hibernate-mapping>
5：映射之后写Hibernate的配置文件，配置文件如下所示：
1 <!DOCTYPE hibernate-configuration PUBLIC 2 "-//Hibernate/Hibernate Configuration DTD 3.0//EN" 3 "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> 4 5 <hibernate-configuration> 6 <session-factory> 7 <!-- 8 1:数据连接配置 9 2:加载所有的映射（*.hbm.xml） 10 --> 11 12 <!-- 1:数据连接配置 --> 13 <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> 14 <property name="hibernate.connection.url">jdbc:mysql:///test</property> 15 <property name="hibernate.connection.username">root</property> 16 <property name="hibernate.connection.password">123456</property> 17 <!-- mysql数据库的方言 --> 18 <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> 19 20 <property name="hibernate.show_sql">true</property> 21 22 <!-- 2:加载所有的映射（*.hbm.xml） --> 23 <mapping resource="com/bie/po/User.hbm.xml"/> 24 25 </session-factory> 26 </hibernate-configuration>
6：完成上面的之后写测试的类即可；
6.1：首先实现Hibernate的插入操作《session.save(user)》：
核心代码：
//获取加载配置文件的管理类对象
Configuration config=new Configuration();
//默认加载src/hibernate.cfg.xml文件
config.configure();
//创建session的工厂文件
SessionFactory sf=config.buildSessionFactory();
//创建session（代表一个会话，与数据库连接的会话）
Session session=sf.openSession();
//开启事务
Transaction tx=session.beginTransaction();
//保存到数据库
session.save(user);
//提交事务
tx.commit();
//关闭
session.close();
//sessionFactory关闭
sf.close();
源码如下所示：
1 package com.bie.test;
2
3 import org.hibernate.Session;
4 import org.hibernate.SessionFactory;
5 import org.hibernate.Transaction;
6 import org.hibernate.cfg.Configuration;
7 import org.junit.Test;
8
9 import com.bie.po.User;
10
11 /**
12 * @author BieHongLi
13 * @version 创建时间：2017年3月8日 下午5:28:35
14 *
15 */
16 public class HelloTest {
17
18 @Test
19 public void testHello(){
20 //对象
21 User user=new User();
22 user.setName("张三");
23 user.setPassword("123456");
24 user.setEmail("1748741329@qq.com");
25 user.setPhone("15236083005");
26
27 //获取加载配置文件的管理类对象
28 Configuration config=new Configuration();
29 //默认加载src/hibernate.cfg.xml文件
30 config.configure();
31 //创建session的工厂文件
32 SessionFactory sf=config.buildSessionFactory();
33 //创建session（代表一个会话，与数据库连接的会话）
34 Session session=sf.openSession();
35 //开启事务
36 Transaction tx=session.beginTransaction();
37 //保存到数据库
38 session.save(user);
39 //提交事务
40 tx.commit();
41 //关闭
42 session.close();
43 //sessionFactory关闭
44 sf.close();
45
46
47 }
48 }
演示效果如下所示：
6.2：实现Hibernate的修改操作，核心代码《session.saveOrUpdate(user); session.update(user);这个就不演示了，用法一样，将他们替换一下即可，只是saveOrUpdate更加强大的说》：
session.saveOrUpdate(user);
这个实现的是如果没有实体类的编号就执行保存操作，如果有实体类的编号就执行修改操作；
设计Hibernate框架的人太TMD有才了，当然这是夸赞，大大简化了我们对数据库的操作，必须赞一个；
源码如下所示：
1 package com.bie.test;
2
3 import org.hibernate.Session;
4 import org.hibernate.SessionFactory;
5 import org.hibernate.Transaction;
6 import org.hibernate.cfg.Configuration;
7 import org.junit.Test;
8
9 import com.bie.po.User;
10
11 /**
12 * @author BieHongLi
13 * @version 创建时间：2017年3月8日 下午5:28:35
14 *
15 */
16 public class HelloTest2 {
17
18 //SessionFactory代表整个配置文件，所以没必要加载多次，放到全局即可
19 private static SessionFactory sf;
20 static{
21 //1:创建配置管理类对象
22 Configuration config=new Configuration();
23 //加载配置文件，(默认加载/src/hibernate.cfg.xml)
24 config.configure();
25
26 //2：根据加载的配置管理类对象，创建SessionFactory对象
27 sf=config.buildSessionFactory();
28
29 //简介写法，写到一行里面
30 //sf=new Configuration().configure().buildSessionFactory();
31 }
32 @Test
33 public void testHello(){
34 //对象
35 User user=new User();
36 user.setId(1);
37 user.setName("李四22222");
38 user.setPassword("222222");
39 user.setEmail("22222222@qq.com");
40 user.setPhone("15236083005");
41
42 //3:根据sesson的工厂创建session对象
43 Session session = sf.openSession();
44
45 //开启事务
46 Transaction tx = session.beginTransaction();
47 //执行操作
48 //session.save(user);
49 session.saveOrUpdate(user);
50
51 //提交事务
52 tx.commit();
53 //关闭事务
54 session.close();
55 sf.close();
56 }
57
58 }
演示结果如下所示：
6.3：实现Hibernate的查询操作：
6.3.1：主键查询的方法
两种方法：
User u=(User)session.get(User.class, 1);
User u=(User)session.load(User.class, 1);
源码如下所示：
1 package com.bie.test;
2
3 import org.hibernate.Session;
4 import org.hibernate.SessionFactory;
5 import org.hibernate.Transaction;
6 import org.hibernate.cfg.Configuration;
7 import org.junit.Test;
8
9 import com.bie.po.User;
10
11 /**
12 * @author BieHongLi
13 * @version 创建时间：2017年3月9日 下午8:47:46
14 * Hibernate查询的几种方式：
15 *
16 */
17 public class SelectTest {
18
19 //全局静态session工厂
20 private static SessionFactory sf;
21 static{
22 //1：创建sesson工厂
23 sf=new Configuration().configure().buildSessionFactory();
24 }
25
26 @Test
27 public void select(){
28 User user=new User();
29
30 //2：根据session工厂创建session
31 Session session=sf.openSession();
32 //3：开启事务
33 Transaction tx=session.beginTransaction();
34 //4：主键查询，执行查询操作，方法一：get方法，方法2：load方法
35 //User u=(User)session.get(User.class, 1);
36 User u=(User)session.load(User.class, 1);
37
38 //主键查询测试结果
39 System.out.println(u);
40 //5：提交事务
41 tx.commit();
42 //6：关闭事务和session
43 session.close();
44 sf.close();
45
46 }
47
48 }
演示效果如下所示：
6.3.2：HQL查询，特别注意的是查询语句必须是实体类的方法名，不能是表明，必须和sql语句查询区别：
HQL查询和sql查询的区别：
（1）：sql查询是表以及字段，不区分大小写，也叫做结构化的查询语句；
（2）：HQL查询是Hibernate提供的面向对象的查询语句，查询的是对象以及对象的属性，区分大小写的。
源码如下所示：
1 package com.bie.test;
2
3
4
5 import java.util.List;
6
7 import org.hibernate.Query;
8 import org.hibernate.Session;
9 import org.hibernate.SessionFactory;
10 import org.hibernate.Transaction;
11 import org.hibernate.cfg.Configuration;
12 import org.junit.Test;
13
14 import com.bie.po.User;
15
16 /**
17 * @author BieHongLi
18 * @version 创建时间：2017年3月9日 下午8:47:46
19 * Hibernate查询的几种方式：
20 *
21 */
22 public class SelectTest2 {
23
24 //全局静态session工厂
25 private static SessionFactory sf;
26 static{
27 //1：创建sesson工厂
28 sf=new Configuration().configure().buildSessionFactory();
29 }
30
31 @Test
32 public void select(){
33 User user=new User();
34
35 //2：根据session工厂创建session
36 Session session=sf.openSession();
37 //3：开启事务
38 Transaction tx=session.beginTransaction();
39
40 //HRL查询，查询全部信息，注意HRL查询的是实体类的名称，不是数据表的名称，特别注意这一点
41 //Query q=session.createQuery("from User");
42 Query q=session.createQuery("from User user where user.id=1 or user.id=2 ");
43
44 List<User> list=q.list();
45 System.out.println(list);
46
47 //5：提交事务
48 tx.commit();
49 //6：关闭事务和session
50 session.close();
51 sf.close();
52
53 }
54
55 }
效果如下所示：
6.3.3：完全面向对象的查询，Criteria查询也叫做 QBC查询 query by criteria
核心代码：
//Criteria查询也叫做 QBC查询 query by criteria
//完全的面向对象的查询
Criteria criteria = session.createCriteria(User.class);
//添加条件
criteria.add(Restrictions.eq("id", 1));
//查询全部，没有sql语句
List<User> list = criteria.list();
System.out.println(list);
源码如下所示：
1 package com.bie.test;
2
3
4
5 import java.util.List;
6
7 import org.hibernate.Criteria;
8 import org.hibernate.Session;
9 import org.hibernate.SessionFactory;
10 import org.hibernate.Transaction;
11 import org.hibernate.cfg.Configuration;
12 import org.hibernate.criterion.Restrictions;
13 import org.junit.Test;
14
15 import com.bie.po.User;
16
17 /**
18 * @author BieHongLi
19 * @version 创建时间：2017年3月9日 下午8:47:46
20 * Hibernate查询的几种方式：
21 *
22 */
23 public class SelectTest3 {
24
25 //全局静态session工厂
26 private static SessionFactory sf;
27 static{
28 //1：创建sesson工厂
29 sf=new Configuration().configure().buildSessionFactory();
30 }
31
32 @Test
33 public void select(){
34 User user=new User();
35
36 //2：根据session工厂创建session
37 Session session=sf.openSession();
38 //3：开启事务
39 Transaction tx=session.beginTransaction();
40
41 //Criteria查询也叫做 QBC查询 query by criteria
42 //完全的面向对象的查询
43 Criteria criteria = session.createCriteria(User.class);
44 //添加条件
45 criteria.add(Restrictions.eq("id", 1));
46
47 //查询全部，没有sql语句
48 List<User> list = criteria.list();
49
50
51 System.out.println(list);
52
53 //5：提交事务
54 tx.commit();
55 //6：关闭事务和session
56 session.close();
57 sf.close();
58
59 }
60
61 }
演示效果如下所示：
6.3.4：本地查询sql语句，适合使用复杂的查询，或者不想使用HQL或者criteria查询，可以使用本地sql查询
核心代码：
//sql语句
//SQLQuery sql= session.createSQLQuery("select * from user ");
SQLQuery sql=session.createSQLQuery("select * from user where id=1 ");
sql.addEntity(User.class);
List<User> list=sql.list();
System.out.println(list);源码如下所示：
1 package com.bie.test;
2
3
4
5 import java.util.List;
6
7 import org.hibernate.SQLQuery;
8 import org.hibernate.Session;
9 import org.hibernate.SessionFactory;
10 import org.hibernate.Transaction;
11 import org.hibernate.cfg.Configuration;
12 import org.junit.Test;
13
14 import com.bie.po.User;
15
16 /**
17 * @author BieHongLi
18 * @version 创建时间：2017年3月9日 下午8:47:46
19 * Hibernate查询的几种方式：
20 *
21 */
22 public class SelectTest4 {
23
24 //全局静态session工厂
25 private static SessionFactory sf;
26 static{
27 //1：创建sesson工厂
28 sf=new Configuration().configure().buildSessionFactory();
29 }
30
31 @Test
32 public void select(){
33 User user=new User();
34
35 //2：根据session工厂创建session
36 Session session=sf.openSession();
37 //3：开启事务
38 Transaction tx=session.beginTransaction();
39
40 //sql语句
41 //把每一行记录封装为对象数组，再添加到list集合中
42 //SQLQuery sql= session.createSQLQuery("select * from user ");
43 //把每一行记录封装为指定的对象类型
44 SQLQuery sql=session.createSQLQuery("select * from user where id=1 ").addEntity(User.class);
45 List<User> list=sql.list();
46 System.out.println(list);
47
48 //5：提交事务
49 tx.commit();
50 //6：关闭事务和session
51 session.close();
52 sf.close();
53
54 }
55
56 }
演示如下所示：
为了美好明天，加油！！！