【hibernate】hibernate 2 （基本概念和CURD）

基本概念和CURD

• 开发流程

• 1. 由Domain object -> mapping->db。(官方推荐)
  2. 由DB开始，用工具生成mapping和Domain object。(使用较多)
  3. 由映射文件开始。

一把情况下使用第二种

第二种从数据库开始，先做数据库然后映射文件

• Domain Object限制
  1. 默认的构造方法(必须的)。
  2. 有无意义的标示符id（主键）(可选)
  3. 非final的，对懒加载有影响（可选）

对象关系映射文件：

把面向对象中的实体类对象映射到数据库中的实体（表的记录），把实体类之间的关联关系也映射到数据库中多个表之间的相互关系中。

这样，在Hibernate中对这些实体对象的操作就直接转换为对数据库表的记录的操作。

xx.hbm.xml  取名
<?xml version="1.0"?>
<hibernate-mapping package=“cn.itcast.domain">
<class name="User" table="user"> 类名，table属性可以没有，默认为全部小写的表名，当类名正好是sql下的关键字必须加table
<id name="id">  属性
<generator class="native"/> 主键生成器
</id>
<property name="name"/>属性
<property name="birthday”/>属性
</class>

</hibernate-mapping>

在hibernate.cfg.xml中加入mapping resource属性

type：hibernate里的类型，作用：通过hibernate的某个类型知道把java里的类型映射到数据库里的类型

基本值类型

基本映射类型可以大致分为 

• integer, long, short, float, double, character, byte, boolean, yes_no, true_false
• 这些类型都对应Java的原始类型或者其封装类，来符合(特定厂商的)SQL 字段类型。
• boolean, yes_no 和 true_false都是Java 中boolean 或者java.lang.Boolean的另外说法。

• string
  • 从java.lang.String 到 VARCHAR (或者 Oracle的VARCHAR2)的映射。
• date, time, timestamp
  • 从java.util.Date和其子类到SQL类型DATE,TIME 和TIMESTAMP(默认) (或等价类型)的映射。
• calendar, calendar_date
  • 从java.util.Calendar 到SQL 类型TIMESTAMP和DATE(或等价类型)的映射。
• big_decimal, big_integer
  • 从java.math.BigDecimal和java.math.BigInteger到NUMERIC (或者 Oracle 的NUMBER类型)的映射。
• locale, timezone, currency
  • 从java.util.Locale, java.util.TimeZone 和java.util.Currency 到VARCHAR (或者 Oracle 的VARCHAR2类型)的映射.Locale和Currency 的实例被映射为它们的ISO代码。TimeZone的实例被影射为它的ID。
• class
  • 从java.lang.Class 到 VARCHAR (或者 Oracle 的VARCHAR2类型)的映射。Class被映射为它的全限定名。
• binary
  • 把字节数组(byte arrays)映射为对应的 SQL二进制类型。
• text
  • 把长Java字符串映射为SQL的CLOB或者TEXT类型。
• serializable
  • 把可序列化的Java类型映射到对应的SQL二进制类型。你也可以为一个并非默认为基本类型的可序列化Java类或者接口指定Hibernate类型serializable。
• clob, blob
  • JDBC 类 java.sql.Clob 和 java.sql.Blob的映射。某些程序可能不适合使用这个类型，因为blob和clob对象可能在一个事务之外是无法重用的。(而且, 驱动程序对这种类型的支持充满着补丁和前后矛盾。)
• imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary
  • 一般来说，映射类型被假定为是可变的Java类型，只有对不可变Java类型，Hibernate会采取特定的优化措施，应用程序会把这些对象作为不可变对象处理。比如，你不应该对作为imm_timestamp映射的Date执行Date.setTime()。要改变属性的值，并且保存这一改变，应用程序必须对这一属性重新设置一个新的（不一样的）对象。

实体及其集合的唯一标识可以是除了binary、 blob 和clob之外的任何基础类型。(联合标识也是允许的，后面会说到。)

在org.hibernate.Hibernate中，定义了基础类型对应的Type常量。比如，Hibernate.STRING代表string 类型。 

【实例】date类型映射

 User.hbm.xml

1. <?xml version="1.0"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC  
3.       "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
4.           "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
5.   
6.   
7. <hibernate-mapping package="www.hbsi.com.domain">  
8.     <!-- 主键 -->  
9.     <class name="User" >  
10.         <id name="id">  
11.             <generator class="increment" />  
12.         </id>  
13.         <!-- 属性 -->  
14.         <property name="name" />  
15.         <!-- type属性为通过hibernate的某个类型知道把java里的类型映射到数据库里的类型  
16.         date类型默认为TIMESTAMP,有时间也有日期  
17.                    如果想要只有日期的就要设置一下  
18.          -->  
19.         <property name="birthday" type="date"/>  
20.           
21.     </class>  
22.   
23. </hibernate-mapping>  

Demo1.java

1. package www.hbsi.com.demo;  
2. import java.text.DateFormat;  
3. import java.text.ParseException;  
4. import java.util.Date;  
5.   
6. import org.hibernate.Session;  
7. import org.hibernate.SessionFactory;  
8. import org.hibernate.cfg.Configuration;  
9.   
10. import www.hbsi.com.domain.User;  
11.   
12. public class Demo1 {  
13.     public static void main(String args[]) throws ParseException{  
14.         User user = new User();  
15.         user.setName("Tom");  
16.         //user.setBirthday(new Date());  
17.         user.setBirthday(DateFormat.getDateInstance().parse("1992-10-21"));  
18.           
19.         //新建一个配置对象  
20.         Configuration cfg = new Configuration();  
21.         //加载hibernate.cfg.xml信息  
22.         cfg.configure();  
23.           
24.         //创建session工厂  
25.         SessionFactory sessionFactory = cfg.buildSessionFactory();  
26.         //得到session对象  
27.         Session session = sessionFactory.openSession();  
28.           
29.         //hibernate下要开启事务进行保存  
30.         session.beginTransaction();  
31.         //保存  
32.         session.save(user);  
33.         //提交事务  
34.         session.getTransaction().commit();  
35.         //关闭事务  
36.         session.close();  
37.     }  
38. }  

测试类执行过程

在测试文件中的一些类

1. Configuration类
   • 是Hibernate的入口，它负责配置并启动Hibernate。
   • Hibernate通过Configuration的实例加载配置文件信息，然后读取指定对象关系映射文件的内容并创建SessionFactory实例。
2. SessionFactory接口
   •   负责初始化Hibernate。
   • 一个SessionFactory实例对应一个数据库。应用程序从SessionFactory中获得Session实例。
3. Session接口
   • Session被称为持久化管理器
   • 负责管理与持久化相关的操作：存储、更新、删除和加载对象。
4. Transaction接口
   • 是Hibernate框架的事务接口。
   • 它对底层的事务接口做了封装。包括：JDBC API和JTA。

Session的缓存 （一级缓存）

Session的CRUD方法以及调用查询接口的list()，iterate()方法时

怎么寻找：

• 如果session缓存中不存在相应的对象，Hibernate就会把该对象加入到第一级缓存中
• 如果session缓存中已经存在这个对象，就不需在去数据库加载，而直接使用缓存中的对象。

session的缓存一般交由hibernate框架自动管理。

• flush: 进行清理缓存(此时缓存中的数据并不丢失)的操作,让缓存和数据库同步 执行一些列sql语句，但不提交事务,；
• commit:先调用flush() 方法，然后提交事务. 则意味着提交事务意味着对数据库操作永久保存下来。   

【实例】增删改查

新建一个工具类：HibernateUtil.java

1. package www.hbsi.com.utils;  
2.   
3. import org.hibernate.Session;  
4. import org.hibernate.SessionFactory;  
5. import org.hibernate.cfg.Configuration;  
6.   
7. public class HibernateUtil {  
8.     private static Session session;  
9.   
10.     static {  
11.         //加载配置文件  
12.         Configuration config = new Configuration().configure();  
13.         //session工厂  
14.         SessionFactory sf = config.buildSessionFactory();  
15.         session = sf.openSession();  
16.     }  
17.   
18.     public static Session getSession() {  
19.         return session;  
20.     }  
21. }  

编写增删改查：crud.java

1. package www.hbsi.com.demo;  
2.   
3. import java.util.Date;  
4. import java.util.List;  
5.   
6. import org.hibernate.Query;  
7. import org.hibernate.Session;  
8. import org.hibernate.Transaction;  
9. import org.junit.Test;  
10.   
11. import www.hbsi.com.domain.User;  
12. import www.hbsi.com.utils.HibernateUtil;  
13.   
14. public class curd {  
15.     Transaction tx = null;  
16.     Session session = null;  
17.   
18.     /* 
19.      * 增加用户 
20.      */  
21.     @Test  
22.     public void addUser() {  
23.         User user = new User();  
24.         user.setName("Linda");  
25.         user.setBirthday(new Date());  
26.   
27.         // 获取session  
28.         try {  
29.             session = HibernateUtil.getSession();  
30.             session.beginTransaction();  
31.             // 增加  
32.             session.save(user);  
33.             session.getTransaction().commit();  
34.         } catch (Exception e) {  
35.             if (tx != null)  
36.                 tx.rollback();  
37.             // throw new RuntimeException(e);//扔出异常  
38.             e.printStackTrace();// 打印轨迹，打印异常  
39.         } finally {  
40.             if (session != null)  
41.                 session.close();  
42.         }  
43.   
44.     }  
45.       
46.     /* 
47.      * 根据id查找用户 
48.      */  
49.     @Test  
50.     public void findUser() {  
51.   
52.         Session session = HibernateUtil.getSession();  
53.         User user = (User) session.get(User.class, 1);  
54.         System.out.println(user.getName() + "---" + user.getBirthday());  
55.         session.close();  
56.   
57.     }  
58.       
59.     /* 
60.      * load方式查找用户 
61.      * 和get方法区别，load属于懒加载 
62.      * 如果没有输出语句，get运行时控制台输出sql语句，load运行不输出sql语句 
63.      * load在调用的时候才加载sql语句 
64.      */  
65.     @Test  
66.     public void loadFindTest() {  
67.         Session session = HibernateUtil.getSession();  
68.         User user = (User) session.load(User.class, 2); // 懒加载，延迟加载  
69.         System.out.println(user.getName()+"---"+user.getBirthday());  
70.         session.close();  
71.     }  
72.       
73.     /* 
74.      * 根据id删除用户 
75.      */  
76.   
77.     @Test  
78.     public void deleteUser() {  
79.   
80.         /*找到之后删除 
81.          
82.          Session session = HibernateUtil.getSession(); 
83.          session.beginTransaction();  
84.          User user = (User)session.get(User.class, 3);  
85.          session.delete(user); 
86.          session.getTransaction().commit();  
87.          session.close(); 
88.          */  
89.            
90.         //直接删除  
91.         Session session = HibernateUtil.getSession();  
92.         session.beginTransaction();  
93.         User user = new User();  
94.         user.setId(1);  
95.         session.delete(user);  
96.         session.getTransaction().commit();  
97.         session.close();  
98.   
99.     }  
100.       
101.     /* 
102.      * 修改用户 
103.      */  
104.   
105.     @Test  
106.     public void updateUser() {  
107.          //找到修改  
108.         /* Session session = HibernateUtil.getSession(); 
109.          session.beginTransaction(); 
110.           
111.          User user = (User) session.get(User.class,1); 
112.          user.setName("Tom"); 
113.          session.update(user); 
114.           
115.          session.getTransaction().commit(); session.close(); 
116.          */  
117.            
118.         //直接修改  
119.         //如果不给birthday复制，birthday值为空  
120.         Session session = HibernateUtil.getSession();  
121.         session.beginTransaction();  
122.   
123.         User user = new User();  
124.         user.setId(1);  
125.         user.setName("Tom");  
126.         session.update(user);  
127.   
128.         session.getTransaction().commit();  
129.         session.close();  
130.   
131.     }  
132.       
133.     /* 
134.      * 查找所有 
135.      */  
136.     @Test  
137.     public void getAll() {  
138.         Session session = HibernateUtil.getSession();  
139.         Query query = session.createQuery("from User"); // HQL;针对实体类  
140.         List<User> users = query.list();  
141.         for (User user : users) {  
142.             System.out.println(user.getId() + ":" + user.getName() + ":"  
143.                     + user.getBirthday());  
144.         }  
145.     }  
146. }  

查找

根据id删除

直接删除

修改，直接修改

修改，查找后修改

查询所有

load方式查询

Session的几个主要方法

1. save：保存数据
2. delete：删除对象
3. update：更新对象，如果数据库中没有记录，会出现异常。
4. get：根据ID查，会立刻访问数据库。
5. Load：根据ID查，(返回的是代理，不会立即访问数据库)。
6. saveOrUpdate： (根据ID和version的值来确定是save或update

主键生成机制

native最常用