ssh架構之hibernate(一)簡單使用hibernate完成CRUD

本文轉載自查看原文 2018-03-06 14:19 1677 大型運輸行業項目/ hibernate

1.Hibernate簡介

Hibernate是一個開放源代碼的對象關系映射(ORM)框架，它對JDBC進行了非常輕量級的對象封裝，它將POJO與數據庫表建立映射關系，是一個全自動的orm框架，hibernate可以自動生成SQL語句，自動執行，使得Java程序員可以隨心所欲的使用對象編程思維來操縱數據庫。
為什么要使用Hibernate
這個需要從Hibernate的起源開始分析。 Hibernate之父Gavin發現咱們以前的開發效率太低，特別在Java這種面向對象的語言在與關系型數據庫之間的數據交互太麻煩了。於是開發出了hibernate。我對他當時的思維的理解是，我們是Java程序員，就算我不懂SQL，我認為自己也應該可以來操作數據庫。
面試題：為什么要使用Hibernate?
首先簡單解釋一下hibernate是一個ORM的框架，底層依然使用JDBC。然后簡述一下它與JDBC之間的優缺點.

Hibernate的優缺點
優點與缺點都是相對的，那么講一個東西的優缺點我們都需要一個參數對比，而咱們要來進行對比的咱們操作數據的原生的JDBC：

JDBC的優缺點
本質:處理Java對象和關系型數據庫表之間的轉換
優點:
操作數據庫最底層,性能最高(需要你是有相應的經驗，並且是一個數據庫高手)
缺點:
1.使用復雜(重復代碼太多)
2.移植數據庫很麻煩,改動比較多       主鍵的生成方式不同(mysql使用自增，oracle使用序列)       分頁的sql語句也是不同(mysql使用limit，oracle使用ROWNUM)
3.性能優化得自己處理,沒有提供數據的緩存
4.面向sql語句操作，不是面向對象的

hibernate的優缺點
本質:處理Java對象和關系型數據庫表之間的轉換，只是對JDBC再次做了一層封裝
優點:
1.程序員操作很簡單，代碼簡單 session.save(user);
2.直接面向對象操作
3.提供世界級數據緩存(現在幾乎所有的ORM框架的緩存都是學的Hibernate)       一級緩存，二級緩存，查詢緩存
4.數據庫移植性很強，很少的修改       把各種數據庫抽取了一個方言接口       不同數據庫實現一個方言接口，如果換了數據庫，必須修改方言實現，驅動jar文   件，連接數據庫信息。
缺點:

1.不能干預sql語句的生成       session.get(User.class,id);       默認查詢t_user表的所有字段       自動生成select user0_.id,user0_.name,user0_.age from t_user user0_ where   user0_.id=?
2.一個項目中，如果對sql語句的優化要求比較高，不適合用hibernate(不過可以使用   Hibernate對原生sql的支持來解決)
3.如果一張表中有上億級別的數據量，也不適合用hibernate，其實也不適合用jdbc(可   以使用數據庫讀寫分離，分庫分表方案解決)

面試題：查詢1千萬條數據，怎么才是最快的？先把數據放到緩存(內存)中？
　　    1000千萬條數據分頁顯示1000條
　　執行SQL：查出1000條顯示
在查詢完之后，偷偷的查詢下一頁的數據，放到緩存中

Hibernate的歷史

Hibernate：之前EJB完成ORM是非常復雜的，Hibernate的作者是Gavin King。
　　PS：也許Cirrus Technologies的老板做夢也想不到兩年以后，這個小伙子開發出的那個產品會成為全世界最流行的O/R Mapping工具，而那個對SQL和數據庫一竅不通的小伙子居然會成為全世界J2EE數據庫解決方案的領導者。
01年末:hibernate的第一個版本
03 年6月,HIbernate2獲得Jolt 2004 大獎，9被JBoss收納為子項目
　　PS：2003年9月，Gavin King在他網站上向全世界發起挑戰：誰要是能對一段代碼用JDBC開發做到效率比hibernate高好多，就給他100美金
05 年3月,Hibernate3正式發布
10 年4月，3.5發布,支持JPA

2.hibernate入門

簡單使用hibernate做CRUD

            步驟
　　　　0.拷貝jar包
　　　　1.建立model
　　　　2.建立映射文件
　　　　3.建立hibernate核心配置文件
　　　　4.編輯dao實現類
　　　　5.測試
  　　　 0.拷貝jar包

　　　　1.建立model---LoginUser

 1 package com.hibernate.day01.model;
 2 
 3 /**
 4  * Created by asus on 2017/6/1.
 5  */
 6 
 7 public class LoginUser {
 8     private Integer id;
 9     private String password;
10     private String userName;
11     private Integer age;
12     private Integer salary;
13     private String createTime;
14 
15     public Integer getSalary() {
16         return salary;
17     }
18 
19     public void setSalary(Integer salary) {
20         this.salary = salary;
21     }
22 
23     public String getCreateTime() {
24         return createTime;
25     }
26 
27     public void setCreateTime(String createTime) {
28         this.createTime = createTime;
29     }
30 
31     public Integer getAge() {
32         return age;
33     }
34 
35     public void setAge(Integer age) {
36         this.age = age;
37     }
38 
39     public Integer getId() {
40         return id;
41     }
42 
43     public void setId(Integer id) {
44         this.id = id;
45     }
46 
47     public String getPassword() {
48         return password;
49     }
50 
51     public void setPassword(String password) {
52         this.password = password;
53     }
54 
55     public String getUserName() {
56         return userName;
57     }
58 
59     public void setUserName(String userName) {
60         this.userName = userName;
61     }
62 }

LoginUser

　　　　2.建立映射文件---loginuser.hbm.xml

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD3.0//EN"
 3         "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 4 <!-- 映射文件 -->
 5 <!-- 在映射文件出現的name屬性都是指的java的類名，屬性名 -->
 6 <!-- 在映射文件出現的column屬性都是指的數據庫表的字段(列)名:也可以不寫，使用name屬性的值 -->
 7 <!-- 在映射文件出現的type屬性是:1.java的全限定類名java.lang.Long 2.也可以是hibernate的類型名稱long 3.也可以不寫,hibernate會通過反射技術獲取java的類型 -->
 8 <hibernate-mapping package="com.hibernate.day01.model">
 9     <!-- class表示一個由hibernate管理的持久對象,對應數據庫的一個表 -->
10     <!-- table數據庫的表名 -->
11     <class name="LoginUser" table="login_user">
12         <!-- id元素（節點）是必須的，是代表表的主鍵 -->
13     <id name="id" column="id">
14         <!-- generator表示主鍵的生成方式,多數都是使用native -->
15         <!-- native自動選擇數據庫本地的策略: -->
16         <!-- mysql:AUTO_INCREMENT自增 --><!-- oracle:序列 -->
17         <generator class="native" />
18     </id>
19         <!-- 非主鍵屬性 -->
20         <property name="userName" column="user_name" />
21         <property name="password" column="password"/>
22        <!-- &lt;!&ndash; default="25"還必須同時配置一個屬性insert="false",表示不出現在insert語句 &ndash;&gt;
23         <property name="age" insert="false">
24             <column name="age" default="25" />
25         </property>
26         &lt;!&ndash; update=false:一經保存就不能修改屬性:身份證號碼,創建時間 &ndash;&gt;
27         <property name="createTime" column="create_time" update="false"/>-->
28     </class>
29 </hibernate-mapping>

loginuser.hbm.xml

　　　　3.建立hibernate核心配置文件---hibernate2.cfg.xml

 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         <!-- Database connection settings
 8         -->
 9         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
10         <property name="connection.url">jdbc:mysql://10.3.2.25:3306/hibernate</property>
11         <property name="connection.username">root</property>
12         <property name="connection.password">admin</property>
13         <!-- JDBC connection pool (use the built -in) JDBC連接池（使用內置） -->
14        <!-- <property name="connection.pool_size">1</property>-->
15         <!-- SQL dialect  -->
16         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
17         <!-- Enable Hibernate's automatic session context management
18         hibernate將session從當前線程中釋放，並且關閉session
19         -->
20      <!--   <property name="current_session_context_class">thread</property>-->
21         <!-- Disable the second-level cache -->
22      <!--   <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>-->
23         <!-- Echo all executed SQL to stdout  -->
24         <property name="show_sql">true</property>
25         <!-- Drop and re-create the database schema on startup-->
26         <property name="hbm2ddl.auto">update</property>
27         <mapping resource="mapper/loginuser.hbm.xml"/>
28        <!-- <mapping class="com.hibernate.day01.model.LoginUser" />-->
29     </session-factory>
30 </hibernate-configuration>

hibernate.cfg.xml

　　　　4.編輯dao實現類

  1 package com.hibernate.day01.dao.impl;
  2 
  3 import com.hibernate.day01.dao.ILoginUserDao;
  4 import com.hibernate.day01.model.LoginUser;
  5 import org.hibernate.Query;
  6 import org.hibernate.Session;
  7 import org.hibernate.SessionFactory;
  8 import org.hibernate.cfg.Configuration;
  9 
 10 import java.util.List;
 11 
 12 /**
 13  * Created by asus on 2017/6/1.
 14  */
 15 public class LoginUserDao implements ILoginUserDao {
 16     @Override
 17     public void save(LoginUser loginUser) {
 18         // 讀取並且解析配置文件(包含映射文件)
 19         Configuration configuration = new Configuration();
 20         // 加載默認配置文件hibernate.cfg.xml
 21         // configuration.configure();
 22         // 加載非默認配置文件hibernate.cfg.xml
 23          configuration.configure("hibernate2.cfg.xml");
 24         // 生成會話工廠(真正解析配置文件)
 25         SessionFactory sessionFactory = configuration.buildSessionFactory();
 26         // 獲取Session對象
 27         Session session = sessionFactory.openSession();
 28         // 開啟事務
 29         // 用法1
 30         //Transaction transaction = session.getTransaction();
 31         // transaction.begin();
 32         // 用法2   hibernate默認情況下是沒有開啟事務的,必須手動開啟事務
 33          session.beginTransaction();
 34         // 操作CUD
 35         session.save(loginUser);// 持久狀態
 36         // 提交事務
 37         session.getTransaction().commit();
 38         // 關閉資源
 39         session.close();// 游離狀態
 40         sessionFactory.close();
 41     }
 42     @Override
 43     public void delete(Integer id) {
 44         //創建讀取文件的類
 45         Configuration configuration=new Configuration();
 46         //加載文件
 47         configuration.configure("hibernate2.cfg.xml");
 48         //獲得sessionFactory對象
 49         SessionFactory sessionFactory = configuration.buildSessionFactory();
 50         //獲得session
 51         Session session = sessionFactory.openSession();
 52         //開啟事務
 53         session.beginTransaction();
 54         //執行操作
 55         LoginUser loginUser=new LoginUser();
 56         loginUser.setId(id);
 57         session.delete(loginUser);//刪除狀態
 58         //關閉事務
 59         session.getTransaction().commit();
 60         //關閉session
 61         session.close();
 62         //關閉sessionFactory
 63         sessionFactory.close();
 64 
 65     }
 66 
 67     @Override
 68     public void update(LoginUser loginUser) {
 69         //創建讀取文件的類
 70         Configuration configuration=new Configuration();
 71         //加載文件
 72         configuration.configure("hibernate2.cfg.xml");
 73         //獲得sessionFactory對象
 74         SessionFactory sessionFactory = configuration.buildSessionFactory();
 75         //獲得session
 76         Session session = sessionFactory.openSession();
 77         //開啟事務
 78         session.beginTransaction();
 79         //執行操作
 80         session.update(loginUser);
 81         //關閉事務
 82         session.getTransaction().commit();
 83         //關閉session
 84         session.close();
 85         //關閉sessionFactory
 86         sessionFactory.close();
 87     }
 88 
 89     @Override
 90     public LoginUser getLoginUser(Integer id) {
 91         //創建讀取文件的類
 92         Configuration configuration=new Configuration();
 93         //加載文件
 94         configuration.configure("hibernate2.cfg.xml");
 95         //獲得sessionFactory對象
 96         SessionFactory sessionFactory = configuration.buildSessionFactory();
 97         //獲得session
 98         Session session = sessionFactory.openSession();
 99         //開啟事務
100       // session.beginTransaction();  查詢操作不需要事務
101         //執行操作
102         LoginUser loginUser=(LoginUser) session.get(LoginUser.class,id);
103         //關閉事務
104        // session.getTransaction().commit();
105         //關閉session
106         session.close();
107         //關閉sessionFactory
108         sessionFactory.close();
109         return loginUser;
110     }
111 
112     @Override
113     public List<LoginUser> getList() {
114         //創建讀取文件的類
115         Configuration configuration=new Configuration();
116         //加載文件
117         configuration.configure("hibernate2.cfg.xml");
118         //獲得sessionFactory對象
119         SessionFactory sessionFactory = configuration.buildSessionFactory();
120         //獲得session
121         Session session = sessionFactory.openSession();
122         //開啟事務
123         // session.beginTransaction();
124         //執行操作
125        String hql="select o from com.hibernate.day01.model.LoginUser o";
126         Query query = session.createQuery(hql);
127         List<LoginUser> list = query.list();
128         //關閉事務
129         // session.getTransaction().commit();
130         //關閉session
131         session.close();
132         //關閉sessionFactory
133         sessionFactory.close();
134         return list;
135     }
136 
137 }

LoginUserDao

　　　　5.測試

 1 import com.hibernate.day01.dao.impl.LoginUserDao;
 2 import com.hibernate.day01.dao.impl.ProductDao;
 3 import com.hibernate.day01.model.LoginUser;
 4 import com.hibernate.day01.model.Product;
 5 import org.junit.Test;
 6 
 7 import java.util.List;
 8 
 9 /**
10  * Created by asus on 2017/6/1.
11  */
12 public class HibernateTest {
13     @Test
14     public void testSave(){
15         LoginUserDao loginUserDao=new LoginUserDao();
16         LoginUser loginUser=new LoginUser();
17         loginUser.setUserName("tesg");
18         loginUser.setPassword("47894");
19         loginUser.setAge(58);
20         loginUserDao.save(loginUser);
21     }
22     @Test
23     public void testDelete(){
24         LoginUserDao loginUserDao=new LoginUserDao();
25         loginUserDao.delete(9);
26     }
27     @Test
28     public void testUpdate(){
29         LoginUserDao loginUserDao=new LoginUserDao();
30         LoginUser loginUser=new LoginUser();
31         loginUser.setId(10);
32         loginUser.setUserName("已經改了2");
33         loginUserDao.update(loginUser);
34     }
35     @Test
36     public void testGet(){
37         LoginUserDao loginUserDao=new LoginUserDao();
38         LoginUser loginUser = loginUserDao.getLoginUser(10);
39         System.out.println("--------loginUser-----"+loginUser);
40     }
41     @Test
42     public void testList(){
43         LoginUserDao loginUserDao=new LoginUserDao();
44         List<LoginUser> list = loginUserDao.getList();
45         System.out.println("---------list----"+list.size());
46     }
47 }

HibernateTest

hibernate簡單實現CRUD完成

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 SpringBoot + Maven + Hibernate ( 簡單實現CRUD功能 ) Hibernate基本CRUD SpringMVC 使用 RESTful 架構實現 CRUD 操作【SSH】——Hibernate實現簡單的自動建表 Hibernate Validator簡單使用 Hibernate 系列 03 - 使用Hibernate完成持久化操作 Mongodb系列- java客戶端簡單使用(CRUD) Servlet實現簡單CRUD SSM + VUE 實現簡單的 CRUD SSH之Hibernate總結篇