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);
}
*/