Hibernate框架的学习-第二天

Posted Vanguard

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Hibernate框架的学习-第二天相关的知识,希望对你有一定的参考价值。

一、 hibernate中的实体规则

   1.   实体类创建的注意事项

  1)  持久化类提供无参数构造

  2)  成员变量私有,提供共有get/set方法访问.需提供属性

  3)  持久化类中的属性,应尽量使用包装类型

  4)  持久化类需要提供oid.与数据库中的主键列对应

  5)  不要用final修饰class

  hibernate使用cglib代理生成代理对象.代理对象是继承被代理对象.如果被final修饰.将无法生成代理.

   2. 主键类型

  1)  自然主键(少见)

  表的业务列中,有某业务列符合,必须有,并且不重复的特征时,该列可以作为主键使用.

  2)  代理主键(常见)

  表的业务列中,没有某业务列符合,必须有,并且不重复的特征时,创建一个没有业务意义的列作为主键

   3.  主键生成策略

  1)  代理主键

  identity : 主键自增.由数据库来维护主键值.录入时不需要指定主键.

  sequence: Oracle中的主键生成策略.

  increment(了解): 主键自增.由hibernate来维护.每次插入前会先查询表中id最大值.+1作为新主键值.                   

  hilo(了解): 高低位算法.主键自增.由hibernate来维护.开发时不使用.

  native:hilo+sequence+identity 自动三选一策略.

  uuid: 产生随机字符串作为主键. 主键类型必须为string 类型.

  2)   自然主键

  assigned:自然主键生成策略. hibernate不会管理主键值.由开发人员自己录入.

二、 hibernate中的对象状态

  1.   对象分为三种状态

    1)  瞬时状态

    没有id,没有在session缓存中

  2)  持久化状态

    有id,在session缓存中

  3)  游离|托管状态

    有id,没有在session缓存中

  2.  三种状态的转换图

           

三、 hibernate进阶-一级缓存

  1.  缓存:提高效率.hibernate中的一级缓存也是为了提高操作数据库的效率.

  2.  提高效率手段1:提高查询效率

        

 

  3.  提高效率手段2:减少不必要的修改语句发送

        

 

四、 hibernate中的事务

  1.  事务

     1) 事务特性

     a 原子性

     c 一致性

     i 隔离性

     d 持久性

   2) 事务并发问题

    1.脏读

    2.不可重复度

    3.幻|虚读

      3) 事务的隔离级别

    1)  读未提交- 123

    2)  读已提交 - 23

    3)  可重复读(mysql默认级别)-3

    4)  串行化 - 没有问题

  2. 知识点:如何在hibernate中指定数据库的隔离级别

               

  3. 知识点2:在项目中如何管理事务

    1)  业务开始之前打开事务,业务执行之后提交事务. 执行过程中出现异常.回滚事务.

    2)   在dao层操作数据库需要用到session对象.在service控制事务也是使用session对象完成. 我们要确保dao层和service层使用的使用同一个session对象

          3)   在hibernate中,确保使用同一个session的问题,hibernate已经帮我们解决了. 我们开发人员只需要调用sf.getCurrentSession()方法即可获得与当前线程绑定的session对象

   4)  注意1: 调用getCurrentSession方法必须配合主配置中的一段配置

   

  5)  注意2:通过getCurrentSession方法获得的session对象.当事务提交时,session会自动关闭.不要手动调用close关闭.

  4. 案例中的代码实现:

        1)service层

 public class CustomerServiceImpl implements CustomerService {

    private CustomerDao customerDao = new CustomerDaoImpl();

    public void save(Customer c) {
        Session session =  HibernateUtils.getCurrentSession();
        //打开事务
        Transaction tx = session.beginTransaction();
        //调用Dao保存客户
        try {
            customerDao .save(c);
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        }
        //关闭事务
        tx.commit();
    }
}

         2)dao层

      

public class CustomerDaoImpl implements CustomerDao {

    public void save(Customer c) {
        //1 获得session
        Session session = HibernateUtils.getCurrentSession();
        //3 执行保存
        session.save(c);
    }
}

五、hibernate中的批量查询(概述)

  1.   HQL查询-hibernate Query Language(多表查询,但不复杂时使用)

     Hibernate独家查询语言,属于面向对象的查询语言

          1) 基本查询

   /**
     * 基本查询
     */
    @Test
    public void fun() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        //1>书写hql语句
        //String hql = "from com.java.domain.Customer";
        String hql = " from Customer "; //查询所有的Customer对象
        //2>根据hql语句创建查询对象
        Query query = session.createQuery(hql);
        //3>根据查询对象获得查询结果
        List<Customer> list = query.list(); //返回list结果
        //Object result = query.uniqueResult(); //接收唯一的查询结果
        System.out.println(list);
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }

   2)条件查询

    /**
     * 条件查询
     * HQL语句中,不出现与数据库相关的
     */
    @Test
    public void fun2() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        //1>书写hql语句
        //String hql = "from com.java.domain.Customer";
        String hql = " from Customer where cust_id=1l "; //查询所有的Customer对象
        //2>根据hql语句创建查询对象
        Query query = session.createQuery(hql);
        //3>根据查询对象获得查询结果
        Customer result = (Customer) query.uniqueResult(); //接收唯一的查询结果
        System.out.println(result);
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }
  /**
     * 条件查询
     * ?占位符
     */
    @Test
    public void fun3() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        //1>书写hql语句
        //String hql = "from com.java.domain.Customer";
        String hql = " from Customer where cust_id=? "; 
        //2>根据hql语句创建查询对象
        Query query = session.createQuery(hql);
        //设置参数
        //query.setLong(0, 2l);
        query.setParameter(0, 2l);
        //3>根据查询对象获得查询结果
        Customer result = (Customer) query.uniqueResult(); //接收唯一的查询结果
        System.out.println(result);
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }
   /**
     * 条件查询
     * 命名占位符
     */
    @Test
    public void fun4() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        //1>书写hql语句
        //String hql = "from com.java.domain.Customer";
        String hql = " from Customer where cust_id=:cust_id "; 
        //2>根据hql语句创建查询对象
        Query query = session.createQuery(hql);
        //设置参数
        query.setParameter("cust_id", 3l);
        //3>根据查询对象获得查询结果
        Customer c = (Customer) query.uniqueResult(); //接收唯一的查询结果
        System.out.println(c);
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }

  3)分页查询

   /**
     * 分页查询
     * limit ?,?
     * query.setFirstResult(2); 
     * query.setMaxResults(2);
     */
    @Test
    public void fun5() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        //1>书写hql语句
        //String hql = "from com.java.domain.Customer";
        String hql = " from Customer "; //查询所有的Customer对象
        //2>根据hql语句创建查询对象
        Query query = session.createQuery(hql);
        
        //设置分页信息 limit ?,?
        query.setFirstResult(2);
        query.setMaxResults(2);
        
        //3>根据查询对象获得查询结果
        List<Customer> list = query.list();
        System.out.println(list);
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }

  2.   Criteria查询(单表条件查询)

    Hibernate自创的无语句面向对象查询

   1)   基本查询

   /**
     * 基本查询
     */
    @Test
    public void fun1() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //查询所有的Customer对象
        Criteria criteria = session.createCriteria(Customer.class);
        List<Customer> list = criteria.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }

  2)条件查询      

  条件查询各个条件对应Criteria的函数API
   >             gt
   >=           ge
   <         lt
   <=       le
   ==       eq
   !=        ne
   in         in
   between and between
   in         in
   like          like
   is not null    isNotNull
   is null      isNull
   or        or
   and       and

  /**
     * 条件查询
     * >                 gt
     * >=                ge
     * <                 lt
     * <=                le
     * ==                eq
     * !=                ne
     * in                in
     * between and       between
     * in                in
     * like              like
     * is not null       isNotNull
     * is null           isNull
     * or                or
     * and               and
     *
     */
    @Test
    public void fun2() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //创建criteris对象
        Criteria criteria = session.createCriteria(Customer.class);
        //添加查询条件的参数  查询cust_id为1的Customer对象
        //criteria.add(Restrictions.eq("cust_id", 1l));
        //Customer c = (Customer) criteria.uniqueResult();
        //System.out.println(c);
        
        //查询cust_id在1和3之间的Customer对象
        criteria.add(Restrictions.between("cust_id", 1l, 3l));
        List<Customer> list = criteria.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }

  3)分页查询

  /**
     *分页查询
     *  limit ?,?
     *    criteria.setFirstResult(3);
     *    criteria.setMaxResults(3);
     */
    @Test
    public void fun3() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //创建criteris对象
        Criteria criteria = session.createCriteria(Customer.class);
        //分页查询 limit ?,?
        criteria.setFirstResult(3);
        criteria.setMaxResults(3);
        List<Customer> list = criteria.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }

  4)聚合函数

  /**
     * 聚合函数
     * criteria.setProjection(Projections.rowCount());
     *查询总记录数
     */
    @Test
    public void fun4() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //创建criteris对象
        Criteria criteria = session.createCriteria(Customer.class);
        //设置查询的聚合函数  总行数
        criteria.setProjection(Projections.rowCount());
        //执行查询
        Long count = (Long) criteria.uniqueResult();
        System.out.println(count);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }

  3.  原生SQL查询(复杂的业务查询)

    1)   基本查询

  /**
     * 基本查询
     */
    @Test
    public void fun1() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>. 书写sql语句
        String sql = "select * from cst_customer";
        //2>. 创建sql语句的查询对象
        SQLQuery query = session.createSQLQuery(sql);
        //3>. 执行查询操作
        List<Object[]> list = query.list();
        for(Object[] objs : list) {
            System.out.println(Arrays.toString(objs));
        }
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
  /**
     * 基本查询
     * 指定将结果封装到哪个对象中去
     * query.addEntity(Customer.class);
     */
    @Test
    public void fun2() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>. 书写sql语句
        String sql = "select * from cst_customer";
        //2>. 创建sql语句的查询对象
        SQLQuery query = session.createSQLQuery(sql);
        //指定将结果封装到哪个对象中去
        query.addEntity(Customer.class);
        //3>. 执行查询操作
        List<Customer> list = query.list();
        System.out.println(list);
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }

  2)条件查询

  /**
     * 条件查询
     */
    @Test
    public void fun3() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>. 书写sql语句
        String sql = "select * from cst_customer where cust_id=?";
        //2>. 创建sql语句的查询对象
        SQLQuery query = session.createSQLQuery(sql);
        //设置?占位符的参数
        query.setParameter(0, 5l);
        //指定将结果封装到哪个对象中去
        query.addEntity(Customer.class);
        
        //3>. 执行查询操作
        Customer c = (Customer) query.uniqueResult();
        System.out.println(c);
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }

  3)分页查询

  /**
     * 分页查询
     */
    @Test
    public void fun4() {
        //1. 获得session对象
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>. 书写sql语句
        String sql = "select * from cst_customer limit ?,?";
        //2>. 创建sql语句的查询对象
        SQLQuery query = session.createSQLQuery(sql);
        //设置?占位符的参数
        query.setParameter(0, 2);
        query.setParameter(1, 2);
        //指定将结果封装到哪个对象中去
        query.addEntity(Customer.class);
        
        //3>. 执行查询操作
        List<Customer> list = query.list();
        System.out.println(list);
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }

 

以上是关于Hibernate框架的学习-第二天的主要内容,如果未能解决你的问题,请参考以下文章

面试题:hibernate 第二天

Hibernate框架第三天

第二天-起步

Scrapy框架学习第二天

springboot学习:第二天

hibernate 第二天