hibernate的基础学习

工具类：

public class H3Util {

    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            //从类加载路径中读取hibernate.cfg.xml文件生成SessionFactory对象
            return new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

基础的增删改查：

public class TestHibernate {

    @Test
    public void add() {
        SessionFactory sessionFactory = H3Util.getSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        for (int i = 0; i < 20; i++) {
            session.save(new User(null, "test"+i, "123456", new Date(), 1, 1000.0f));
        }
        transaction.commit();
        session.close();
        System.out.println("成功");
    }
    
    @Test
    public void find() {
        SessionFactory sessionFactory = H3Util.getSessionFactory();
        Session session = sessionFactory.openSession();
        System.out.println("+++++++++");
        User user = (User)session.get(User.class, 1);
        System.out.println("======");
        System.out.println(user);
        session.close();
    }
    
    @Test
    public void del() {
        SessionFactory sessionFactory = H3Util.getSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        User user = (User)session.get(User.class, 2);
        session.delete(user);
        transaction.commit();
        session.close();
        System.out.println("成功"+user);
    }
    
    @Test
    public void update() {
        SessionFactory sessionFactory = H3Util.getSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        User user = (User)session.get(User.class, 1);
        user.setPassword("111111");
        session.update(user);
        transaction.commit();
        session.close();
        System.out.println("成功"+user);
    }
    
    @Test
    public void findList() {
        SessionFactory sessionFactory = H3Util.getSessionFactory();
        Session session = sessionFactory.openSession();
        String hql = "from User";
        Query query = session.createQuery(hql);
        @SuppressWarnings("unchecked")
        List<User> uList = query.list();
        for (User user : uList) {
            System.out.println(user);
        }
        session.close();
    }
    
}

测试hibernate的对象状态：

/**
 * @author nunu
 * 测试 hibernate 对象
 */
public class TestHibernateObject {

    /**
     * 共有三种状态： 
     *    1、瞬时对象：TO   直接new对象
     *       特点：
     *       1、不受hibernate管理（session管理）
     *       2、没有OID
     *    2、持久化对象：PO 
     *       特点：
     *       1、受hibernate管理（session管理）
     *       2、有OID
     *    3、离线（托管）对象：DO
     *       特点：
     *       1、曾经受过hibernate管理，现在不受管理的（session）
     *       2、有OID
     */
    @Test
    public void status(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        Transaction ts  = session.beginTransaction();
        //user --> TO
        User user = new User(null, "nnn", "1234568", new Date(), 0, 999.9f);
        session.save(user);
        ts.commit();
        //session.close();
        //user --> PO
        System.out.println(user);
        session.delete(user);
        //user --> DO
        System.out.println(user+"----");
    }
    
    
    /**
     * session 中数据发生更改，若事务提交，数据库中数据修改
     * 若事务不提交，session关闭时，不会修改数据库
     */
    @Test
    public void addUser() {
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        Transaction ts  = session.beginTransaction();
        /**
         * PO:持久化对象--数据库表中的记录同步的对象，只要该对象发生任何改变，session关闭时都会同步该对象的状态到数据库中的表记录上
        User user = (User) session.get(User.class, "4028810d57c20db20157c20db5920013");
        user.setUsername("wangwu");
        */
        
        //DO
        //User user = new User("4028408157c0f5920157c0f593e100001", "wangwu", "12312", new SimpleDateFormat("yyyy-MM-dd").parse("2016-10-14"), 1, 1000.0f);
        //user.setUsername("wangwu");
        
        //DO--PO :session  -->一定会发生sql语句
        //session.update(user);
        
        //PO
        User user = (User) session.get(User.class, "4028810d57c20db20157c20db5920013");
        
        //PO--TO
        session.delete(user);
        
        /**
         * 若不提交事务不会进行数据库修改
         */
        ts.commit();
        //session会拿session中的所有的持久化对象和
        session.close();
        
        System.out.println(user);
    }
}

hibernate的一级缓存：

/**
 * @author nunu
 * 一级缓存
 */
public class TestHibernateSession {

    /**
     * 查询结果会放入session中，从session中获取结果不需要查询语句
     */
    @Test
    public void sessionQuery() {
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        
        //默认所有查询，都会将结果存入到一级缓存（session）
        //HQL、QBC、原生SQL查找：每次都会发送新sql,不会去session中获取
        Query query = session.createQuery("from User where userId = '4028810d57c20db20157c20db58c000e'");
        User user = (User)query.uniqueResult();
        
        Query query1 = session.createQuery("from User where userId = 'ff80808157c72cbe0157c72cc1540000'");
        User user1 = (User)query1.uniqueResult();
        System.out.println("0"+user);
        System.out.println("1"+user1);
        User user2 = (User)session.get(User.class,"4028810d57c20db20157c20db58c000e");
        //user2的获取不会发出查询语句
        System.out.println("2"+user2);
        session.close();
    }
    
    
    /**
     * 不发出update方法，修改session中结果是，再次获取的该值是修改过的结果
     * 
     * 先去session缓存（一级缓存）查询看有没对应的对象
     * 如果没有就会立即（无论有没有使用到该对象）发生sql语句去数据库查找，
     * 查询到之后会将查询结果再存入到session缓存（一级缓存中）
     */
    @Test
    public void testSessionUpdate() {
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        User user = (User)session.get(User.class,"4028810d57c20db20157c20db5920013");
        
        user.setUsername("admin");
        
        //不会发送sql语句：
        //User user1 = (User)session.get(User.class,"4028810d57c20db20157c20db5920013");
        //System.out.println(user1);
        //获取到是最新的对象信息
        //System.out.println(user1.getUsername());
        
        session.close();
    }
    
    
    /** 
     * 懒加载
     * org.hibernate.LazyInitializationException: could not initialize proxy - no Session
     * 先去session缓存（一级缓存）查询看有没对应的对象
     * 如果没有,再看程序中有没有使用改对象到除OID之外的属性，如果只是使用了OID它不会发送任何sql语句
     * 但是如果使用除OID之外的属性，此时（使用之前）才会发送sql语句查询
     */
    @Test
    public void testLoad() {
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        User user1 = (User) session.load(User.class, "4028810d57c20db20157c20db5920013");
        User user2 = (User) session.load(User.class, "ff80808157c72cbe0157c72cc1540000");
        System.out.println("--------------");
        
        System.out.println(user1);
        System.out.println(user2);
        
        session.close();
        
        //发送：sql
        //System.out.println(user.getUsername());
        
        //System.out.println(user1.getUsername());
    }
}

hibernate的模糊查询、单条记录查询、分页查询、、等单表基本查询

public class TestQuery {
    @Test
    public void list() {
        SessionFactory sessionFactory = H3Util.getSessionFactory();
        Session session = sessionFactory.openSession();
        String hql = "from User";
        Query query = session.createQuery(hql);
        @SuppressWarnings("unchecked")
        List<User> uList = query.list();
        for (User user : uList) {
            System.out.println(user);
        }
        session.close();
    }
    
    /**
     * 模糊查询
     */
    @Test
    public void list1() {
        SessionFactory sessionFactory = H3Util.getSessionFactory();
        Session session = sessionFactory.openSession();
        String hql = "from User as u where u.username like :username";
        Query query = session.createQuery(hql);
        query.setString("username", "%test1%");
        @SuppressWarnings("unchecked")
        List<User> uList = query.list();
        for (User user : uList) {
            System.out.println(user);
        }
        session.close();
    }
    
    /**
     * 模糊查询
     */
    @Test
    public void list2() {
        SessionFactory sessionFactory = H3Util.getSessionFactory();
        Session session = sessionFactory.openSession();
        String hql = "from User as u where u.username like ?";
        Query query = session.createQuery(hql);
        query.setString(0, "%test1%");
        @SuppressWarnings("unchecked")
        List<User> uList = query.list();
        for (User user : uList) {
            System.out.println(user);
        }
        session.close();
    }
    
    /**
     * 单个记录查询
     */
    @Test
    public void uniqueResult() {
        SessionFactory sessionFactory = H3Util.getSessionFactory();
        Session session = sessionFactory.openSession();
        String hql = "from User where userId = '4028810d57c20db20157c20db58c000a'";
        Query query = session.createQuery(hql);
        User u = (User) query.uniqueResult();
        System.out.println(u);
        session.close();
    }
    //findUsername
    @Test
    public void findUsername() {
        SessionFactory sessionFactory = H3Util.getSessionFactory();
        Session session = sessionFactory.openSession();
        String hql = "select username from User";
        Query query = session.createQuery(hql);
        @SuppressWarnings("unchecked")
        List<String> names = query.list();
        for (String string : names) {
            System.out.println("==="+string);
        }
        session.close();
    }
    
    
    @Test//查询多个属性（投影）
    public void findUsernameAndId(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        
        //sql：select username,sex from t_user
        //String hql = "select sex,username from User where userId = '4028408157bbe02f0157bbe030820000' ";
        //Query query = session.createQuery(hql);
        
        //返回值至多有一个：多了就会报异常 org.hibernate.NonUniqueResultException: query did not return a unique result: 2
        /*Object[] obj = (Object[]) query.uniqueResult();
        
        System.out.println("sex"+obj[0]);
        System.out.println("username"+obj[1]);*/
        
        //将查询结果封装到对象中:提供大量的构造方法
        String hql = "select new User(userId,username) from User where userId = '4028810d57c20db20157c20db58b0005' ";
        Query query = session.createQuery(hql);
        User user = (User)query.uniqueResult();
        
        System.out.println(user);
    }
    
    /**
     * 分页查询
     */
    @Test
    public void findByPage() {
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        
        
        int currentPage = 2;
        int pageSize = 3;
        String hql = "from User";
        Query query = session.createQuery(hql);
        query.setFirstResult((currentPage-1)*pageSize);
        query.setMaxResults(pageSize);
        @SuppressWarnings("unchecked")
        List<User> uList = query.list();
        for (User user : uList) {
            System.out.println(user);
        }
        session.close();
    }
    
    
    @Test//固定条件查询：查询username = 李四
    public void findByUsername(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        String hql = "from User where username = '李四'";
        Query query = session.createQuery(hql);
        @SuppressWarnings("unchecked")
        List<User> list = query.list();
        for (User user : list) {
            System.out.println(user);
        }
    }
    @Test//可变参条件查询：查询username = 李四
    public void findByUsername1(){
        String username = "李四";
        int sex = 1;
        float salary = 10000.0f;
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        //String hql = "from User where  sex = ? and username = ? and salary = ?";
        //Query query = session.createQuery(hql);
        //为？设置具体数值
        //只能使用索引方式设置值：此形式参数传递索引，灵活度太差，不推荐使用
        //query.setString(0, username);    
        //query.setInteger(1, sex);
        //query.setFloat(2, salary);
        
        
        //使用:别名 占位符形式
        //使用属性名（占位符）方式设置值（推荐）：名称和：后面的一致
        String hql = "from User where  sex = :sex and username = :username and salary = :salary";
        Query query = session.createQuery(hql);
        query.setString("username", username);
        query.setInteger("sex", sex);
        //query.setFloat("salary", salary);
        query.setParameter("salary", salary);//如果不确定类型可以使用该方式，不推荐使用
        
        @SuppressWarnings("unchecked")
        List<User> list = query.list();
        for (User user : list) {
            System.out.println(user);
        }
    }
    
    @Test//统计记录个数
    public void findCount(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        String hql = "select count(*) from User";
        Query query = session.createQuery(hql);
        
        Long count = (Long) query.uniqueResult();
        System.out.println(count);
    }
    
    @Test//最小值
    public void findMin(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        //返回值：和字段类型一致
        String hql = "select min(salary) from User";
        Query query = session.createQuery(hql);
        
        Float min = (Float) query.uniqueResult();
        System.out.println(min);
    }
    
    @Test//求和
    public void findSum(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        //返回值：整形Long/小数Double
        String hql = "select sum(salary) from User";
        Query query = session.createQuery(hql);
        
        Double sum = (Double) query.uniqueResult();
        System.out.println(sum);
    }
    @Test//求平均值
    public void findAvg(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        //返回值：Double
        String hql = "select avg(salary) from User";
        Query query = session.createQuery(hql);
        
        Double avg = (Double) query.uniqueResult();
        System.out.println(avg);
    }
    
    @Test//求分组查找
    public void findGroup(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        String hql = "select sex, count(*) from User group by sex";
        Query query = session.createQuery(hql);
        @SuppressWarnings("unchecked")
        List<Object[]> list = query.list();
        for (int i=0;i<list.size();i++) {
            System.out.println(list.get(i)[0]+":"+list.get(i)[1]);
        }
    }
    @Test//求排序
    public void findOrder(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        String hql = "from User order by salary asc,sex asc";
        Query query = session.createQuery(hql);
        @SuppressWarnings("unchecked")
        List<User> list = query.list();
        for (User user : list) {
            System.out.println(user);
        }
    }
    @Test//求排序
    public void findOrder1(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        Query query = session.getNamedQuery("findOrder");
        @SuppressWarnings("unchecked")
        List<User> list = query.list();
        for (User user : list) {
            System.out.println(user);
        }
    }
}

hibernate的QBC：query by criteria

/**
 * @author nunu
 * QBC：query by criteria
 */
public class TestCriteria {

    /**
     * criteria 普通查询
     */
    @Test
    public void list(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        Criteria criteria = session.createCriteria(User.class);
        @SuppressWarnings("unchecked")
        List<User> uList = criteria.list();
        for (User user : uList) {
            System.out.println(user);
        }
    }
    
    /**
     * 查询用户名
     */
    @Test
    public void findUsername(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        //select username from User
        Criteria criteria = session.createCriteria(User.class);
        //准备投影（属性）
        Property prop = Property.forName("username");
        //设置投影（属性）
        criteria.setProjection(prop);
        
        @SuppressWarnings("unchecked")
        List<String> usernames = criteria.list();
        for (String name : usernames) {
            System.out.println(name);
        }
    }
    
    
    /**
     * 查询用户名和性别
     */
    @Test
    public void findUsernameSex(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        //select username from User
        Criteria criteria = session.createCriteria(User.class);
        //准备投影（属性）
        Property prop1 = Property.forName("username");
        Property prop2 = Property.forName("sex");
        
        //获取投影集合
        ProjectionList pList = Projections.projectionList();
        pList.add(prop1);
        pList.add(prop2);
        //设置投影（属性）
        criteria.setProjection(pList);
        
        @SuppressWarnings("unchecked")
        List<Object[]> usernames = criteria.list();
        for (int i = 0; i < usernames.size(); i++) {
            System.out.println(usernames.get(i)[0]+":"+usernames.get(i)[1]);;
        }
    }
    
    /**
     * 模糊查询
     */
    @Test
    public void findByName(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        //select username from User where username = :name
        Criteria criteria = session.createCriteria(User.class);
        //添加条件
        //criteria.add(Restrictions.eq("username", "李四"));
        criteria.add(Restrictions.like("username", "%test1%"));
        
        @SuppressWarnings("unchecked")
        List<User> list = criteria.list();
        for (User user : list) {
            System.out.println(user);
        }
    }
    @Test
    public void findGroup(){
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        //select username from User group by sex
        Criteria criteria = session.createCriteria(User.class);
        
        Projection p1 = Projections.groupProperty("sex");
        Projection p2 = Projections.rowCount();//count(*)
        
        ProjectionList pList = Projections.projectionList();
        pList.add(p1);
        pList.add(p2);
        //分组
        criteria.setProjection(pList);
        @SuppressWarnings("unchecked")
        List<Object[]> list = criteria.list();
        
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i)[0]+":"+list.get(i)[1]);
        }
    }
}

hibernate 中使用SQL语句查询

/**
 * @author nunu
 * hibernate 中使用SQL语句查询
 */
public class TestSQLQuery {

    @Test
    public void testList() {
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        String sql = "select * from t_user";
        SQLQuery sqlQuery = session.createSQLQuery(sql);
        @SuppressWarnings("unchecked")
        List<Object[]> uList = sqlQuery.list();
        for (Object[] user : uList) {
            for (int i = 0; i < user.length; i++) {
                System.out.println(user[i]);
            }
        }
    }
    
    
    @Test
    public void testList1() {
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        String sql = "select * from t_user";
        SQLQuery sqlQuery = session.createSQLQuery(sql);
        //告诉系统如何去封装对象
        sqlQuery.addEntity(User.class);
        @SuppressWarnings("unchecked")
        List<User> uList = sqlQuery.list();
        for (User user : uList) {
            System.out.println(user);
        }
    }
    
    /**
     * 指明对象
     */
    @Test
    public void testList2() {
        SessionFactory sf = H3Util.getSessionFactory();
        Session session = sf.openSession();
        String sql = "select u.* from t_user u";
        SQLQuery sqlQuery = session.createSQLQuery(sql);
        //告诉系统如何去封装对象
        sqlQuery.addEntity("u",User.class);
        @SuppressWarnings("unchecked")
        List<User> uList = sqlQuery.list();
        for (User user : uList) {
            System.out.println(user);
        }
    }
}