前言
本博文主要講解介紹Hibernate框架,ORM的概念和Hibernate入門,相信大家看了就會使用Hibernate了!html
什麼是Hibernate框架?
Hibernate是一種ORM框架,全稱爲 Object_Relative DateBase-Mapping,在Java對象與關係數據庫之間創建某種映射,以實現直接存取Java對象!java
爲何要使用Hibernate?
既然Hibernate是關於Java對象和關係數據庫之間的聯繫的話,也就是咱們MVC中的數據持久層->在編寫程序中的DAO層...mysql
首先,咱們來回顧一下咱們在DAO層寫程序的歷程吧:sql
- 在DAO層操做XML,將數據封裝到XML文件上,讀寫XML文件數據實現CRUD
- 在DAO層使用原生JDBC鏈接數據庫,實現CRUD
- 嫌棄JDBC的Connection\Statement\ResultSet等對象太繁瑣,使用對原生JDBC的封裝組件-->DbUtils組件
咱們來看看使用DbUtils以後,程序的代碼是怎麼樣的:數據庫
public class CategoryDAOImpl implements zhongfucheng.dao.CategoryDao{
@Override
publicvoidaddCategory(Category category) {
QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
String sql = "INSERT INTO category (id, name, description) VALUES(?,?,?)";
try {
queryRunner.update(sql, new Object[]{category.getId(), category.getName(), category.getDescription()});
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public Category findCategory(String id) {
QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
String sql = "SELECT * FROM category WHERE id=?";
try {
Category category = (Category) queryRunner.query(sql, id, new BeanHandler(Category.class));
return category;
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public List<Category> getAllCategory() {
QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
String sql = "SELECT * FROM category";
try {
List<Category> categories = (List<Category>) queryRunner.query(sql, new BeanListHandler(Category.class));
return categories;
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
其實使用DbUtils時,DAO層中的代碼編寫是很有規律的。服務器
- 當插入數據的時候,就將JavaBean對象拆分,拼裝成SQL語句
- 當查詢數據的時候,用SQL把數據庫表中的列組合,拼裝成JavaBean對象
也就是說:javaBean對象和數據表中的列存在映射關係!若是程序可以自動生成SQL語句就行了....那麼Hibernate就實現了這個功能!微信
簡單來講:咱們使用Hibernate框架就不用咱們寫不少繁瑣的SQL語句,從而簡化咱們的開發!markdown
ORM概述
在介紹Hibernate的時候,說了Hibernate是一種ORM的框架。那什麼是ORM呢?ORM是一種思想session
- O表明的是Objcet
- R表明的是Relative
- M表明的是Mapping
ORM->對象關係映射....ORM關注是對象與數據庫中的列的關係併發
Hibernate快速入門
學習一個框架無非就是三個步驟:
- 引入jar開發包
- 配置相關的XML文件
- 熟悉API
引入相關jar包
咱們使用的是Hibernate3.6的版本
hibernate3.jar核心 + required 必須引入的(6個) + jpa 目錄 + 數據庫驅動包
編寫對象和對象映射
編寫一個User對象->User.java
public class User {
private int id;
private String username;
private String password;
private String cellphone;
//各類setter和getter
}
編寫對象映射->User.hbm.xml。通常它和JavaBean對象放在同一目錄下
咱們是不知道該XML是怎麼寫的,能夠搜索一下Hibernate文件夾中後綴爲.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">
<!-- This mapping demonstrates content-based discrimination for the table-per-hierarchy mapping strategy, using a formula discriminator.-->
<hibernate-mapping package="org.hibernate.test.array">
<class name="A" lazy="true" table="aaa">
<id name="id">
<generator class="native"/>
</id>
<array name="bs" cascade="all" fetch="join">
<key column="a_id"/>
<list-index column="idx"/>
<one-to-many class="B"/>
</array>
</class>
<class name="B" lazy="true" table="bbb">
<id name="id">
<generator class="native"/>
</id>
</class>
</hibernate-mapping>
- 在上面的模板上修改~下面會具體講解這個配置文件!
<!--在domain包下-->
<hibernate-mapping package="zhongfucheng.domain">
<!--類名爲User,表名也爲User-->
<class name="User" table="user">
<!--主鍵映射,屬性名爲id,列名也爲id-->
<id name="id" column="id">
<!--根據底層數據庫主鍵自動增加-->
<generator class="native"/>
</id>
<!--非主鍵映射,屬性和列名一一對應-->
<property name="username" column="username"/>
<property name="cellphone" column="cellphone"/>
<property name="password" column="password"/>
</class>
</hibernate-mapping>
主配置文件
hibernate.cfg.xml
若是使用Intellij Idea生成的Hibernate能夠指定生成出主配置文件hibernate.cfg.xml
,它是要放在src目錄下的
若是不是自動生成的,咱們能夠在Hibernate的hibernate-distribution-3.6.0.Final\project\etc
這個目錄下能夠找到
它長得這個樣子:
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="connection.url."/>
<property name="connection.driver_class"/>
<property name="connection.username"/>
<property name="connection.password"/>
<!-- DB schema will be updated if needed -->
<!-- <property name="hbm2ddl.auto">update</property> -->
</session-factory>
</hibernate-configuration>
經過上面的模板進行修改,後面會有對該配置文件進行講解!
<hibernate-configuration>
<!-- 一般,一個session-factory節點表明一個數據庫 -->
<session-factory>
<!-- 1. 數據庫鏈接配置 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql:///zhongfucheng</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<!-- 數據庫方法配置, hibernate在運行的時候,會根據不一樣的方言生成符合當前數據庫語法的sql -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
<!-- 2. 其餘相關配置 -->
<!-- 2.1 顯示hibernate在運行時候執行的sql語句 -->
<property name="hibernate.show_sql">true</property>
<!-- 2.2 格式化sql -->
<property name="hibernate.format_sql">true</property>
<!-- 2.3 自動建表 -->
<property name="hibernate.hbm2ddl.auto">create</property>
<!--3. 加載全部映射-->
<mapping resource="zhongfucheng/domain/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
測試
package zhongfucheng.domain;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
/** * Created by ozc on 2017/5/6. */
public class App {
publicstaticvoidmain(String[] args) {
//建立對象
User user = new User();
user.setPassword("123");
user.setCellphone("122222");
user.setUsername("nihao");
//獲取加載配置管理類
Configuration configuration = new Configuration();
//不給參數就默認加載hibernate.cfg.xml文件,
configuration.configure();
//建立Session工廠對象
SessionFactory factory = configuration.buildSessionFactory();
//獲得Session對象
Session session = factory.openSession();
//使用Hibernate操做數據庫,都要開啓事務,獲得事務對象
Transaction transaction = session.getTransaction();
//開啓事務
transaction.begin();
//把對象添加到數據庫中
session.save(user);
//提交事務
transaction.commit();
//關閉Session
session.close();
}
}
值得注意的是:JavaBean的主鍵類型只能是int類型,由於在映射關係中配置是自動增加的,String類型是不能自動增加的。若是是你設置了String類型,又使用了自動增加,那麼就會報出下面的錯誤!
Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Table 'zhongfucheng.user' does
執行完程序後,Hibernate就爲咱們建立對應的表,並把數據存進了數據庫了
咱們看看快速入門案例的代碼用到了什麼對象吧,而後一個一個講解
publicstaticvoidmain(String[] args) {
//建立對象
User user = new User();
user.setPassword("123");
user.setCellphone("122222");
user.setUsername("nihao");
//獲取加載配置管理類
Configuration configuration = new Configuration();
//不給參數就默認加載hibernate.cfg.xml文件,
configuration.configure();
//建立Session工廠對象
SessionFactory factory = configuration.buildSessionFactory();
//獲得Session對象
Session session = factory.openSession();
//使用Hibernate操做數據庫,都要開啓事務,獲得事務對象
Transaction transaction = session.getTransaction();
//開啓事務
transaction.begin();
//把對象添加到數據庫中
session.save(user);
//提交事務
transaction.commit();
//關閉Session
session.close();
}
Configuration
配置管理類:主要管理配置文件的一個類
它擁有一個子類AnnotationConfiguration,也就是說:咱們可使用註解來代替XML配置文件來配置相對應的信息
configure方法
configure()方法用於加載配置文件
- 加載主配置文件的方法
- 若是指定參數,那麼加載參數的路徑配置文件
- 若是不指定參數,默認加載src/目錄下的hibernate.cfg.xml
buildSessionFactory方法
buildSessionFactory()用於建立Session工廠
SessionFactory
SessionFactory-->Session的工廠,也能夠說表明了hibernate.cfg.xml這個文件...hibernate.cfg.xml的就有<session-factory>
這麼一個節點
openSession方法
建立一個Session對象
getCurrentSession方法
建立Session對象或取出Session對象
Session
Session是Hibernate最重要的對象,Session維護了一個鏈接(Connection),只要使用Hibernate操做數據庫,都須要用到Session對象
一般咱們在DAO層中都會有如下的方法,Session也爲咱們提供了對應的方法來實現!
public interface IEmployeeDao {
voidsave(Employee emp);
voidupdate(Employee emp);
Employee findById(Serializable id);
List<Employee> getAll();
List<Employee> getAll(String employeeName);
List<Employee> getAll(int index, int count);
voiddelete(Serializable id);
}
更新操做
咱們在快速入門中使用到了save(Objcet o)方法,調用了這個方法就把對象保存在數據庫之中了。Session對象還提供着其餘的方法來進行對數據庫的更新
- session.save(obj); 【保存一個對象】
- session.update(obj); 【更新一個對象】
- session.saveOrUpdate(obj); 【保存或者更新的方法】
- 沒有設置主鍵,執行保存;
- 有設置主鍵,執行更新操做;
- 若是設置主鍵不存在報錯!
咱們來使用一下update()方法吧....既然是更新操做了,那麼確定須要設置主鍵的,不設置主鍵,數據庫怎麼知道你要更新什麼。將id爲1的記錄修改爲以下:
user.setId(1);
user.setPassword("qwer");
user.setCellphone("1111");
user.setUsername("zhongfucheng");
主鍵查詢
經過主鍵來查詢數據庫的記錄,從而返回一個JavaBean對象
- session.get(javaBean.class, int id); 【傳入對應的class和id就能夠查詢】
- session.load(javaBean.class, int id); 【支持懶加載】
User重寫toString()來看一下效果:
User user1 = (User) session.get(User.class, 1);
System.out.println(user1);
HQL查詢
HQL:hibernate query language 即hibernate提供的面向對象的查詢語言
- 查詢的是對象以及對象的屬性【它查詢的是對象以及屬性,所以是區分大小寫的!】。
SQL:Struct query language 結構化查詢語言
- 查詢的是表以及列【不區分大小寫】
HQL是面向對象的查詢語言,能夠用來查詢所有的數據!
Query query = session.createQuery("FROM User");
List list = query.list();
System.out.println(list);
固然啦,它也能夠傳遞參數進去查詢
Query query = session.createQuery("FROM User WHERE id=?");
//這裏的?號是從0開始的,並不像JDBC從1開始的!
query.setParameter(0, user.getId());
List list = query.list();
System.out.println(list);
QBC查詢
QBC查詢: query by criteria 徹底面向對象的查詢
從上面的HQL查詢,咱們就能夠發現:HQL查詢是須要SQL的基礎的,由於仍是要寫少部分的SQL代碼....QBC查詢就是徹底的面向對象查詢...可是呢,咱們用得比較少
咱們來看一下怎麼使用吧:
//建立關於user對象的criteria對象
Criteria criteria = session.createCriteria(User.class);
//添加條件
criteria.add(Restrictions.eq("id", 1));
//查詢所有數據
List list = criteria.list();
System.out.println(list);
本地SQL查詢
有的時候,若是SQL是很是複雜的,咱們不能靠HQL查詢來實現功能的話,咱們就須要使用原生的SQL來進行復雜查詢了!
可是呢,它有一個缺陷:它是不能跨平臺的...所以咱們在主配置文件中已經配置了數據庫的「方言「了。
咱們來簡單使用一下把:
//將全部的記錄封裝成User對象存進List集合中
SQLQuery sqlQuery = session.createSQLQuery("SELECT * FROM user").addEntity(User.class);
List list = sqlQuery.list();
System.out.println(list);
beginTransaction方法
開啓事務,返回的是一個事務對象....Hibernate規定全部的數據庫操做都必須在事務環境下進行,不然報錯!
主配置文件
主配置文件主要配置:
- 數據庫的信息
- 其餘參數
- 加載映射文件
經常使用的配置信息均可以在hibernate-distribution-3.6.0.Final\project\etc\hibernate.properties
目錄下能夠找到..
數據庫信息
經常使用的配置信息均可以在hibernate.properties文件中找到,所以,咱們來搜索一下:
<!-- 1. 數據庫鏈接配置 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql:///hib_demo</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<!-- 數據庫方法配置, hibernate在運行的時候,會根據不一樣的方言生成符合當前數據庫語法的sql【大體能夠理解成:不一樣的版本對應的SQL不一樣】 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
其餘參數信息
經常使用的有那麼三個:
<!-- 2. 其餘相關配置 -->
<!-- 2.1 顯示hibernate在運行時候執行的sql語句 -->
<property name="hibernate.show_sql">true</property>
<!-- 2.2 格式化sql -->
<property name="hibernate.format_sql">true</property>
<!-- 2.3 自動建表 -->
<property name="hibernate.hbm2ddl.auto">update</property>
須要咱們注意的是自動建表,其中它有幾個參數:
- create-drop 每次在建立sessionFactory時候執行建立表。當調用sesisonFactory的close方法的時候,刪除表!
- create 每次都從新建表; 若是表已經存在就先刪除再建立
- update 若是表不存在就建立; 表存在就不建立;
- validate (生成環境時候) 執行驗證: 當映射文件的內容與數據庫表結構不同的時候就報錯!
加載映射文件
值得注意的是:mapping的屬性使用的是resource!
<!--3. 加載映射文件-->
<mapping resource="zhongfucheng/domain/User.hbm.xml"/>
加載映射文件其實咱們能夠在程序中加載,不必定在配置文件中配置....通常地,咱們在測試的時候通常使用程序的方式去加載映射文件【方便】
那麼怎麼在程序中加載映射文件呢?
在Configuration對象中提供了addClass()的方法。
通常地咱們的映射配置文件和JavaBean對象是放在同一個包下的。而且映射文件的命名是有規範的。所以Hibernate是能夠經過提供的JavaBean對象從而找到相對應的映射文件!
//獲取加載配置管理類
Configuration configuration = new Configuration();
//加載User的映射文件!
configuration.configure().addClass(User.class);
映射配置文件
映射文件: 映射一個實體類對象; 描述一個對象最終實現能夠直接保存對象數據到數據庫中
一般地,咱們都是一個JavaBean對象對應一個映射配置文件,而且配置文件和JavaBean對象是放在同一個目錄下的
咱們按照快速入門的映射配置文件一步一步來說解:
<!--在domain包下-->
<hibernate-mapping package="zhongfucheng.domain">
<!--類名爲User,表名也爲User-->
<class name="User" table="user">
<!--主鍵映射,屬性名爲id,列名也爲id-->
<id name="id" column="id">
<!--根據底層數據庫主鍵自動增加-->
<generator class="native"/>
</id>
<!--非主鍵映射,屬性和列名一一對應-->
<property name="username" column="username"/>
<property name="cellphone" column="cellphone"/>
<property name="password" column="password"/>
</class>
</hibernate-mapping>
hibernate-mapping
節點
經常使用的屬性:
- package【要映射的對象所在的包(可選,若是不指定,此文件全部的類都要指定全路徑)】
- auto-import
- 默認爲true, 在寫hql的時候自動導入包名
- 若是指定爲false, 再寫hql的時候必需要寫上類的全名;
class
節點
class 映射某一個對象的(通常狀況,一個對象寫一個映射文件,即一個class節點)
經常使用的屬性:
- name【指定要映射的對象的類型】
- table【指定對象對應的表】
- 若是沒有指定,默認與對象名稱同樣
property
節點
property是普通屬性的映射,即JavaBean普通的成員變量屬性就使用property來描述!
經常使用的屬性:
- name 指定對象的屬性名稱
- column 指定對象屬性對應的表的字段名稱
- 若是不寫默認與對象屬性一致。
- length 指定字符的長度, 默認爲255
- type 指定映射表的字段的類型,若是不指定會匹配屬性的類型
- java類型: 必須寫全名【例:java.lang.String】
- ** hibernate類型: 直接寫類型,都是小寫**
值得注意的是:若是列名稱爲數據庫關鍵字,須要用反引號或改列名。固然啦,咱們通常不使用關鍵字來做爲列名
id
節點
id是主鍵映射....
- name 指定對象的屬性名
- column 指定對象屬性對應的表的字段名稱
<id>
節點下還有子節點<generator class=""/>
主鍵的自動生成策略
- identity 自增加(mysql,db2)
- sequence 自增加(序列), oracle中自增加是以序列方法實現**
- native 自增加【會根據底層數據庫自增加的方式選擇identity或sequence】
- 若是是mysql數據庫, 採用的自增加方式是identity
- 若是是oracle數據庫, 使用sequence序列的方式實現自增加
- increment 自增加(會有併發訪問的問題,通常在服務器集羣環境使用會存在問題。)
指定主鍵生成策略爲手動指定主鍵的值
- assigned
指定主鍵生成策略爲UUID生成的值
- uuid
foreign(外鍵的方式, one-to-one講)
composite-id
主鍵通常分爲兩種:
- 單列主鍵
- 多列複合主鍵
單列主鍵就是上面那種,那麼若是要使用多列複合主鍵就須要使用<composite-id>
節點來配置了
- 如今我有這麼下面的一個對象,我想使用username和password做爲複合主鍵
public class User2 {
private String username;
private String password;
private String cellphone;
//各類setter和getter方法
}
- 將username和password抽取成一個類---->CompositeKey....必須實現Serializable接口
package zhongfucheng.domain;
/** * Created by ozc on 2017/5/6. */
public class CompositeKey implements Serializable{
private String username;
private String password;
public String getUsername() {
return username;
}
publicvoidsetUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
publicvoidsetPassword(String password) {
this.password = password;
}
}
- 在User2中須要指定一個變量來維護這個主鍵對象
package zhongfucheng.domain;
/** * Created by ozc on 2017/5/6. */
public class User2 {
//在User對象中維護這個主鍵對象
private CompositeKey key;
private String cellphone;
public CompositeKey getKey() {
return key;
}
publicvoidsetKey(CompositeKey key) {
this.key = key;
}
public String getCellphone() {
return cellphone;
}
publicvoidsetCellphone(String cellphone) {
this.cellphone = cellphone;
}
}
測試
publicstaticvoidmain(String[] args) {
//建立對象
User2 user2 = new User2();
CompositeKey compositeKey = new CompositeKey();
compositeKey.setUsername("123");
compositeKey.setPassword("123");
user2.setCellphone("111");
user2.setKey(compositeKey);
//獲取加載配置管理類
Configuration configuration = new Configuration();
//加載User的映射文件!
configuration.configure().addClass(User2.class);
//建立Session工廠對象
SessionFactory factory = configuration.buildSessionFactory();
//獲得Session對象
Session session = factory.openSession();
//使用Hibernate操做數據庫,都要開啓事務,獲得事務對象
Transaction transaction = session.getTransaction();
//開啓事務
transaction.begin();
//添加User2對象到數據庫
session.save(user2);
//提交事務
transaction.commit();
//關閉Session
session.close();
}
由於Hibernate在取得的時候是須要實現Serializable這個接口的對象的...所以compositeKey必須實現Serializable接口
Hibernate執行流程圖
若是文章有錯的地方歡迎指正,你們互相交流。習慣在微信看技術文章,想要獲取更多的Java資源的同窗,能夠關注微信公衆號:Java3y