HQL语句操作

1.实体类规范(javaBean)

1.提供无参构造方法
2.成员变量私有化 提供get/set方法
double 表示学分 0--100.0  没考试 0  
Double 有null值 缺考 用空值表示  0分
3.基本数据类型尽量使用包装类型(可以多表示一个值null 例如考试分数 缺考和0分)
4.实体中必须要提供一个与表中的主键对应的属性id
  hibernate是通过主键来区别对象是否相同
5.不要使用final修饰实体类(代理对象是要继承该类的)  

2.主键类型

1.自然主键
  输入人的时候  人的身份证号 保证了 非空不重复 符合主键的贴点
  但是身份证号  本身是业务字段 可以作为主键使用 叫做自然主键
2.代理主键(常用)
  找不到主键(没有业务字段符合主键规则)
  搞一个没有任何意义的主键id列 作为主键 就是为了非空不重复 叫做代理主键

3.主键生成策略.

1.identity:主键自增 由数据库来维护主键 录入的时候不需要指定主键
2.increment:主键自增 由hibernate来维护主键 每次插入前会先查询表中 id最大值 +1 作为新主键
效率不高 每次都要查询 如何10个人同时要保存 可能会出现线程问题
3.sequence:Oracle中的主键生成策略 序列
4.hilo:高低位算法(数据库中的主键自增算法原理) 由hibernate来维护主键 hibernate自己算一下(无意义)
5.native:hilo + sequence + identity 自动三选一 检测你是什么数据库
mysql就identity Oracle就sequence 如果没有就 用hilo
但是世界上没有一个 不支持自增和序列的数据库 其实就是 2选1

6.uuid:产生一个随机的字符串作为主键 主键类型必须为string类型
7.assigned:自然主键生成策略 (没策略) hibernate不会管理 由开发人员自己录入

4.HQL的三种状态

1.瞬时态 没有id 没有和session关联
2.持久态 有id 有关联
3.游离态 有id 没有关联
测试:save get 状态的改变
结论:就是将我们想要同步到数据库的数据 所对应的对象转换成持久态

5.事物的隔离级别

READ UNCOMMITTED  脏读                       1
READ COMMITTED    幻读                       2
REPEATABLE READ   可重复读                   4
SERIALIZABLE      串行化(只能一个一个访问)   8

2.设置隔离级别
<property name="hibernate.connection.isolation">4</property>

SQL语句设置
specify a JDBC isolation level hibernate.connection.isolation 1|2|4|8

6.获取当前session 与当前线程绑定的

<property name="hibernate.current_session_context_class">thread</property>

注意:
1.配置配置文件
2.调用getCurrentSession获取session 当事务提交 session会自动关闭 不需要手动关闭

7.HQL查询

查询所有对象
String HQL = "from User";  跟着的是类名 项目里 只有
按条件查询 HQL不会出现表中字段  id 代表的是属性名
String HQL = "from User where id = 1";
查询方法
Query query = session.createQuery(HQL);
返回结果(预见结果)
集合 list()
单个 uniqueResult()

问号?占位符
因为面向对象的查询 这里的id 指的是 实体类中的属性名 
String HQL = "from User where id = ? and username = ?";
Query query = session.createQuery(HQL); 
赋值参数的时候 参数1 占位符的索引  注意:HQL索引从0开始的
query.setParameter(0, 2);
query.setParameter(1, "www1");

冒号:占位符(注意冒号后面别来空格兄弟)
String HQL = "from User where id = :ww1 and username = :ww2";

分页查询
String HQL = "from User"; 
Query query = session.createQuery(HQL); 
limit ?,? 相同 起始 和 最大显示
query.setFirstResult(2);
query.setMaxResults(2);



Criteria无语句查询(单表查询)
Criteria criteria = session.createCriteria(User.class);
List<User> list = criteria.list();
需要预见结果 使用单对象返回
User user = (User) criteria.uniqueResult(); 
System.out.println(user);

添加查询条件
criteria.add(Restrictions.eq("id", 2));
User user = (User) criteria.uniqueResult();
System.out.println(user);

   HQL运算符                   QBC运算符                         含义
      =                    Restrictions.eq()                  等于
      >                    Restrictions.gt()                  大于
      >=                   Restrictions.ge()                  大于等于
      <                    Restrictions.lt()                  小于
      <=                   Restrictions.le()                  小于等于
      is null              Restrictions.isnull()              等于空值
      is not null          Restrictions.isNotNull()           非空值
      like                 Restrictions.like()                字符串模式匹配
      and                  Restrictions.and()                 逻辑与
      or                   Restrictions.or()                  逻辑或
      not                  Restrictions.not()                 逻辑非
      in(列表)              Restrictions.in()                  等于列表中的某一个值
      between x and y      Restrictions.between()             闭区间xy中的任意值


查询总行数
criteria.setProjection(Projections.rowCount());

原生sql查询(复杂的多表查询)
String sql = "select * from user where id=?";
SQLQuery query = session.createSQLQuery(sql);
query.setParameter(0, 3);
预见返回结果集
注意:返回数据的类型

1.创建User.hbm.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 让实体类 与 数据中的表建立起关系(字段与属性建立关系) -->
<!-- package可以添加包名 添加后底下可以省略包名 -->
<hibernate-mapping package="com.lanou3g">
  <!--  全类名 -->
  <class name="User" table="user">
  <!-- 设置主键关联 注意:表中必须有主键 -->
  <id name="id" column="id">
     <!-- 主键生成策略 -->
     <!-- 
                identity: 主键自增 由数据库维护 插入数据无id
                increment: 主键自增 但是由hibernate维护 先查询 最大id
                然后在这个最大id的基础上加1并插入数据时有id
                sequence:序列 
                hilo:高低位算法(hibernate会自己通过该算法 算出主键自增)
                native:(常用) hilo + identity + Sequence三选一 系统
                会检测你的数据库类型mysql 就是自增策略
                uuid: 全球范围内 不重复的值 是字符串
                注意:主键必须是字符串类型 是由hibernate 生成的uuid 插入到数据库中
                assigned: 是由程序员自己管理主键
            -->
     <generator class="native"></generator>
  </id>
  <!-- 配置非主键属性 -->
   <property name="username" column="username"></property>
   <property name="password" column="password"></property>
   <!-- 注意:写完映射文件后 需要 跟配置文件进行关联 -->
  </class>
</hibernate-mapping>

2.创建hibernate.cfg.xml文件

<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<!-- hibernate配置的跟标签 -->
<hibernate-configuration>
<!-- sessionfactory(会话工厂)相当于 数据库连接池 -->
    <session-factory>
    <!-- 加载数据库的驱动类 -->
       <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
       <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/a_hibernate</property>
       <property name="hibernate.connection.username">root</property>
       <property name="hibernate.connection.password">123456</property>
      <!--  hibernate方言 mysql方言 limit -->
      <!-- 配置使用哪个类 全类名-->
      <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
     <!--  在控制台输出SQL语句 -->
     <property name="hibernate.show_sql">true</property>
     <!-- 美化SQL语句 -->
     <property name="hibernate.format_sql">true</property>
    <!-- hibernate.hbm2ddl.auto是否自动生成表结构 -->
    <property name="hibernate.hbm2ddl.auto">update</property>
   <!--  
            1.脏读
            2.可重复读
            3.幻读
         READ UNCOMMITTED   未提交读  123              1
         READ COMMITTED     提交读    23               2
         REPEATABLE READ    可重复读   3                4 
         SERIALIZABLE       串行化(只能一个一个访问)        8

          specify a JDBC isolation level
          hibernate.connection.isolation 1|2|4|8
         隔离级别是用一个字节存储
         0001 1
         0010 2
         0100 4
         1000 8
   -->

    <property name="hibernate.connection.isolation">4</property>
    <!-- 使用getCurrentSession必须配置一下
         注意:当你使用getCurrentSession时不需要你手动关闭session 系统会帮那关闭
     -->
    <property name="hibernate.current_session_context_class">thread</property>
    <!-- 注意:映射实体类 全文件名从包名开始-->
    <mapping resource="com/lanou3g/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

3.创建实体类User

package com.lanou3g;
/*
 * 实体类
 * 需要创建实体类 对应的 映射文件
 * 名字规范(User.hbm.xml)
 * 1.与实体类名字相同
 * 2.与实体类在同一个包下
 * 3.xml文件
 */
public class User {

    private int id;
    private String username;
    private String password;
    public User() {
        super();
        // TODO Auto-generated constructor stub
    }
    public User(int id, String username, String password) {
        super();
        this.id = id;
        this.username = username;
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password=" + password + "]";
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

4.创建HibernateUtils.java类

package com.lanou3g;
/*
 * 实体类
 * 需要创建实体类 对应的 映射文件
 * 名字规范(User.hbm.xml)
 * 1.与实体类名字相同
 * 2.与实体类在同一个包下
 * 3.xml文件
 */
public class User {

    private int id;
    private String username;
    private String password;
    public User() {
        super();
        // TODO Auto-generated constructor stub
    }
    public User(int id, String username, String password) {
        super();
        this.id = id;
        this.username = username;
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password=" + password + "]";
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

6.创建测试类测试HQL语句

package com.lanou3g;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.jupiter.api.Test;

public class Demo01 {
/*
 * 测试主键策略 查看生产的SQL语句
 */
    @Test
    public void fun1() {
        //获取session
        Session session = HibernateUtils.getSession();
        //开启事物
        Transaction transaction = session.beginTransaction();
        //包裹语句
        User user = new User();
        user.setUsername("wanglong");
        user.setPassword("123");
        session.save(user);

        //提交事物
        transaction.commit();
        //关闭session
        session.close();
    }
    /*
     * hibernate中对象三种状态
     */
    @Test
    public void fun2() {
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //---------------------------
        User user = new User();//顺时态 没有id 没有和session关联
        user.setUsername("wanglong");
        user.setPassword("123");

        session.save(user);//持久态: 有id 有session关联

       //----------------------------
        transaction.commit();
        session.close();//游离态 有id 没关联
    }
    /*
     * 测hibernate中的缓存
     */
    @Test
    public void fun3() {
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //---------------------------
        User user1 = session.get(User.class, 1);
        User user2 = session.get(User.class, 1);
        User user3 = session.get(User.class, 1);
        User user4 = session.get(User.class, 1);
        User user5 = session.get(User.class, 1);
        //1.生成几条SQL语句
        //2.下面打印的结果
        //3.思考为什么
        System.out.println(user2==user2);
       //----------------------------
        transaction.commit();
        session.close();//游离态 有id 没关联
    }
    /*
     * 快照测试
     */
    @Test
    public void fun4() {
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //---------------------------

        User user = session.get(User.class, 1);
        user.setUsername("haha");//修改了缓存
        user.setUsername("dp");
        session.update(user);
       //----------------------------
        transaction.commit();
        session.close();//游离态 有id 没关联
    }
    /*
     * 瞬时态->游离态->持久态
     */
    @Test
    public void fun5() {
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //---------------------------
            User user = new User();//瞬时态 无id 无关联 session中的缓存无关联
            user.setId(1);//游离态 有id 无联系--//session中的缓存无关联

            //从数据库返回结果集是保存进缓存和快照中
            //update时 把这个要更新的对象放入缓存中(跟快照没有关系)
            session.update(user);//持久态 有id 有联系

            //get查询时 去缓存中去找 看有没有改id的对象
            User u = session.get(User.class, 1);

       //----------------------------
        //用处    提高效率
            //当事物提交的时候hibernate会比 快照和缓存中的对象是否同
            //不相同 会把缓存中的对象 同步到数据库
        transaction.commit();
        session.close();//游离态 有id 没关联
    }
}

package com.lanou3g;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.query.Query;
import org.junit.jupiter.api.Test;
public class Demo02 {
     /*
      * HQL查询
      */
    @Test
    public void fun1() {
        String hql = "from User";
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();

        Query query = session.createQuery(hql);
        List<User> list = query.list();
        //预见一个结果(单数据)
        //User user = (User)query.uniqueResult();
        System.out.println(list);

        transaction.commit();
        session.close();
    }
    @Test
    public void fun2() {

        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //---------------------------------
        String hql = "from User where id=?";
        Query query = session.createQuery(hql);
        query.setParameter(0, 5);
        User user = (User) query.uniqueResult();
        System.out.println(user);
        //-----------------------------------
        transaction.commit();
        session.close();
    }
    /*
     * 冒号占位符
     */
    @Test
    public void fun3() {

        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //---------------------------------
        //冒号后面相当于给这个冒号占位符起了个别名
        //注意:冒号后面不要搞空格
        String hql = "from User where id = :www";
        Query query = session.createQuery(hql);
        //直接使用别名给占位符赋值
        query.setParameter("www", 5);
        System.out.println(query.uniqueResult());
        //-----------------------------------
        transaction.commit();
        session.close();
    }
    /*
     * 分页
     */
    @Test
    public void fun4() {
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //---------------------------------
        String hql = "from User";
        Query query = session.createQuery(hql);
        //设置起始和最大显示
        query.setFirstResult(0);
        query.setMaxResults(3);
        List list = query.list();
        System.out.println(list);
        //-----------------------------------
        transaction.commit();
        session.close();
    }
    /*
     * 无语句查询
     */

    @Test
    public void fun5() {
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //---------------------------------
        Criteria criteria = session.createCriteria(User.class);
        List list = criteria.list();
        System.out.println(list);
        //-----------------------------------
        transaction.commit();
        session.close();
    }
    /*
     * 条件查询
     */
    @Test
    public void fun6() {
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //---------------------------------
        Criteria criteria = session.createCriteria(User.class);
        //添加一个查询条件
        criteria.add(Restrictions.eq("id", 3));
        User user = (User) criteria.uniqueResult();
        System.out.println(user);
        //-----------------------------------
        transaction.commit();
        session.close();
    }
    /*
     * 查询有多少记录数
     */
    @Test
    public void fun7() {
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //---------------------------------
        Criteria criteria = session.createCriteria(User.class);
        criteria.setProjection(Projections.rowCount());
        //一般返回值 是个数的通常都使用大Long来接受
        Long l = (Long) criteria.uniqueResult();
        System.out.println(l);
        //-----------------------------------
        transaction.commit();
        session.close();
    }
    /*
     * 原生SQL查询 注意:返回的结果与对象没有关系
     */

    @SuppressWarnings("deprecation")
    @Test
    public void fun8() {
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //---------------------------------
        String sql = "select * from user where id=?";
        Query query = session.createSQLQuery(sql);
        query.setParameter(0, 3);
        //一条记录就是一个object数组
        List list = query.list();
        System.out.println(list);

        //-----------------------------------
        transaction.commit();
        session.close();
    }

}