ssh架构之hibernate(一)简单使用hibernate完成CRUD

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完成