Hibernate框架基本学习(四)--查询方式和抓取策略

最新推荐文章于 2021-02-01 04:34:12 发布
最新推荐文章于 2021-02-01 04:34:12 发布
阅读量210 收藏
点赞数 1
分类专栏： Hibernate框架基本学习 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun_shine_szc/article/details/104334282
版权

Hibernate的查询方式

在Hibernate中提供了很多种查询方式，共提供了五种查询方式。

一、Hibernate的查询方式：OID查询

OID检索：Hibernate根据对象的OID(主键)进行检索

  1. 使用get方法
Customer customer = session.get(Customer.class,1l);
  1. 使用load方法
Customer customer = session.load(Customer.class,1l);

二、Hibernate的查询方式：对象导航检索

对象导航检索：Hibernate根据一个已经查询到的对象，获得其关联的对象的一种查询方式。

// 1
LinkMan linkMan = session.get(LinkMan.class,1l);
Customer customer = linkMan.getCustomer();

// 2
Customer customer = session.get(Customer.class,2l);
Set<LinkMan> linkMans = customer.getLinkMans();

三、Hibernate的查询方式：HQL检索

  HQL查询：Hibernate Query Language，Hibernate的查询语言，是一种面向对象的方式的查询语言，语法类似SQL。通过session.createQyery()接收一个HQL进行查询的方式。

1、初始化数据

	@Test
	/**
	 * 初始化数据
	 */
	public void demo1() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 创建一个客户
		Customer customer = new Customer();
		customer.setCust_name("李前");
		
		for (int i = 1; i <= 10; i++) {
			LinkMan linkMan = new LinkMan();
			linkMan.setLkm_name("乔伊"+i);
			linkMan.setCustomer(customer);
			
			customer.getLinkMans().add(linkMan);
			session.save(linkMan);
		} 
		session.save(customer);
	
		transaction.commit();
	}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2、HQL的简单查询

查询所有： from 实体类名称

	@Test
	//HQL简单查询 
	public void demoe2() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 简单查询
		Query query = session.createQuery("from Customer"); // from后面是类名，而不是表名。
		List<Customer> list = query.list();
		
		// sql中支持*号写法：select * from cst_customer;但是HQL中不支持*号写法。
		/*Query query = session.createQuery("select * from Customer");//报错
		List<Customer> list = query.list();*/
		
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}

注意：HQL语句中，from后面是类名，而不是表名。

3、HQL的别名查询

别名查询： from 实体类名称 别名
别名查询： select 别名 from 实体类名称 别名

	@Test 
	// HQL别名查询
	public void demoe3() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 别名查询
		/*Query query = session.createQuery("from Customer c");
		List<Customer> list = query.list();*/
		
		Query query = session.createQuery("select c from Customer c");
		List<Customer> list = query.list();
		
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}

4、HQL的排序查询

排序查询：from 实体类名称 order by 实体类属性名称 asc/desc

	@Test 
	// HQL排序查询
	public void demoe4() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 排序查询
		// 默认为升序
		//List<Customer> list = session.createQuery("from Customer order by cust_id").list();
		// 设置降序排序 升序用asc，降序用desc。
		List<Customer> list = session.createQuery("from Customer order by cust_id desc").list();
		
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}

5、HQL的条件查询

hql条件查询语句写法：

  • 按位置绑定:根据参数的位置进行绑定
  • from 实体类名称 where 实体类属性名称=? and实体类属性名称=?
  • from 实体类名称 where 实体类属性名称 like ?
  • 按名称绑定
    • 第一步：from 实体类名 where 实体类属性名称 = :aaa(随便起一个名字)
    • 第二步：query.setParameter(“aaa”, “条件”);
@Test 
	// HQL条件查询
	public void demoe5() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 条件查询
		// 1 按位置绑定:根据参数的位置进行绑定
		// 一个条件
		/*Query query = session.createQuery("from Customer where cust_name = ?");
		query.setParameter(0, "李末");*/
		
		// 多个条件
		/*Query query = session.createQuery("from Customer where cust_source=? and cust_name like ?");
		query.setParameter(0, "小广告");
		query.setParameter(1, "李%");
		List<Customer> list = query.list();*/
		
		// 2 按名称绑定
		Query query = session.createQuery("from Customer where cust_source = :aaa and cust_name like :bbb");
		// 设置参数：
		query.setParameter("aaa", "朋友推荐");
		query.setParameter("bbb", "李%");
		List<Customer> list = query.list();
		
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}
  • setParameter(int arg0, Object arg1):Query-Query方法的两个参数：
    此方法用于按位置绑定查询。
    • 第一个参数：int类型是 ? 位置，?位置是从0开始。
    • 第二个参数：具体的参数值。
  • setParameter(String arg0, Object arg1):Query-Query方法的两个参数：
    此方法用于按名称绑定查询。
    • 第一个参数：String类型是随便起的名字，比如aaa。
    • 第二个参数：具体的参数值。

6、HQL的投影查询

投影查询：查询对象的某个或某些属性。
投影查询hql语句写法：
（1）select 实体类属性名称1, 实体类属性名称2 from 实体类名称
（2）select 后面不能写 * ，不支持的

	@Test 
	// HQL投影查询
	public void demoe6() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 投影查询
		// 单个属性
		/*List<Object> list = session.createQuery("select c.cust_name from Customer c").list();
		for (Object object : list) {
			System.out.println(object);
		}*/
		
		// 多个属性
		/*List<Object[]> list = session.createQuery("select c.cust_name,c.cust_source from Customer c").list();
		for (Object[] objects : list) {
			System.out.println(Arrays.toString(objects));
		}*/
		
		// 想查询多个属性，同时封装倒对象中
		// 要封装的对象类中，需要有无参构造，以及涉及的要查询的属性有参构造。
		List<Customer> list = session.createQuery("select new Customer(cust_name,cust_source) from Customer").list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}

例：要查询cust_name和cust_source两个属性，需要在Customer实体类中加入无参构造和只包含这两个属性的有参构造。

	public Customer() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public Customer(String cust_name, String cust_source) {
		super();
		this.cust_name = cust_name;
		this.cust_source = cust_source;
	}

7、HQL的分页查询

  1. mysql实现分页
select * from t_customer Limit 0,3;
  1. 在hql中实现分页
    （1）在HQL操作中，在语句里面不能写limit，hibernate的Query对象封装两个方法实现分页操作
	@Test 
	// HQL分页查询
	public void demoe7() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 分页查询
		Query query = session.createQuery("from LinkMan");
		query.setFirstResult(10);
		query.setMaxResults(10);
		List<LinkMan> list = query.list();
		
		for (LinkMan linkMan : list) {
			System.out.println(linkMan);
		}
		
		transaction.commit();
	}

8、HQL的分组统计查询

  1. 常用的聚集函数
    count、sum、avg、max、min

  2. hql聚集函数语句写法
    （1）查询表记录数
    select count(*) from 实体类名称

	@Test 
	// HQL分组统计查询
	public void demoe8() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 聚合函数的使用：count(),max(),min(),avg(),sum()
		Object object = session.createQuery("select count(*) from Customer").uniqueResult();
		System.out.println(object);
		// 分组统计
		List<Object[]> list = session.createQuery("select cust_source,count(*) from Customer group by cust_source having count(*)>=2").list();
		for (Object[] objects : list) {
			System.out.println(Arrays.toString(objects));
		}
		transaction.commit();
	}
  1. 报错处理
// 聚合函数的使用：count(),max(),min(),avg(),sum()
		Object object = session.createQuery("select count(*) from Customer").uniqueResult();
		int count = (int) object;
		System.out.println(count);

在这里插入图片描述
解决方法1：

		Object object = session.createQuery("select count(*) from Customer").uniqueResult();
		// 解决1
		Long lobj = (Long) object;
		int count = lobj.intValue();
		System.out.println(count);

解决方法2：

		Object object = session.createQuery("select count(*) from Customer").uniqueResult();
		System.out.println(object);

HQL的多表查询

SQL的多表查询
1、连接查询
  1. 交叉连接：笛卡尔积
SELECT * FROM A,B;
  • 内连接：inner join(inner可省略），两表的交集
    • 隐式内连接
    • 显示内连接
// 隐式内连接
SELECT * FROM A,B WHERE A.id = B.aid;
// 显示内连接
SELECT * FROM A INNER JOIN B ON A.id = B.aid;
  • 外连接
    • 左外连接：letf outer join(outer可省略)
    • 右外连接：right outer join(outer可省略)
// 左外连接
SELECT * FROM A LEFT OUTER JOIN B ON A.id = B.aid;
//右外连接
SELECT * FROM A RIGHT OUTER JOIN B ON A.id = B.aid;
  1. 子查询
HQL的多表查询
  1. 连接查询
    • 交叉连接
    • 内连接
      • 显示内连接
      • 隐式内连接
      • 迫切内连接
    • 外连接
      • 左外连接
      • 右外连接
      • 迫切左外连接
	@Test 
	// HQL多表查询
	public void demoe9 () {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 多表查询SELECT * FROM cst_customer c INNER JOIN cst_linkman l ON c.`cust_id` = l.`lkm_cust_id`;
		// HQL内连接：from Customer c inner join c.linkMans
	/*	List<Object[]> list = session.createQuery("from Customer c inner join c.linkMans").list();
		for (Object[] objects : list) {
			System.out.println(Arrays.toString(objects));
		}*/
		
		//HQL迫切内连接：其实就是在普通内连接inner join后添加一个关键字fetch。
		// from Customer c inner join fetch c.linkMans
		// fetch的作用：通中Hibernate，将另一个对象的数据封装倒=到该对象中。
		List<Customer> list = session.createQuery("select distinct c from Customer c inner join fetch c.linkMans").list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}

内连接和迫切内连接的区别(简单理解)：内连接是封装为Objecr数组了，迫切内连接是封装到一个对象里边去了。

四、Hibernate的查询方式：QBC检索

QBC查询：Query By Criteria，条件查询。是一种更加面向对象的查询方式。

1、简单查询

查询所有：

  1. 创建Criteria对象
  2. 调用方法得到结果
	@Test
	// 简单查询
	public void demo1() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 获得Criteria的对象
		Criteria criteria = session.createCriteria(Customer.class);
		List<Customer> list = criteria.list();
		
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}

2、排序查询

调用方法：

  1. asc(String propertyName):Order-Order
  2. desc(String propertyName):Order-Order
	@Test
	// 排序查询
	public void demo2() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 排序查询
		Criteria criteria = session.createCriteria(Customer.class);
		//criteria.addOrder(Order.asc("cust_id"));//升序
		criteria.addOrder(Order.desc("cust_id"));//降序
		List<Customer> list = criteria.list();
		
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}

3、分页查询

开始位置计算公式： （当前页-1）*每页记录数

	@Test
	// 分页查询
	public void demo3() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 分页查询
		Criteria criteria = session.createCriteria(LinkMan.class);
		criteria.setFirstResult(10);
		criteria.setMaxResults(10);
		List<LinkMan> list = criteria.list();
		for (LinkMan linkMan : list) {
			System.out.println(linkMan);
		}
		
		transaction.commit();
	}

4、条件查询

没有语句，使用封装的方法实现

	@Test
	// 条件查询
	public void demo4() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 条件查询
		Criteria criteria = session.createCriteria(Customer.class);
		// 设置条件：
		/**
		 * = eq
		 * > gt
		 * >= ge
		 * < lt
		 * <= le
		 * <> ne 不等于
		 * like
		 * in
		 * and
		 * or
		 */
		//criteria.add(Restrictions.eq("cust_source", "小广告"));
		//criteria.add(Restrictions.like("cust_name", "李%"));
		criteria.add(Restrictions.or(Restrictions.like("cust_name", "刘%"),Restrictions.like("cust_name", "邓%")));
		List<Customer> list = criteria.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}

5、统计查询

	@Test
	// 统计查询
	public void demo5() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		// 统计查询
		Criteria criteria = session.createCriteria(Customer.class);
		/**
		 * add:普通条件，where后面条件
		 * addOrder:排序
		 * setProjection：聚合函数 和 group by、having
		 */
		criteria.setProjection(Projections.rowCount());
		Long count = (Long) criteria.uniqueResult();
		System.out.println(count);
		
		transaction.commit();
	}

6、离线条件查询(SSH)-DetachedCriteria

	@Test
	// 离线条件查询
	public void demo6() {
		DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
		detachedCriteria.add(Restrictions.like("cust_name", "李%"));
		
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		Criteria criteria = detachedCriteria.getExecutableCriteria(session);
		List<Customer> list = criteria.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}

在这里插入图片描述

五、Hibernate的查询方式：SQL检索

1、SQL查询

SQL查询：通过使用sql语句进行查询

	@Test
	public void demo1() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		/*SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer");
		// 将查询结果封装到数组里边
		List<Object[]> list = sqlQuery.list();
		for (Object[] objects : list) {
			System.out.println(Arrays.toString(objects));
		}*/
		
		// 将查询结果封装到对象当中
		SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer");
		sqlQuery.addEntity(Customer.class);
		List<Customer> list = sqlQuery.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}

Hibernate的抓取策略(优化)

1、延迟加载

延迟加载：lazy(懒加载)。执行该行代码的时候，不会发送语句去进行查询，在真正使用这个对象的属性的时候才会发送SQL语句进行查询。

延迟加载的分类

  1. 类级别的延迟加载
    指的是通过load方法查询某个对象的时候，是否使用延迟。session.load(Customer.class,1l);

    • 类级别的延迟加载通过<class>上的lazy进行配置。如果想让lazy失效：
      • 将lazy设置为false。
      • 将持久化类用final修饰。
      • 调用Hibernate.initialize()。

  2. 关联级别的延迟加载
    指的是在查询某个对象的时候，查询其关联对象的时候是否会采用延迟加载。
    Customer customer = session.get(Customer.class,1l);
    customer.getLinkMans();—通过客户获得联系人的时候，联系人对象是否使用了延迟加载，称为关联级别的延迟。

  • 抓取策略往往会和关联级别的延迟加载一起使用，优化语句。

2、抓取策略

1、抓取策略的概述

  通过一个对象抓取到关联对象需要发送SQL语句，SQL语句如何发，发送什么样的格式通过策略进行配置。

  • 通过<set>或者<many-to-one>上通过fetch属性进行设置。
  • fetch和这些标签上的lazy如何设置优化发送的SQL语句。

2、<set>上的fetch和lazy

  1. fetch：抓取策略，控制SQL语句格式。取值有：

    • select：默认值，发送普通的select语句，查询关联对象
    • join：发送一条迫切左外连接查询关联对象
    • subselect：发送一条子查询查询其关联对象

  2. lazy：延迟加载，控制查询关联对象的时候是否采用延迟。取值有：

    • true：默认值，查询关联对象的时候，采用延迟加载
    • false：查询关联对象的时候，不采用延迟加载
    • extra：及其懒惰。(用什么发送什么)

注意：在实际开发过程中，一般采用默认值。如果有特殊的需求，可能需要配置join。

测试：
3. 默认情况下，发送SQL语句：
默认情况，即配置fetch=“select” lazy="true"

	@Test
	// 默认情况，即配置 fetch="select" lazy="true"
	public void demo2(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		//查询1号客户
		Customer customer = session.get(Customer.class, 1l);// 发送一条查询客户的SQL
		System.out.println(customer);
		// 查看1号客户的每个联系人的信息
		for (LinkMan linkMan : customer.getLinkMans()) { // 发送一条根据ID查询联系人的SQL
			System.out.println(linkMan.getLkm_name());
		}
		
		transaction.commit();
	}
  1. 配置fetch=“select” lazy="false"
	@Test
	// 配置fetch="select" lazy="false"
	public void demo3(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		//查询1号客户
		Customer customer = session.get(Customer.class, 1l);// 发送两条SQL语句:查询客户，查询客户关联的联系人
		System.out.println(customer);
		// 查看1号客户的每个联系人的信息
		/*for (LinkMan linkMan : customer.getLinkMans()) {
			System.out.println(linkMan.getLkm_name());
		}*/
		
		System.out.println(customer.getLinkMans().size());
		
		transaction.commit();
	}
  1. 配置fetch=“select” lazy="extra"
	@Test
	// 配置fetch="select" lazy="extra"
	public void demo4(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		//查询1号客户
		Customer customer = session.get(Customer.class, 1l);// 发送一条查询1号客户的SQL语句
		System.out.println(customer);
		// 查看1号客户的每个联系人的信息
		/*for (LinkMan linkMan : customer.getLinkMans()) {
			System.out.println(linkMan.getLkm_name());
		}*/
		
		System.out.println(customer.getLinkMans().size()); // 发送一条select count() from.....
		
		transaction.commit();
	}
  1. 配置fetch=“join” lazy=失效
	@Test
	// 配置fetch="join" lazy=失效
	public void demo5(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		//查询1号客户
		Customer customer = session.get(Customer.class, 1l);// 发送一条迫切左外连接查询记录
		System.out.println(customer);
		
		System.out.println(customer.getLinkMans().size()); // 不发送
		transaction.commit();
	}
  1. 配置fetch=“subselect” lazy="true"
	@Test
	// 配置fetch="subselect" lazy="true"
	public void demo6(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		List<Customer> list = session.createQuery("from Customer").list();// 发送查询所有客户的SQL
		for (Customer customer : list) {
			System.out.println(customer.getCust_name());
			System.out.println(customer.getLinkMans().size());// 发送一条子查询
		}
		
		transaction.commit();
	}

在这里插入图片描述
注意：在设置为subselect下，不能只查询一条记录，否则看不到子查询。

  1. 配置fetch=“subselect” lazy="false"
	@Test
	// 配置fetch="subselect" lazy="false"
	public void demo7(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		List<Customer> list = session.createQuery("from Customer").list();// 发送查询所有客户的SQL和一条子查询
		for (Customer customer : list) {
			System.out.println(customer.getCust_name());
			System.out.println(customer.getLinkMans().size());
		}
		
		transaction.commit();
	}
  1. 配置fetch=“subselect” lazy="extra"
    在统计个数的时候才会发送统计的SQL语句。

3、<many-to-one>标签上的fetch和lazy

  1. fetch：抓取策略，控制SQL语句格式。取值有：

    • select：默认值，发送普通的select语句，查询关联对象
    • join：发送一条迫切左外连接查询关联对象

  2. lazy：延迟加载，控制查询关联对象的时候是否采用延迟。取值有：

    • proxy：默认值，proxy具体取值，取决于另一端的<class>上的lazy的值
    • false：查询关联对象的时候，不采用延迟加载
    • no-proxy(不会使用）

注意：在实际开发过程中，一般采用默认值。如果有特殊的需求，可能需要配置join。

测试：
3. 默认情况，配置fetch=“select”,lazy=“proxy”

	@Test
	/*
	 * 默认值：配置fetch="select",lazy="proxy"
	 */
	public void demo1() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		LinkMan linkMan = session.get(LinkMan.class, 1l);// 发送一条查询联系人的语句
		System.out.println(linkMan.getLkm_name());
		System.out.println(linkMan.getCustomer().getCust_name());// 发送一条select语句查询联系人所关联的客户
		
		transaction.commit();
	}
  1. 配置fetch=“select” lazy=“false”
	@Test
	/**
	 * fetch="select" lazy="false" 
	 */
	public void demo3() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		LinkMan linkMan = session.get(LinkMan.class, 1l);// 发送一条查询联系人的语句，发送一条select语句查询
														 // 联系人所关联的客户
		System.out.println(linkMan.getLkm_name());
		System.out.println(linkMan.getCustomer().getCust_name());
		
		transaction.commit();
	}
  1. 配置fetch=“join” lazy=失效
	@Test
	/**
	 * fetch="join" lazy=失效
	 */
	public void demo4() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		LinkMan linkMan = session.get(LinkMan.class, 1l);// 发送一条迫切左外连接查询联系人所关联的客户

		System.out.println(linkMan.getLkm_name());
		System.out.println(linkMan.getCustomer().getCust_name());
		
		transaction.commit();
	}

3、批量抓取

1、什么是批量抓取：一批关联对象一起抓取，batch-size

2、测试批量抓取

  1. 获取客户的时候，批量获取联系人
    在Customer.hbm.xml的set标签下，配置batch-size=“数字”，数字根据要抓取的联系人的数量确定。
	@Test 
	// 获取客户的时候，批量获取联系人
	// 在Customer.hbm.xml中的set标签上配置batch-size
	public void demo1() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		List<Customer> list = session.createQuery("from Customer").list();
		for (Customer customer : list) {
			System.out.println(customer.getCust_name());
			for (LinkMan linkMan : customer.getLinkMans()) {
				System.out.println(linkMan.getLkm_name());
			}
		}
		
		transaction.commit();
	}
  1. 获取联系人的时候，批量获取客户。
    在Customer.hbm.xml的class标签下，配置batch-size=“数字”，数字根据要抓取的联系人的数量确定。
	@Test 
	// 获取联系人的时候，批量获取客户
	// 在Customer.hnm.xml的class标签上配置batch-size
	public void demo2() {
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		List<LinkMan> list = session.createQuery("from LinkMan").list();
		for (LinkMan linkMan : list) {
			System.out.println(linkMan.getLkm_name());
			System.out.println(linkMan.getCustomer().getCust_name());
		}
		
		transaction.commit();
	}
静水流深i
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate常见问题集锦
hejianjie520的专栏
06-03 324
1问：Hibernate初始化时总是报错：java.lang.NoClassDefFoundError Hibernate初始化时出现出错代码： java.lang.NoClassDefFoundError: net/sf/ehcache/CacheException 答：这是新手常见问题。是因为使用默认设置时，Hibernate文档里指出的Hibernate库不完整，缺少ehcache.ja...
Hibernate基本查询(学习笔记)
Lazyafei's Blog
05-28 722
Query接口 HQL基本查询 Hibernate投影查询 where条件查询   Query接口 Query接口是hibernate专门用来执行HQL语句的查询接口，使用方式：   Query query = session.createQuery("HQL语句"); Query.setParameter(…); List resultList = query.lis
Hibernate本地SQL的使用
lichuangcsdn的博客
09-05 861
Hibernate默认的是使用Query对象完成数据库操作，也就是说这里面需要传入的是HQL语句，如果要用本地SQL（也即自定义SQL语句），那么我们一般用的是SQLQuery对象。下面介绍下该对象的一些常见操作 1、返回分页查询结果List&lt;T&gt; getSession().createSQLQuery(sql.toString())                 .setRes...
hibernate学习(查询)
mockingbirds的专栏
06-20 1120
数据查询是hibernate的一个亮点，hibernate为程序猿提供了多种的查询方式，分为以下三种： 1.hibernate语言查询，也就是我们今天需要说的hql查询，这种查询是完全面向对象的方式来查询，将查询语句封装为对象来进行操作。符合面向对象的思维来维护数据库。 2.hibernate标准化查询:（criteria query）将查询语句封装成对象进行操作。 3.原声sql查询：直接使
bernate中的Query一些基本用法
u010486495的专栏
01-31 789
Java代码   /**  * 添加  */   public void save(Stu stu){      try {       tran=this.GetSession().beginTransaction();       this.GetSession().save(stu);       tran.commit();      } catch (Hib
Hibernate中的多表查询及抓取策略
08-31
综上所述，Hibernate的多表查询和抓取策略提供了灵活的数据获取方式，开发者可以根据需求选择合适的策略来平衡性能和代码的简洁性。了解并熟练运用这些策略，可以显著提高应用程序的效率。在实际开发中，合理利用...
day36 07-Hibernate抓取策略：many-to-one上的抓取策略
04-26
今天我们要讨论的是Hibernate框架中的一个关键概念——抓取策略，特别是针对"many-to-one"关系的抓取策略。这篇博客将深入剖析这个主题，帮助你更好地理解和应用Hibernate。 Hibernate是Java领域中最流行的对象关系...
day36 08-Hibernate抓取策略：批量抓取
04-26
为了解决这个问题，Hibernate提供了几种抓取策略，包括批量抓取和预加载。 批量抓取允许我们在一次查询中获取多个关联对象，而不是逐个加载。例如，如果我们有一个`User`实体，每个用户都有多个`Order`，我们可以...
day36 06-Hibernate抓取策略：set集合上的抓取策略
04-26
在提供的压缩包文件"hibernate_day03"中，可能包含了相关的代码示例或教程，可以帮助你更直观地学习和体验Hibernate的抓取策略。通过深入学习和实践，你将能够更好地应对各种复杂的数据库操作场景。
hibernate查询mysql数据库_使用hibernate排序查询MySQL数据库
weixin_34782968的博客
01-19 115
我有一个MySQL数据库包含一个名为'任务'的表。我使用Hibernate将数据映射到数据库。它包括这些字段：id，user_id，project_id，deliverrable_id，activity_id，...当我从Db检索任务时，首先需要按项目对它们进行排序，然后通过Deliverable，最后通过Activty进行排序。Session session = HibernateUtil.ge...
Hibernate入门(六)---------HQL语句
daxia7577的博客
11-10 134
Query: 　　　　代表面向对象的一个Hibernate查询操作.在Hibernate中，通常使用session.createQuery()方法接收一个HQL语句，然后调用Query的 list()或uniqueResult()方法执行查询。所谓的HQL是Hibernate Query Language缩写，其语法很像SQL，但它是完全面向对象的。 在Hibernate中使用Qu...
Hibernate中的查询
曰业而安的博客
01-31 240
温故而知新，本文回顾一下Hibernate中的查询方式。 1.hql查询 //第一种：查询所有 Session session = HibernateUtils.getCurrentSession(); Transaction ts = session.beginTransaction(); String hql="from Customer"; Query query = session....
SSH进阶（三）Hibernate----关联关系，HQL查询语言
qq_42112846的博客
07-17 3119
关联关系、HQL语言、关联表之间的查询   在mybatis种有关联关系，同样在Hibernate当中也是有关联关系得； 在mybatis当中多对一用的是associatej节点，而一对多对应得就是collection 相应得再hibernate当中多对一是many-to-one 而一对多是one-to-many 一、关联关系 1.首先来说hibernate种多对一得关系：   比如...
Hibernate 抓取 去除重复 解决方案
eMavaj的小窝
05-21 168
其实，对于Hibernate 的 Lazy   可以说是又爱又恨   不过好像细想，爱是自然，恨嘛...  个人觉得还是恨自己的技术不过关吧   Lazy 懒加载 和 Fetch 抓取   是对相反的东西   用好了相当于可以自由切换Hibernate配置中的 lazy = "xxx" 这个属性   情景：   一个 ACL 有很多 Power ，他们是一 (ACL)...
hibernate mysql5.6_Hibernate 原理及实战（一）
weixin_35782323的博客
02-01 361
1.三层架构分层三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为：界面层(User Interface layer)、业务逻辑层(Business Logic Layer)、数据访问层(Data access layer)。区分层次的目的即为了“高内聚低耦合”的思想。在软件体系架构设计中，分层式结构是最常见，也是最重要的一种结构。微软推荐的分层式结构...
Hibernate查询操作
aisi5656的博客
07-20 182
操作前需要创建好Hibernate项目，创建项目，可参考：http://www.cnblogs.com/zhaojinyan/p/9336174.html 一下的例子是从其他贴子粘过来的（知识无国界！！），好了，抖擞抖擞精神，开始吧...... 测试数据库如下 t_sort表： t_good表： 一...
hibernate查询接口Query用法
feinifi的博客
03-18 1万+
hibernate的Session接口提供了get,load等按照id查询单个记录的方法，但是大多数时候，我们查询的是实体类的集合列表，这就需要用到复杂查询了，hibernate提供了类sql语句hql，他可以帮助我们编写复杂的查询语句，来做复杂的增删改查操作。这里介绍hibernate提供的Query接口用法。 Query接口的创建是通过Session来创建的，默认需要传入一个hql语句，比如...
hibernate 获取实体的表名、主键名、列名(转载+修改)
前往JAVA架构的路上
05-27 4321
package com.escs.utils; import java.util.Iterator; import org.hibernate.cfg.AnnotationConfiguration; import org.hibernate.cfg.Configuration; import org.hibernate.mapping.Column; impor
由HibernateTemplate执行原生SQL总结
热门推荐
sonwing_for的博客
04-01 1万+
一次做项目中，我将数据源放在了db.properties文件中，将数据源dataSource交给Spring来管理。然后在dao的实现层继承HibernateSupport类，从而通过this.getHibernateTemplate()就可以执行HQL语句。据说是在HibernateTemplate类里面就有sessionFactory这个属性。 附上我的db.properties和sprin
Hibernate官方教程3.5.0-Final中文版：持久化框架详解
5. **配置**：详细讲述了如何配置Hibernate，包括编程式配置、获取SessionFactory、JDBC连接的管理，以及一系列可选配置属性，如SQL方言选择、外连接抓取策略、二进制流处理、二级缓存和查询缓存的使用，还有查询...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值