欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Hibernate迫切连接和普通连接的区别实例详解

程序员文章站 2024-02-13 20:07:40
hibernate 迫切连接和普通连接的区别 相关的介绍和解释在代码中已注释,大家可以参考。 package com.baidu.test; import...

hibernate 迫切连接和普通连接的区别

相关的介绍和解释在代码中已注释,大家可以参考。

package com.baidu.test;
import java.util.arraylist;
import java.util.linkedhashset;
import java.util.list;
import org.hibernate.query;
import org.hibernate.session;
import org.hibernate.sessionfactory;
import org.hibernate.transaction;
import org.hibernate.cfg.configuration;
import org.hibernate.service.serviceregistry;
import org.hibernate.service.serviceregistrybuilder;
import org.junit.after;
import org.junit.before;
import org.junit.test;
import com.baidu.leftjoin.department;
import com.baidu.leftjoin.employee;
public class testhql_leftjoin {
	private sessionfactory sessionfactory;
	private session session;
	private transaction transaction;
	@before
	  public void init(){
		configuration configuration = new configuration().configure();
		serviceregistry serviceregistry = new serviceregistrybuilder()
		                    .applysettings(configuration.getproperties())
		                    .buildserviceregistry();
		sessionfactory = configuration.buildsessionfactory(serviceregistry);
		session = sessionfactory.opensession();
		transaction = session.begintransaction();
	}
	@after
	  public void destroy(){
		transaction.commit();
		session.close();
		sessionfactory.close();
	}
	// ~~~~~~~~~~~~~~~~~~~~~~~~~~下面的例子是 从 1 对 多  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	/**
   *
   * 迫切左外连接: 特点是:如果左表有不满足条件的,也返回左表不满足条件
   *    1. left join fetch 关键字表示迫切左外连接检索策略.
   *    2. list() 方法返回的集合中存放实体对象的引用, 每个 department 对象关联的 employee 集合都被初始化,
   *       存放所有关联的 employee 的实体对象.
   *    3. 查询结果中可能会包含重复元素, 可以通过一个 hashset 来过滤重复元素
   *
   *     去重:
   *       方法一:使用 distinct
   *         string hql = "select distinct d from department d left join fetch d.emps ";
   *        query query = session.createquery(hql);
   *
   *        list<department> depts = query.list();
   *        system.out.println(depts.size());
   *       
   *       方法二
   *         string hql = "from department d left join fetch d.emps ";
   *        query query = session.createquery(hql);
   *
   *        list<department> depts = query.list();
   *
   *        depts = new arraylist<>(new linkedhashset(depts));
   *        system.out.println(depts.size());
   *        
   *        for(department dept:depts){
   *          system.out.println(dept.getname() + "--" + dept.getemps().size() );
   *        }
   *
   *
   */
	@test
	  public void testleftjoinfetch(){
		//    string hql = "select distinct d from department d left join fetch d.emps ";
		//    query query = session.createquery(hql);
		//    
		//    list<department> depts = query.list();
		//    system.out.println(depts.size());
		//    
		string hql = "from department d left join fetch d.emps ";
		query query = session.createquery(hql);
		list<department> depts = query.list();
		system.out.println(depts.size());
		depts = new arraylist<>(new linkedhashset(depts));
		system.out.println(depts.size());
		for (department dept:depts){
			system.out.println(dept.getname() + "--" + dept.getemps().size() );
		}
	}
	/**
   * 左外连接:
   *    1. left join 关键字表示左外连接查询.
   *    2. list() 方法返回的集合中存放的是对象数组类型
   *    3. 根据配置文件来决定 employee 集合的检索策略.
   *    4. 如果希望 list() 方法返回的集合中仅包含 department 对象,
   *      可以在hql 查询语句中使用 select 关键字
   *    
   *    这样的语句查询的结果有重复:
   *      string hql = "from department d left join d.emps";
   *      query query = session.createquery(hql);
   *    
   *      list<object[]> results = query.list();
   *      system.out.println(results.size());
   *  
   *     去重:
   *       仅能使用 distinct 的方法去除重复
   *   
   *       string hql = "select distinct d from department d left join d.emps";
   *       query query = session.createquery(hql);
   *
   *       list<department> depts = query.list();
   *       system.out.println(depts.size());
   *         
   *       for(department dept:depts){
   *         system.out.println(dept.getname() + dept.getemps().size());
   *       }
   *
   */
	@test
	  public void testleftjoin(){
		string hql = "select distinct d from department d left join d.emps";
		query query = session.createquery(hql);
		list<department> depts = query.list();
		system.out.println(depts.size());
		for (department dept:depts){
			system.out.println(dept.getname() + dept.getemps().size());
		}
	}
	/**
   * 迫切内连接: 特点是:不返回左表不满足条件
   *    inner join fetch 关键字表示迫切内连接, 也可以省略 inner 关键字
   *    list() 方法返回的集合中存放 department 对象的引用, 每个 department
   *        对象的 employee 集合都被初始化, 存放所有关联的 employee 对象
   *
   * 内连接:
   *    inner join 关键字表示内连接, 也可以省略 inner 关键字
   *    list() 方法的集合中存放的每个元素对应查询结果的一条记录, 每个元素都是对象数组类型
   *    如果希望 list() 方法的返回的集合仅包含 department 对象, 可以在 hql 查询语句中使用 select 关键字
   *
   *
   *
   */
	@test
	  public void testinnerjoinfetch(){
		//string hql = "select distinct d from department d left join fetch d.emps ";
		string hql = "from department d inner join fetch d.emps ";
		query query = session.createquery(hql);
		list<department> depts = query.list();
		depts = new arraylist<>(new linkedhashset(depts));
		system.out.println(depts.size());
		for (department dept:depts){
			system.out.println(dept.getname() + "--" + dept.getemps().size() );
		}
	}
	// ~~~~~~~~~~~~~~~~~~~~~~~~~~下面的例子是 从多 对 1  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	@test
	  public void testleftjoinfetch2(){
		string hql = "from employee e left join fetch e.dept";
		query query = session.createquery(hql);
		list<employee> emps = query.list();
		system.out.println(emps.size());
		for (employee emp:emps){
			system.out.println(emp + " -- " + emp.getdept());
		}
	}
}

总结

以上就是本文关于hibernate迫切连接和普通连接的区别实例详解的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站:

hibernate中session增删改查操作代码详解

如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!