非本人總結(jié)的筆記，抄點筆記復習復習。感謝傳智博客及黑馬程序猿
記筆記啊記筆記
Hibernate的簡介
什么是Hibernate
Hibernate：冬眠。對類進行實例化操作，這里類指的是之前說的javabean，javabean正確的叫法：實體類 entity
Hibernate是輕量級JavaEE應用的持久層解決方案，是一個關系數(shù)據(jù)庫****ORM****框架
Hibernate具體實現(xiàn)的操作：
Hibernate的是開源輕量級的框架，對jdbc的代碼進行封裝，程序員不需要寫底層的sql語句的代碼，就可以實現(xiàn)對數(shù)據(jù)庫的操作。實現(xiàn)對數(shù)據(jù)庫的crud操作。
Javaee中有三層結(jié)構(gòu)
Web層：struts2
Service層：spring
持久化層（dao層）：hibernate框架
Hibernate是使用在持久化層的框架
Jdbc底層代碼的步驟：
1 加載驅(qū)動
2 創(chuàng)建連接
3 對sql語句進行預編譯操作
4 設置參數(shù)，執(zhí)行sql語句
5 釋放資源
什么是ORM
ORM: object relational mapping , 對象關系映射
ORM 就是通過將Java對象映射到數(shù)據(jù)庫表，通過操作Java對象，就可以完成對數(shù)據(jù)表的操作
做操作時候，有實體類 ，有數(shù)據(jù)庫表 ，
在hibernate中，讓實體類和數(shù)據(jù)庫進行映射對應的關系（配置文件配置），
操作實體類就相當于操作數(shù)據(jù)庫表中的數(shù)據(jù)
流行數(shù)據(jù)庫框架
JPA Java Persistence API.JPA通過JDK 5.0注解或XML描述對象－關系表的映射關系（只有接口規(guī)范）
Hibernate 最流行ORM框架，通過對象-關系映射配置，可以完全脫離底層SQL
MyBatis 本是apache的一個開源項目 iBatis，支持普通 SQL查詢，存儲過程和高級映射的優(yōu)秀持久層框架
Apache DBUtils 、Spring JDBCTemplate
Hibernate的優(yōu)點
- Hibernate對JDBC訪問數(shù)據(jù)庫的代碼做了封裝，大大簡化了數(shù)據(jù)訪問層繁瑣的重復性代碼
- Hibernate是一個基于jdbc的主流持久化框架，是一個優(yōu)秀的orm實現(xiàn)，它很大程度的簡化了dao層編碼工作
- Hibernate使用java的反射機制，而不是字節(jié)碼增強程序類實現(xiàn)透明性
- Hibernate的性能非常好，因為它是一個輕量級框架。映射的靈活性很出色。它支持很多關系型數(shù)據(jù)庫，從一對一到多對多的各種復雜關系
Hibernate的版本
Struts2 版本 2.3.15
Hibernate 版本 3.6.10
Hibernate 3.x 4.x 5.x
1、下載hibernate3.x的開發(fā)包 (3.6.10)
http://sourceforge.net/projects/hibernate/files/hibernate3/
2.jar包作用
Hibernate的入門案例
Hibernate的開發(fā)環(huán)境搭建
第一步：導入hibernate的核心的jar包
1、導入hibernate的核心的jar包
2、導入lib里面的required里面的所有的jar包
?
?
3、導入lib里面jpa中所有的jar包
?
4、hibernate需要日志的輸出
? hibernate本身不支持日志輸出，導入第三方支持日志輸出的jar包（兩個）
?
5、導入數(shù)據(jù)庫驅(qū)動的jar包
加上數(shù)據(jù)庫驅(qū)動jar包一共有 11個
?
第二步：創(chuàng)建實體類 user類
package cn.itcast.entity;
import java.util.Date;
/**
* 實體類
*/
public class User {
private Integer id;
private String username;
private Date birthday;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
第三步：創(chuàng)建Hibernate的核心配置文件
1、Hibernate的核心配置文件
名稱必須是 hibernate.cfg.xml，位置放到 src下面
2、在核心配置文件中引入dtd約束
<?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">
3、配置的相關信息
（1）配置數(shù)據(jù)庫的相關內(nèi)容
（2）配置hibernate的相關內(nèi)容
<hibernate-configuration>
<session-factory>
<!-- 配置數(shù)據(jù)庫的相關信息 -->
<property name="hibernate.connection.driver_class">
com.mysql.jdbc.Driver
</property>
<property name="hibernate.connection.url">
jdbc:mysql:///hibernate_day01
</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<!-- 配置數(shù)據(jù)庫的方言
比如在mysql里面有關鍵字 limit ，只能使用在mysql里面
讓hibernate識別到不同數(shù)據(jù)庫自己特有的語句
-->
<property name="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
<!-- 配置hibernate的相關信息 -->
<!-- 是否顯示底層的sql語句 -->
<property name="hibernate.show_sql">true</property>
<!-- 是否格式化sql語句 -->
<property name="hibernate.format_sql">true</property>
<!-- hibernate會幫自己創(chuàng)建數(shù)據(jù)庫表，默認不會創(chuàng)建，需要配置
值 update： 如果數(shù)據(jù)庫里面不存在表，創(chuàng)建；如果已經(jīng)存在，更新
-->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 配置事務自動提交 -->
<!-- <property name="hibernate.connection.autocommit">true</property> -->
<!-- 引入映射配置文件 -->
<mapping resource="cn/itcast/entity/User.hbm.xml" />
</session-factory>
</hibernate-configuration>
第四步：配置實體類和數(shù)據(jù)表映射關系
1、創(chuàng)建映射配置文件，文件格式xml
但是這個文件映射配置文件名稱和位置沒有要求，一般建議：命名(實體類.hbm.xml) 位置：放到實體類所在的包里面
2、映入dtd約束
<?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">
3、配置實體類和表映射關系
<hibernate-mapping>
<!-- 配置實體類名稱和表名稱對應
name：實體類全路徑
table：表名稱
-->
<class name="cn.itcast.entity.User" table="USER">
<!--
在hibernate中要求每個表有一個唯一標識
-->
<id name="id" column="ID">
<generator class="identity"></generator>
</id>
<!-- 配置其他的屬性和其他字段映射
name: 實體類屬性名稱
column: 表里面字段名稱
細節(jié)問題：
1 propery里面有 type屬性，指定字段類型，但是可以省略
2 column屬性，實體類屬性名稱和字段名稱一樣，column可以省略
-->
<property name="username" column="USERNAME"></property>
<property name="birthday" column="BIRTHDAY"></property>
</class>
</hibernate-mapping>
第五步：在Hibernate的核心配置文件中映入映射文件
因為hibernate只會加載核心配置文件，其他文件不會加載
如果沒有在核心文件中引入映射文件，出現(xiàn)錯誤
可以在myeclipse 直接把映射文件拖到核心配置文件里就可以了
<!--
引入映射配置文件 -->
<mapping resource="cn/itcast/entity/User.hbm.xml"
/>
實現(xiàn)添加操作
使用hibernate代碼實現(xiàn)crud操作，步驟是固定
第一步 加載核心配置文件
第二步 創(chuàng)建sessionFactory
第三步 使用sessionFactory創(chuàng)建session
第四步 開啟事務
第五步 寫具體邏輯（crud）
第六步 提交事務
第七步 關閉資源
package cn.itcast.hibernate.test;
import java.util.Date;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;
/**
實現(xiàn)hibernate的crud的操作
*/
public class TestDemo1 {
//實現(xiàn)添加操作
@Test
public void add() {
//加載核心配置文件
Configuration cfg = new Configuration();
cfg.configure();
//創(chuàng)建sessionFactory
SessionFactory sessionFactory = cfg.buildSessionFactory();
//打開session
Session session = sessionFactory.openSession();
//開啟事務
Transaction tx = session.beginTransaction();
//寫添加邏輯
//項數(shù)據(jù)庫設置值
User user = new User();
user.setUsername("lucy");
user.setBirthday(new Date());
//調(diào)用session里面的方法 save方法,保存的意思
session.save(user);
//提交事務
tx.commit();
//關閉連接
session.close();
sessionFactory.close();
}
}
Hibernate的配置文件詳解（hibernate.cfg.xml）
1、hibernate中加載核心配置文件
要求
- 位置：放到src下
- 名稱：必須是hibernate.cfg.xml
配置三部分
- 配置數(shù)據(jù)庫信息（必須的）
- 配置hibernate的相關信息（不是必須的）
- 配置引入的映射文件（如果有映射文件必須配置）
2、映射配置文件
位置和名稱沒有固定要求
核心API使用
Configuration類（管理Hibernate的配置信息）
Configuration 類負責管理 Hibernate 的配置信息。包括如下內(nèi)容：
加載hibernate.properties 和 hibernate.cfg.xml
持久化類與數(shù)據(jù)表的映射關系（*.hbm.xml文件）
創(chuàng)建Configuration 的兩種方式
? 屬性文件（hibernate.properties）:
Configuration cfg = new Configuration(); //手動加載hbm
? Xml文件（hibernate.cfg.xml）
Configuration cfg = newConfiguration().configure();
在核心配置文件中引入映射配置文件
之前做法：
還有另外方式加載映射配置文件（了解）
?
SessionFactory接口（獲取Session對象）
Configuration對象根據(jù)當前的配置信息生成SessionFactory對象
SessionFactory對象中保存了當前數(shù)據(jù)庫配置信息和所有映射關系以及預定義的SQL語句
SessionFactory對象是線程安全的
SessionFactory還負責維護Hibernate的二級緩存
Configuration configuration = new Configuration().configure();
創(chuàng)建sessionFactory
SessionFactory sessionFactory = configuration.buildSessionFactory();
可以通過SessionFactory對象 獲得Session對象
Session session = sessionFactory.openSession();
構(gòu)造SessionFactory 很消耗資源，一般情況下一個應用只初始化一個
☆抽取HibernateUtils 用來提供Session對象
創(chuàng)建HibernateUtils
package cn.itcast.utils;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
/**
* 創(chuàng)建sessionFactory對象
*/
public class HibernateUtils {
static Configuration cfg = null;
static SessionFactory sessionFactory = null;
//靜態(tài)代碼塊
static {
cfg = new Configuration();
cfg.configure();
//創(chuàng)建sessionFactory
sessionFactory = cfg.buildSessionFactory();
}
//提供得到Session的方法
public static Session getSession() {
Session session = sessionFactory.openSession();
return session;
}
}
使用工具類得到session對象
package cn.itcast.hibernate.test;
import java.util.Date;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;
/**
* 實現(xiàn)hibernate的crud的操作
*/
public class TestDemo1 {
//實現(xiàn)添加操作
@Test
public void addTestSession() {
//根據(jù)工具類得到session對象
Session session = HibernateUtils.getSession();
//開啟事務
Transaction tx = session.beginTransaction();
//寫添加邏輯
User user = new User();
user.setUsername("jacktom");
user.setBirthday(new Date());
//調(diào)用session里面的方法 save方法
session.save(user);
//提交事務
tx.commit();
//關閉連接
session.close();
//sessionFactory不需要關閉了
// sessionFactory.close();
}
}
Session接口（CRUD操作）
調(diào)用Session里面的方法，實現(xiàn)crud操作
Session是單線程對象，只能有一個操作時候，不能同時多個操作使用，不要把Session變量定義成成員變量，每次使用都創(chuàng)建新對象，相當于JDBC的Connection
Session是應用程序與數(shù)據(jù)庫之間交互操作的一個單線程對象，是 Hibernate 運作的中心；Session是線程不安全的
所有持久化對象必須在session 的管理下才可以進行持久化操作
Session 對象有一個一級緩存，顯式執(zhí)行 flush 之前，所有的持久化操作的數(shù)據(jù)都緩存在 session 對象處
持久化類與 Session 關聯(lián)起來后就具有了持久化的能力
常用方法
| 方法 | 作用 |
|---|---|
| save()/persist() 、update() 、saveOrUpdate() | 增加和修改對象 |
| delete() | 刪除對象 |
| get()/load() | 根據(jù)主鍵查詢 |
| createQuery()、createSQLQuery() | 數(shù)據(jù)庫操作對象 |
| createCriteria | 條件查詢 |
Transaction接口(事務)
代表數(shù)據(jù)庫操作的事務對象
Transactiontransaction = session.beginTransaction();
提供事務管理的方法
commit():提交相關聯(lián)的session實例
rollback():撤銷事務操作
wasCommitted():檢查事務是否提交
回顧：
什么是事務
兩個操作：提交和回滾
事務特性：原子性、一致性、隔離性、持久性
不考慮隔離性產(chǎn)生問題：臟讀、不可重復讀、虛讀
在jdbc中，使用jdbc代碼實現(xiàn)添加操作，默認事務自動提交
在hibernate中，事務默認不是自動提交的，需要手動配置，手動代碼提交
如果沒有開啟事務，那么每個Session的操作，都相當于一個獨立的事務
讓hibernate事務提交有兩種：
第一種： 通過配置方式設置hibernate是自動提交
產(chǎn)生問題：第一個save方法添加數(shù)據(jù)，但是添加之后出現(xiàn)異常，第二個添加不能完成
第二種：手動代碼方式控制事務
package cn.itcast.hibernate.test;
import java.util.Date;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;
/**
*實現(xiàn)hibernate的crud的操作
*
*/
public class TestDemo1 {
//事務操作
@Test
public void testTx() {
//根據(jù)工具類得到session對象
Session session = null;
//開啟事務
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();
//實現(xiàn)兩次添加操作
//寫添加邏輯
User user = new User();
user.setUsername("jacktom");
user.setBirthday(new Date());
//調(diào)用session里面的方法 save方法
session.save(user);
//發(fā)生異常
int a = 1/0;
User user1 = new User();
user1.setUsername("lilei");
user1.setBirthday(new Date());
//調(diào)用session里面的方法 save方法
session.save(user1);
//提交
tx.commit();
}catch(Exceptione) {
e.printStackTrace();
//回滾
tx.rollback();
}finally {
//關閉session
session.close();
}
}
}
Query接口(HQL語句查詢操作)
Query代表面向?qū)ο蟮囊粋€Hibernate查詢操作
session.createQuery 接受一個HQL語句
HQL是Hibernate Query Language縮寫，語法很像SQL語法，但是完全面向?qū)ο蟮?/p>
使用Query對象步驟
獲得Hibernate Session對象
編寫HQL語句
? 調(diào)用session.createQuery 創(chuàng)建查詢對象
? 如果HQL語句包含參數(shù)，則調(diào)用Query的setXXX設置參數(shù)
? 調(diào)用Query對象的list() 或uniqueResult() 方法執(zhí)行查詢
Query還包含兩個方法 用于控制返回結(jié)果
? setFirstResult(intfirstResult) 設置返回結(jié)果從第幾條開始
? setMaxResults(intmaxResults) 設置本次返回結(jié)果記錄條數(shù)
實現(xiàn)查詢的操作
Query query = session.createQuery(“hql語句”)
query.list(); 返回集合
package cn.itcast.hibernate.test;
import java.util.Date;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;
/**
* 實現(xiàn)hibernate的crud的操作
*/
public class TestDemo1 {
//query使用
@Test
public void testQuery() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();
//查詢表中所有的記錄
//hql語句 User是實體類的名稱
Query query = session.createQuery("from User");
List<User> list = query.list();
for (User user : list) {
System.out.println(user);
}
tx.commit();
}catch(Exception e) {
tx.rollback();
}finally {
session.close();
}
}
}
Hibernate實現(xiàn)crud操作（重點）
功能具體介紹
（1）添加操作save
調(diào)用Session里的save（實體類對象），不需要設置對象的id值
User user = new User();
user.setUsername("jackTom");
user.setBirthday(new Date());
session.save(user);//調(diào)用Session里的save方法
（2）根據(jù)主鍵查詢操作
調(diào)用Session里面的get方法
get方法里面有兩個參數(shù)：
| 參數(shù) | 值 |
|---|---|
| 參數(shù)一 | 返回實體類的Class |
| 參數(shù)二 | id值 |
User user = (User)session.get(User.class, 1);//調(diào)用Session里面的get方法
（3）修改操作update
調(diào)用session里面的方法update方法
update方法里面?zhèn)鬟f參數(shù)有一個：
修改之后的值，封裝到實體類對象，這個對象中必須有id值
做修改操作時候?qū)崿F(xiàn)的步驟： 首先 根據(jù)id把原始信息查詢出來 其次，設置要修改的值 最后，調(diào)用update方法實現(xiàn)
User user = new User();
user.setId(2);
user.setUsername("東方不敗");
session.update(user);
做修改操作時候?qū)崿F(xiàn)的步驟：
首先 根據(jù)id把原始信息查詢出來
其次，設置要修改的值
最后，調(diào)用update方法實現(xiàn)
//修改：根據(jù)id修改
//修改id=1的username，修改為其他值
//根據(jù)id查詢出來對象
User user = (User)session.get(User.class, 1);
//設置對象中，要修改的值
user.setUsername("大腹便便");
//調(diào)用update方法實現(xiàn)
session.update(user);
（4）刪除操作delete
調(diào)用session里面的方法 delete方法
Delete方法中傳遞一個參數(shù)： 實體類對象，對象中至少要有一個id值
實現(xiàn)方式有兩種
第一種 先查詢出來對象，再調(diào)用delete方法刪除
//刪除id是4的記錄
//查詢id是4的記錄
User user = (User)session.get(User.class, 4);
//調(diào)用delete方法
session.delete(user)
第二種 創(chuàng)建對象，設置id值，再調(diào)用delete方法刪除
//刪除id是3的記錄
//創(chuàng)建對象
User user = new User();
//設置id值
user.setId(3);
//調(diào)用delete方法刪除
session.delete(user);
（5）查詢操作(3種)hql sql qbc
查詢表中所有記錄
第一種 使用hql查詢
//創(chuàng)建query對象
Query query = session.createQuery("from User");
//調(diào)用query里面list方法返回list集合
List<User> list = query.list();
for(User user : list){
System.out.println(user);
}
第二種 使用本地sql查詢（會用）
//創(chuàng)建對象
SQLQuery query = session.createSQLQuery("select * from user");
//調(diào)用query里面的方法
//返回list集合，每部分不是對象形式，而是數(shù)據(jù)形式
List<Object[]> list = query.list();
for(Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}
crud代碼演示:
package cn.itcast.hibernate.test;
import java.util.Arrays;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;
/**
* 實現(xiàn)hibernate的crud的操作
*/
public class TestDemo2 {
//根據(jù)主鍵查詢
@Test
public void testGet() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();
//調(diào)用session里面get方法
User user = (User) session.get(User.class, 1);
System.out.println(user);
tx.commit();
}catch(Exception e) {
tx.rollback();
}finally {
session.close();
}
}
//本地sql查詢
@Test
public void testSQL() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();
//創(chuàng)建對象
SQLQuery query = session.createSQLQuery("select * from user");
//調(diào)用query里面的方法
//返回list里面，每部分不是對象形式，而是數(shù)組形式
List<Object[]> list = query.list();
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}
tx.commit();
}catch(Exception e) {
tx.rollback();
}finally {
session.close();
}
}
//hql語句查詢 Query
@Test
public void testHQL() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();
//創(chuàng)建query對象
Query query = session.createQuery("from User");
//調(diào)用query里面list方法返回list集合
List<User> list = query.list();
for (User user : list) {
System.out.println(user);
}
tx.commit();
}catch(Exception e) {
tx.rollback();
}finally {
session.close();
}
}
//第二種直接刪除操作(不建議使用)
@Test
public void testDeleteDemo2() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();
//刪除id是3的記錄
//創(chuàng)建對象
User user = new User();
//設置id值
user.setId(2);
//調(diào)用delete方法刪除
session.delete(user);
tx.commit();
}catch(Exception e) {
tx.rollback();
}finally {
session.close();
}
}
//第一種刪除操作(先查詢在刪除方法)建議使用
@Test
public void testDeleteDemo1() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();
//刪除id是4的記錄
//查詢id是4的對象
User user = (User) session.get(User.class, 4);
//調(diào)用delete方法
session.delete(user);
tx.commit();
}catch(Exception e) {
tx.rollback();
}finally {
session.close();
}
}
//修改操作(先查詢在修改)
@Test
public void testUpdateSuccess() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();
//修改：根據(jù)id修改
// 修改id=1的username，修改為 其他值
//根據(jù)id查詢出來對象
User user = (User) session.get(User.class, 1);
//設置對象中，要修改成的值
user.setUsername("大腹便便");
//調(diào)用update方法實現(xiàn)
session.update(user);
tx.commit();
}catch(Exception e) {
tx.rollback();
}finally {
session.close();
}
}
//修改操作(直接修改)
@Test
public void testUpdate() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();
//修改：根據(jù)id修改
// 修改id=2的username，修改為 東方不敗
//創(chuàng)建實體類對象
//操作實現(xiàn)修改，但是問題：
//調(diào)用update方法之后，把表里面所有字段都修改
//只是設置id和username值，根據(jù)id修改username和birthday
User user = new User();
user.setId(2);
user.setUsername("東方不敗");
session.update(user);
tx.commit();
}catch(Exception e) {
tx.rollback();
}finally {
session.close();
}
}
}
基本數(shù)據(jù)類型和包裝類使用
回顧：
Java中基本數(shù)據(jù)類型 有8個 byte short int long float double char boolean
對應的包裝類：
? int---Integer char---Character，其他是首字母大寫
? 在實體類中使用基本數(shù)據(jù)類型還是使用包裝類？
都是使用包裝類。
考試成績。
可以使用類型 int 和 包裝類 Integer
一般都使用 包裝類
表示 學生得分是 0 分
int score = 0;
Integer score = 0;
表示學生是否參加考試
int score = 0;
Integer score = null;
Hibernate的主鍵oid
什么是oid
在java中，區(qū)分不同的對象，根據(jù)對象的地址
在數(shù)據(jù)庫中，區(qū)別不同的記錄，根據(jù)主鍵id值
現(xiàn)在是實體類和數(shù)據(jù)庫映射關系
在java中沒有主鍵，在數(shù)據(jù)庫里面沒有地址
使用hibernate的OID區(qū)別不同的對象，如果OID相同的就是一個對象
自然主鍵和代理主鍵
自然主鍵：
Oid和業(yè)務相關的屬性或者字段
比如人的身份證號碼
代理主鍵：
Oid和業(yè)務不相關的屬性和字段
比如寫id
配置Hibernate的oid
<id name="id" column="ID">
<generator class="native"></generator>
</id>
使用id標簽
有name屬性 值寫 實體類屬性名稱
Column屬性值 寫數(shù)據(jù)庫表字段
在id標簽里面使用 generator，配置oid
有class屬性值 oid主鍵的生成策略
Hibernate的oid主鍵生成策略
Increment和identity
使用increment作為生成策略，生成建表語句中沒有AUTO_INCREMENT自動增長
使用identity作為生成策略，生成的語句中 有AUTO_INCREMENT自動增長
詳解:
