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;
    }
}

　　　　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>

　　　　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>

　　　　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;
    }

}

　　　　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());
    }
}

hibernate简单实现CRUD完成