hibernate的基本使用

public class Test {
   //基本的crud
  public static void main(String[] args) {
      Session session=HibernateUtil.getCurrentSession();//获得和当前线程绑定的session对象 无需关闭 线程结束 自动关闭
    
    Transaction tx=session.beginTransaction();//通过session对象得到事务对象
    
    //查询
    Customer c1=session.get(Customer.class,1l);//第一个参数 实体类的class对象,第二个主键值
    
    
    //将对象保存到数据库
//    Customer c2=new Customer();
//    c2.setCust_name("甘创");
//  long id=(long)session.save(c2);//会返回一个 Serializable接口,其实就是插入记录后的主键值 
    
    //修改的对象 必须有和表对应的主键 不然hibernate无法找到对应记录 会报错
//    Customer c3=new Customer();
//    c3.setCust_id(2l);
//    c3.setCust_name("甘创");
//    session.update(c3);
    
    //删除的对象 必须有和表对应的主键 不然hibernate无法找到对应记录 会报错
//    Customer c4=new Customer();
//    c4.setCust_id(3l);
//    session.delete(c4);
    
    
    
    tx.commit();//提交事物
      
}

}

Hibernate中hql查询方式

/**
 * hql的查询方式
 * */
public class Test3 {
    public static void main(String[] args) {
        Session session=HibernateUtil.getCurrentSession();
        Transaction tx=session.beginTransaction();
        
        //hql简单查询 注意 hql中不支持 直接使用*号 但在聚合函数中 比如 count(*) 可以
        /**
        List<Customer> list = session.createQuery("from Customer").list();
        */
        
        //hql别名查询   可以给表取别名 和sql语句语法相同 
        /**
         List<Customer> list = session.createQuery("select c from Customer c").list();
        */
        
        //排序查询    注意hql语法中 表名和列名都是类名和属性名
        /**
        List<Customer> list = session.createQuery("from Customer order by cust_id desc").list();
        */
        
        //条件查询   第一种 根据位置设置值 索引从0开始
        /**
        Query query = session.createQuery("from Customer where cust_name=? and cust_id=?");
        query.setParameter(0, "龙岩江");
        query.setParameter(1, 1l);
        List<Customer> list = query.list();
        */
        
        //条件查询  第二种  按名称绑定  :名字可以随便起 但中间不能有空格
        /**
        Query query = session.createQuery("from Customer where cust_name= :name and cust_id= :id ");
        query.setParameter("name", "龙岩江");
        query.setParameter("id",1l);
        List<Customer> list = query.list();
        */
        
        
        //hql的投影查询 :查询对象的某个或某些属性 
   
        /**    //查询单个属性 会返回一个object集合
        List<Object> list=session.createQuery("select cust_name from Customer").list();
        for (Object object : list) {
            System.out.println(object);
        }
        */
        
         //查询多个属性  会返回一个object[] 集合
     /**    List<Object[]> list = session.createQuery("select cust_name,cust_id from Customer").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
        */
        
        //想将查询的属性 直接封装成对应类的对象,会返回对应实体类的集合  语法 select new 实体类名(属性名,属性名) from 实体类名 
        //注意 如果要使用直接封装成对应对象  需要提供相应的构造方法,注意参数的位置
    /**    List<Customer> list = session.createQuery("select new Customer(cust_id,cust_name) from Customer").list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        */
        
        //hql分页查询
    /**    
        Query query = session.createQuery("from Customer");
        query.setFirstResult(1);//设置从第几条记录开始查  从0开始
        query.setMaxResults(2);//设置从起始位置开始 查几条记录 
        List<Customer> list = query.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        */
        
        //hql分组统计查询 
        //分组加条件查询      根据名字分组 然后查询名字为龙岩江
    /*    List<Object> list = session.createQuery("select cust_name FROM Customer  GROUP BY cust_name HAVING cust_name='龙岩江' ").list();
        for (Object cust_name : list) {
            System.out.println(cust_name);
        }
        */
        
        //hql多表查询   普通内连接和迫切内连接区别在于,普通返回object[]数组,迫切返回对应实体类的对象
        
        //普通的内连接查询语法: from 类名 别名 inner join 别名.属性名
        //返回值是一个object[] 里面存放着对应实体类的对象
    /**    List<Object[]> list = session.createQuery("from Customer c inner join c.linKMans").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
        */
        
        //迫切内连接  语法和普通内连接类似 多了一个fetch 关键字 , 语法:  from 类名 别名 inner join  fetch 别名.属性名
       //迫切内连接返回值是对应的 实体类对象 hibernate自动封装完成
        /**    List<Customer> list = session.createQuery("from Customer c inner join fetch c.linKMans ").list();
        for (Customer customer : list) {
            System.out.println(customer);
            for (LinKMan linKMan  : customer.getLinKMans()) {
                System.out.println(linKMan);
            }
        }
        */
        
        //还有对应有左外连接 和迫切左外连接 语法和内连接就区别于 inner join 替换为 left join 
        
        
        
        
        
        tx.commit();
    }

}

Hibernate中Criteria查询方式

public class Test4 {
    /**
     * Criteria 查询方式
     * 
     * */
    public static void main(String[] args) {
    Session session=HibernateUtil.getCurrentSession();
    Transaction tx=session.beginTransaction();
    
    
    //简单查询
 /**    Criteria criteria = session.createCriteria(Customer.class);
    List<Customer> list = criteria.list();
    for (Customer customer : list) {
        System.out.println(customer);
    }
    */
    
     //排序查询
    //criteria的addOrder()方法 传入Order类的静态方法 asc(属性名)升序 ,desc(属性名)降序
  /**    Criteria criteria = session.createCriteria(Customer.class);
    criteria.addOrder(Order.desc("cust_id"));
    List<Customer> list = criteria.list();
    for (Customer customer : list) {
        System.out.println(customer);
    }
    */
    
    //分页查询
 /**    Criteria criteria = session.createCriteria(Customer.class);
    criteria.setFirstResult(0); //指定从第几条记录开始查询
    criteria.setMaxResults(2); //指定查询几条记录
    List<Customer> list = criteria.list();
    for (Customer customer : list) {
        System.out.println(customer);
    }
    */
    
    //条件查询
//    Criteria criteria = session.createCriteria(Customer.class);
//    /**
//     *        设置条件
//     * sql运算符       Restrictions类静态方法名
//     * =             eq(String propertyName,Object value);参1 属性名 参2 值
//     * >             gt(String propertyName,Object value);参1 属性名 参2 值
//     * >=            ge(String propertyName,Object value);参1 属性名 参2 值
//     * <             lt(String propertyName,Object value);参1 属性名 参2 值
//     * <=            le(String propertyName,Object value);参1 属性名 参2 值
//     * <>            ne(String propertyName,Object value);参1 属性名 参2 值
//     * is null       isNull(String propertyName) 属性名
//     * like         like(String propertyName,Object value);参1 属性名 参2 值
//     * in           in (String propertyName,Collection values);参1 属性名 参2 可以是collection集合接口的实现类 或者object数组
//     * and          and 可变个数Restrictions.xx() 方法
//     * or           or  可变个数Restrictions.xx() 方法
//     * */
//    //多个条件之间  关系默认是and 
//    criteria.add(Restrictions.eq("cust_name", "龙岩江"));
//    criteria.add(Restrictions.gt("cust_id",0l));
//    //criteria.add(Restrictions.or(Restrictions.gt("cust_id",4l),Restrictions.eq("cust_name", "龙岩江")));
//    //or的写法  and的写法和这个一样 
//    List<Customer> list = criteria.list();
//    for (Customer customer : list) {
//        System.out.println(customer);
//    }
    
    
    //分组查询   
//    Criteria criteria = session.createCriteria(Customer.class);
//    /**
//     *Criteria的 add()    :普通条件  where 后面的条件
//     *Criteria的addOrder() :排序
//     *Criteria的setProjections() :聚合函数 和group by 和分组以后条件 having 
//     * */
//    //分组之后 默认返回都是一个object对象集合
//    criteria.setProjection(Projections.groupProperty("cust_name")); //根据名字分组
//    List list = criteria.list();
//    for (Object object : list) {
//        System.out.println(object);
//    }
    
    
        //离线条件查询
    // 在没有session对象时,可以 创建一个离线条件对象DetachedCriteria
    //使用DetachedCriteria对象 设置完对应的条件 ,可以通过getExecutableCriteria()方法 传入session对象
    //创建出criteria 对象 调用其list()方法 可以实现查询
    //主要用于在web层创建DetachedCriteria对象 设置完条件 传入dao层  根据session对象可以实现创建出criteria对象 实现查询
    //解决了 多个参数传递问题 , DetachedCriteria对象设置条件方式和Criteria对象一样
    DetachedCriteria dc=DetachedCriteria.forClass(Customer.class);
    dc.add(Restrictions.eq("cust_name", "龙岩江"));
    Criteria criteria = dc.getExecutableCriteria(session);
    List<Customer> list = criteria.list();
    for (Customer customer : list) {
        System.out.println(customer);
    }
    
    
    tx.commit();

    }

}

Hibernate中还支持sql语法的查询对象  不过不常用

 //SQLQuery对象默认查询是返回一个object[]数组 存放着值 可以设置让hibernate自动封装成指定类的对象
     //分页也和别的对象一样 设置setFirstResult()方法和setMaxResults()方法
    
     /**
     SQLQuery sqlQuery=session.createSQLQuery("select * from cst_Customer");
     sqlQuery.addEntity(Customer.class);//添加实体配置  hibernate将自动将查询返回的object[]数组封装成对应的对象 参1为持久化类的class对象
    List list= sqlQuery.list(); //查询返回一个list类型集合 
     for (Object obj : list) {
        Customer c=(Customer)obj;
        System.out.println(c);
    }
    */