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

 package com.hibernate.day01.model;

 /**
  * Created by asus on 2017/6/1.
  */

 public class LoginUser {
     private Integer id;
     private String password;
     private String userName;
     private Integer age;
     private Integer salary;
     private String createTime;

     public Integer getSalary() {
         return salary;
     }

     public void setSalary(Integer salary) {
         this.salary = salary;
     }

     public String getCreateTime() {
         return createTime;
     }

     public void setCreateTime(String createTime) {
         this.createTime = createTime;
     }

     public Integer getAge() {
         return age;
     }

     public void setAge(Integer age) {
         this.age = age;
     }

     public Integer getId() {
         return id;
     }

     public void setId(Integer id) {
         this.id = id;
     }

     public String getPassword() {
         return password;
     }

     public void setPassword(String password) {
         this.password = password;
     }

     public String getUserName() {
         return userName;
     }

     public void setUserName(String userName) {
         this.userName = userName;
     }
 }

LoginUser

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

 <?xml version="1.0"?>
 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD3.0//EN"
         "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <!-- 映射文件 -->
 <!-- 在映射文件出现的name属性都是指的java的类名，属性名 -->
 <!-- 在映射文件出现的column属性都是指的数据库表的字段(列)名:也可以不写，使用name属性的值 -->
 <!-- 在映射文件出现的type属性是:1.java的全限定类名java.lang.Long 2.也可以是hibernate的类型名称long 3.也可以不写,hibernate会通过反射技术获取java的类型 -->
 <hibernate-mapping package="com.hibernate.day01.model">
     <!-- class表示一个由hibernate管理的持久对象,对应数据库的一个表 -->
     <!-- table数据库的表名 -->
     <class name="LoginUser" table="login_user">
         <!-- id元素（节点）是必须的，是代表表的主键 -->
     <id name="id" column="id">
         <!-- generator表示主键的生成方式,多数都是使用native -->
         <!-- native自动选择数据库本地的策略: -->
         <!-- mysql:AUTO_INCREMENT自增 --><!-- oracle:序列 -->
         <generator class="native" />
     </id>
         <!-- 非主键属性 -->
         <property name="userName" column="user_name" />
         <property name="password" column="password"/>
        <!-- &lt;!&ndash; default="25"还必须同时配置一个属性insert="false",表示不出现在insert语句 &ndash;&gt;
         <property name="age" insert="false">
             <column name="age" default="25" />
         </property>
         &lt;!&ndash; update=false:一经保存就不能修改属性:身份证号码,创建时间 &ndash;&gt;
         <property name="createTime" column="create_time" update="false"/>-->
     </class>
 </hibernate-mapping>

loginuser.hbm.xml

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

 <!DOCTYPE hibernate-configuration PUBLIC
         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
         "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

 <hibernate-configuration>
     <session-factory>
         <!-- Database connection settings
         -->
         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
         <property name="connection.url">jdbc:mysql://10.3.2.25:3306/hibernate</property>
         <property name="connection.username">root</property>
         <property name="connection.password">admin</property>
         <!-- JDBC connection pool (use the built -in) JDBC连接池（使用内置） -->
        <!-- <property name="connection.pool_size">1</property>-->
         <!-- SQL dialect  -->
         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
         <!-- Enable Hibernate's automatic session context management
         hibernate将session从当前线程中释放，并且关闭session
         -->
      <!--   <property name="current_session_context_class">thread</property>-->
         <!-- Disable the second-level cache -->
      <!--   <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>-->
         <!-- Echo all executed SQL to stdout  -->
         <property name="show_sql">true</property>
         <!-- Drop and re-create the database schema on startup-->
         <property name="hbm2ddl.auto">update</property>
         <mapping resource="mapper/loginuser.hbm.xml"/>
        <!-- <mapping class="com.hibernate.day01.model.LoginUser" />-->
     </session-factory>
 </hibernate-configuration>

hibernate.cfg.xml

　　　　4.编辑dao实现类

 package com.hibernate.day01.dao.impl;

 import com.hibernate.day01.dao.ILoginUserDao;
 import com.hibernate.day01.model.LoginUser;
 import org.hibernate.Query;
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.cfg.Configuration;

 import java.util.List;

 /**
  * Created by asus on 2017/6/1.
  */
 public class LoginUserDao implements ILoginUserDao {
     @Override
     public void save(LoginUser loginUser) {
         // 读取并且解析配置文件(包含映射文件)
         Configuration configuration = new Configuration();
         // 加载默认配置文件hibernate.cfg.xml
         // configuration.configure();
         // 加载非默认配置文件hibernate.cfg.xml
          configuration.configure("hibernate2.cfg.xml");
         // 生成会话工厂(真正解析配置文件)
         SessionFactory sessionFactory = configuration.buildSessionFactory();
         // 获取Session对象
         Session session = sessionFactory.openSession();
         // 开启事务
         // 用法1
         //Transaction transaction = session.getTransaction();
         // transaction.begin();
         // 用法2   hibernate默认情况下是没有开启事务的,必须手动开启事务
          session.beginTransaction();
         // 操作CUD
         session.save(loginUser);// 持久状态
         // 提交事务
         session.getTransaction().commit();
         // 关闭资源
         session.close();// 游离状态
         sessionFactory.close();
     }
     @Override
     public void delete(Integer id) {
         //创建读取文件的类
         Configuration configuration=new Configuration();
         //加载文件
         configuration.configure("hibernate2.cfg.xml");
         //获得sessionFactory对象
         SessionFactory sessionFactory = configuration.buildSessionFactory();
         //获得session
         Session session = sessionFactory.openSession();
         //开启事务
         session.beginTransaction();
         //执行操作
         LoginUser loginUser=new LoginUser();
         loginUser.setId(id);
         session.delete(loginUser);//删除状态
         //关闭事务
         session.getTransaction().commit();
         //关闭session
         session.close();
         //关闭sessionFactory
         sessionFactory.close();

     }

     @Override
     public void update(LoginUser loginUser) {
         //创建读取文件的类
         Configuration configuration=new Configuration();
         //加载文件
         configuration.configure("hibernate2.cfg.xml");
         //获得sessionFactory对象
         SessionFactory sessionFactory = configuration.buildSessionFactory();
         //获得session
         Session session = sessionFactory.openSession();
         //开启事务
         session.beginTransaction();
         //执行操作
         session.update(loginUser);
         //关闭事务
         session.getTransaction().commit();
         //关闭session
         session.close();
         //关闭sessionFactory
         sessionFactory.close();
     }

     @Override
     public LoginUser getLoginUser(Integer id) {
         //创建读取文件的类
         Configuration configuration=new Configuration();
         //加载文件
         configuration.configure("hibernate2.cfg.xml");
         //获得sessionFactory对象
         SessionFactory sessionFactory = configuration.buildSessionFactory();
         //获得session
         Session session = sessionFactory.openSession();
         //开启事务
       // session.beginTransaction();  查询操作不需要事务
         //执行操作
         LoginUser loginUser=(LoginUser) session.get(LoginUser.class,id);
         //关闭事务
        // session.getTransaction().commit();
         //关闭session
         session.close();
         //关闭sessionFactory
         sessionFactory.close();
         return loginUser;
     }

     @Override
     public List<LoginUser> getList() {
         //创建读取文件的类
         Configuration configuration=new Configuration();
         //加载文件
         configuration.configure("hibernate2.cfg.xml");
         //获得sessionFactory对象
         SessionFactory sessionFactory = configuration.buildSessionFactory();
         //获得session
         Session session = sessionFactory.openSession();
         //开启事务
         // session.beginTransaction();
         //执行操作
        String hql="select o from com.hibernate.day01.model.LoginUser o";
         Query query = session.createQuery(hql);
         List<LoginUser> list = query.list();
         //关闭事务
         // session.getTransaction().commit();
         //关闭session
         session.close();
         //关闭sessionFactory
         sessionFactory.close();
         return list;
     }

 }

LoginUserDao

　　　　5.测试

 import com.hibernate.day01.dao.impl.LoginUserDao;
 import com.hibernate.day01.dao.impl.ProductDao;
 import com.hibernate.day01.model.LoginUser;
 import com.hibernate.day01.model.Product;
 import org.junit.Test;

 import java.util.List;

 /**
  * Created by asus on 2017/6/1.
  */
 public class HibernateTest {
     @Test
     public void testSave(){
         LoginUserDao loginUserDao=new LoginUserDao();
         LoginUser loginUser=new LoginUser();
         loginUser.setUserName("tesg");
         loginUser.setPassword("47894");
         loginUser.setAge(58);
         loginUserDao.save(loginUser);
     }
     @Test
     public void testDelete(){
         LoginUserDao loginUserDao=new LoginUserDao();
         loginUserDao.delete(9);
     }
     @Test
     public void testUpdate(){
         LoginUserDao loginUserDao=new LoginUserDao();
         LoginUser loginUser=new LoginUser();
         loginUser.setId(10);
         loginUser.setUserName("已经改了2");
         loginUserDao.update(loginUser);
     }
     @Test
     public void testGet(){
         LoginUserDao loginUserDao=new LoginUserDao();
         LoginUser loginUser = loginUserDao.getLoginUser(10);
         System.out.println("--------loginUser-----"+loginUser);
     }
     @Test
     public void testList(){
         LoginUserDao loginUserDao=new LoginUserDao();
         List<LoginUser> list = loginUserDao.getList();
         System.out.println("---------list----"+list.size());
     }
 }

HibernateTest

hibernate简单实现CRUD完成