hibernate初步

package cn.bdqn.test;

import java.io.Serializable;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import cn.bdqn.bean.Student;
import cn.bdqn.util.HibernateSessionFactory;

public class HibernateTest {

    // 新增一个学生信息
    @Test
    public void addStudent() {
        // 获取配置文件 hibernate.cfg.xml
        Configuration configuration = new Configuration().configure();
        // 创建咱们的sessionFactory
        SessionFactory factory = configuration.buildSessionFactory();
        // 打开session
        Session session = factory.openSession();
        // 开启事务
        Transaction transaction = session.beginTransaction();
        /*
         * 开始新增操作 创建一个学生对象
         */
        for (int i = 4; i < 15; i++) {
            Student stu = new Student(i, "强"+i, "坚强"+i);
            // 保存学生信息到数据库
            session.save(stu);
        }
        // 提交事务
        transaction.commit();
        // 关闭session
        session.close();
    }

    // 查询指定学生信息 get()立即加载 把所需要的对象 session load()延迟加载 hibernate默认的 使用的使用
    @Test
    public void findStudent() {
        /*
         * get()和load()方法:从数据库中取得持久化对象(已经记载在怎们的session缓存中)!
         * student就是一个持久化对象(持久态) session.close(); student就变成了游离态!
         *
         *
         * 01.get(): hibernate回去确认ID(主键标识符)在数据库中是否存在,首先会去session
         * 中查找,也就是一级缓存中去查找!如果没有,再去二级缓存中查找,如果再没有,就去 数据库中查询,仍然还没有找到,就返回一个NULL!
         *
         * 02.load(): hibernate就会认为咱们所查找的ID一定存在!首先会去session中查找,如果没有找到
         * ,hibernate会根据lazy属性的值是否使用延迟加载,如果是,就返回该代理对象,如果没有找到,
         * 再去二级缓存中查找,再去数据库,再没有,报ObjectNotFoundException;
         */

        // 获取配置文件 hibernate.cfg.xml
        Configuration configuration = new Configuration().configure();
        // 创建咱们的sessionFactory
        SessionFactory factory = configuration.buildSessionFactory();
        // 打开session
        Session session = factory.openSession();
        // 查询指定的学生
        /*
         * 如果load想实现象get() 必须在配置文件中加上 lazy="false"
         */
        Student student = (Student) session.load(Student.class, 4);
        // 输出学生信息
        System.out.println(student + "*********1");
        // 关闭session
        session.close();
    }

    // 修改学生信息
    @Test
    public void updateStudent() {
        /*
         * update(),saveOrUpdate以及merge()的区别
         *
         * 01.update() 直接更新数据库,只有一条SQL,无论数据库中存不存在数据
         *
         * 02.saveOrUpdate 001.数据库存在数据,先查询,后修改! 两条SQL 002.数据库不存在数据,先查询,后新增!
         * 两条SQL 03.merge 001.数据库存在数据,先查询,后修改! 两条SQL 002.数据库不存在数据,先查询,后新增! 两条SQL
         */

        /*
         * commit()方法执行之前默认进行Flush()清理缓存,Flush()清理缓存的时候会进行脏检查,之后把脏对象同步到数据库 脏对象:
         * 与之前session中存在的快照对比,发现对象的属性有变化,那么就是!!
         *
         * flush():只是进行清理缓存!!
         */

        // 读取配置文件
        Configuration configuration = new Configuration().configure();
        // 创建工厂
        SessionFactory factory = configuration.buildSessionFactory();
        // 打开session
        Session session = factory.openSession();
        // 开启事务
        Transaction transaction = session.beginTransaction();
        // 修改
        Student student = new Student(10, "光头强10", "李和强10");
        student.setName("管光头强");
        session.save(student);
        student.setName("管光头强2");
        // 事务的提交
        transaction.commit();
        // 关闭session
        session.close();
    }

    // 删除学生信息
    @Test
    public void deleteStudent() {
        // 读取配置文件
        Configuration configuration = new Configuration().configure();
        // 创建工厂
        SessionFactory factory = configuration.buildSessionFactory();
        // 打开session
        Session session = factory.openSession();
        // 开启事务
        Transaction transaction = session.beginTransaction();
        // 首先查询到要删除的对象
        Student student = (Student) session.load(Student.class, 6);
        // 删除
        session.delete(student);
        // 事务的提交
        transaction.commit();
        // 关闭session
        session.close();
    }

    // 使用list查询所有学生信息
    @Test
    public void testList() {
        // 获取session
        Session session = HibernateSessionFactory.getSession();
        // 编写HQL语句(from的是类)
        String hql = "from Student";
        // 创建Query
        Query query = session.createQuery(hql);
        // 使用list查询所有(只有一条查询语句)
        List list = query.list();
        // 遍历
        for (Object object : list) {
            System.out.println(object);
        }
    }

    // 使用iterate查询所有学生信息
    // 01.在没有缓存的情况下 执行N+1条sql语句 N代表数据 第一条只是查ID(主键标识符)
    @Test
    public void testIterate() {
        // 获取session
        Session session = HibernateSessionFactory.getSession();
        // 编写HQL语句(from的是类)
        String hql = "from Student";
        // 创建Query
        Query query = session.createQuery(hql);
        // 使用list查询所有
        Iterator list = query.iterate();
        // 遍历
        while (list.hasNext()) {
            Student object = (Student) list.next();
            System.out.println(object);
        }
    }

    // 使用iterate查询所有学生信息
    // 02.在有缓存的情况下 执行1条sql语句
    @Test
    public void testIterate2() {
        // 获取session
        Session session = HibernateSessionFactory.getSession();
        // 编写HQL语句(from的是类)
        String hql = "from Student";
        // 创建Query
        Query query = session.createQuery(hql);
        // 使用list查询所有
        List list2 = query.list();
        System.out.println("上面的sql是list查询的!!*************");
        // 清空缓存
        session.clear();
        Iterator list = query.iterate();
        // 遍历
        while (list.hasNext()) {
            Student object = (Student) list.next();
            System.out.println(object);
        }
    }

    // 按参数位置绑定
    @Test
    public void argTest1() {
        // 获取session shift +tab 前移
        Session session = HibernateSessionFactory.getSession();
        // 写HQL
        String hql = "from Student where id=?";
        // 创建query对象
        Query query = session.createQuery(hql);
        // 参数位置绑定
        // 01.setString()
        // query.setString(0, "1");
        // 02.setParameter
        query.setParameter(0, 2);
        // 执行查询
        Student stu = (Student) query.uniqueResult();
        System.out.println(stu);
        // 关闭session
        HibernateSessionFactory.closeSession();
    }

    // 按参数名称绑定
    @Test
    public void argTest2() {
        // 获取session shift +tab 前移
        Session session = HibernateSessionFactory.getSession();
        // 写HQL
        String hql = "from Student where name like :names";
        // 创建query对象
        Query query = session.createQuery(hql);
        // 参数名称绑定
        // 01.setString()
        // query.setString(0, "1");
        // 02.setParameter
        query.setParameter("names", "%强%");
        // 执行查询
        List list = query.list();
        for (Object object : list) {
            System.out.println(object);
        }
        // 关闭session
        HibernateSessionFactory.closeSession();
    }

    // 动态参数绑定
    @Test
    public void argTest3() {
        // 获取session shift +tab 前移
        Session session = HibernateSessionFactory.getSession();
        // 创建一个对象
        Student student = new Student();
        student.setName("%强%");
        // 编写HQL
        StringBuffer buffer = new StringBuffer("from Student s where 1=1 ");
        // 条件拼接
        if (student.getId() != null) {
            buffer.append(" and id=:id");
        }
        if (student.getName() != null) {
            buffer.append(" and name like :name");
        }
        if (student.getPassword() != null) {
            buffer.append(" and password=:password");
        }
        // 创建query对象
        Query query = session.createQuery(buffer.toString());
        // 通过setProperties()
        query.setProperties(student);
        List list = query.list();
        for (Object object : list) {
            System.out.println(object);
        }
        // 关闭session
        HibernateSessionFactory.closeSession();
    }

    // 投影查询 01.将每条查询结果封装成Object对象
    @Test
    public void ObjTest1() {
        // 获取session shift +tab 前移
        Session session = HibernateSessionFactory.getSession();
        // 写HQL
        String hql = "select name from Student";
        // 创建query对象
        Query query = session.createQuery(hql);
        // 查询
        List<Object> list = query.list();
        // 遍历
        for (Object object : list) {
            System.out.println(object);
        }
        // 关闭session
        HibernateSessionFactory.closeSession();
    }

    // 投影查询 02.将每条查询结果封装成Object数组
    @Test
    public void ObjTest2() {
        // 获取session shift +tab 前移
        Session session = HibernateSessionFactory.getSession();
        // 写HQL
        String hql = "select name,password from Student";
        // 创建query对象
        Query query = session.createQuery(hql);
        // 查询
        List<Object[]> list = query.list();
        // 遍历 [L 这是数组toString()的结果
        for (Object[] object : list) {
            System.out.print("name:" + object[0]);
            System.out.println("password:" + object[1]);
        }
        // 关闭session
        HibernateSessionFactory.closeSession();
    }

    // 投影查询 03.将每条查询结果通过构造函数封装成对象
    @Test
    public void ObjTest3() {
        // 获取session shift +tab 前移
        Session session = HibernateSessionFactory.getSession();
        // 写HQL,前提这个构造函数必须在Student类中存在
        String hql = "select new Student(name,password) from Student";
        // 创建query对象
        Query query = session.createQuery(hql);
        // 查询
        List<Student> list = query.list();
        // 遍历
        for (Student object : list) {
            System.out.println(object.getName());
        }
        // 关闭session
        HibernateSessionFactory.closeSession();
    }

    // 分页
    @Test
    public void pageList() {
        /*
         * pageIndex :当前页码
         * pageSize:  页大小(每页显示的数据)
         * totalCount:总记录数
         * totalPage: 总页数
         * 每页显示3条数据  按照id升序排列  查看第一页内容
         */
        // 获取session
        Session session = HibernateSessionFactory.getSession();
        //写一个hql排序
        String hql="from Student order by id";
        //创建query对象
        Query query = session.createQuery(hql);
        //查询总记录数
        String hqlCounts="select count(*) from Student";
        //执行
        int counts= ((Long)session.createQuery(hqlCounts).uniqueResult()).intValue();
        //页大小(每页显示的数据)
        int  pageSize=3;
        //求出总页数(总记录数%页大小==0)?(总记录数/页大小):(总记录数/页大小+1)
        int totalPage=(counts%pageSize==0)?(counts/pageSize):(counts/pageSize+1);
        //当前页
        Scanner scanner=new Scanner(System.in);
        System.out.println("亲:想看第几页?");
        int pageIndex=scanner.nextInt();
        //设置从第几页开始(当前页-1)*页大小
        query.setFirstResult((pageIndex-1)*pageSize);
        //设置每页显示多少条数据
        query.setMaxResults(pageSize);
        //查询
        List list = query.list();
        for (Object object : list) {
            System.out.println(object);
        }
    }

    @Test
    public  void test111(){
        int a=10;
        int b=10;
        Integer c=10;
        Integer d=10;
        //底层有ValueOf(int value) -128  127之间的数字 是不会重新创建一个integer对象的!
        Integer c1=128;
        Integer d1=128;
        System.out.println(a==b); //t
        System.out.println(a==c); //t
        System.out.println(c==d); //t
        System.out.println(c1==d1); //f
    }
}