Hibernate中的双向一对多的映射,表中的QBC和HQL查询

最新推荐文章于 2021-02-27 07:43:19 发布
最新推荐文章于 2021-02-27 07:43:19 发布
阅读量218 收藏
点赞数
分类专栏： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43257103/article/details/89947868
版权

Department:对应一的一方

package zhang.hibernate.entities;
    import java.util.HashSet;
    import java.util.Set; 
    public class Department {
    	private Integer departmentId;
    	private String departmentName;
    	private Set<Employee> employees=new HashSet<>();
    	public Integer getDepartmentId() {
    		return departmentId;
    	}
    	public void setDepartmentId(Integer departmentId) {
    		this.departmentId = departmentId;
    	}
    	public String getDepartmentName() {
    		return departmentName;
    	}
    	public void setDepartmentName(String departmentName) {
    		this.departmentName = departmentName;
    	}
    	public Set<Employee> getEmployees() {
    		return employees;
    	}
    	public void setEmployees(Set<Employee> employees) {
    		this.employees = employees;
    	}
    	public Department(String departmentName, Set<Employee> employees) {
    		super();
    		this.departmentName = departmentName;
    		this.employees = employees;
    	}
    	
    
    	@Override
    	public String toString() {
    		return "Department [departmentId=" + departmentId + ", departmentName=" + departmentName + "]\n";
    	}
    	public Department() {
    		// TODO Auto-generated constructor stub
    	}
    	
    
    }

Employee对应多的一方

package zhang.hibernate.entities;

public class Employee {
	private Integer id;
	private String name;
	private String email;
	private String phoneNumber;
	private float salary;

	private Department department;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getPhoneNumber() {
		return phoneNumber;
	}

	public void setPhoneNumber(String phoneNumber) {
		this.phoneNumber = phoneNumber;
	}

	public float getSalary() {
		return salary;
	}

	public void setSalary(float salary) {
		this.salary = salary;
	}

	public Department getDepartment() {
		return department;
	}

	public void setDepartment(Department department) {
		this.department = department;
	}
	
	public Employee(Integer id, String name, String email) {
		super();
		this.id = id;
		this.name = name;
		this.email = email;
	}
	
	public Employee(Integer id, String name, String email, String phoneNumber) {
		super();
		this.id = id;
		this.name = name;
		this.email = email;
		this.phoneNumber = phoneNumber;
	}

	public Employee(String name, String email, String phoneNumber, float salary, Department department) {
		super();
		this.name = name;
		this.email = email;
		this.phoneNumber = phoneNumber;
		this.salary = salary;
		this.department = department;
	}
	
	

	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", email=" + email + ", phoneNumber=" + phoneNumber
				+ ", salary=" + salary +  "]\n";
	}

	public Employee() {
		// TODO Auto-generated constructor stub
	}
	
}

employee和department对应的映射文件
department.hbm.xm文件:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2019-5-6 16:51:34 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="zhang.hibernate.entities.Department" table="ZYK_DEPARTMENTS">
        <id name="departmentId" type="java.lang.Integer">
            <column name="DEPARTMENTID" />
            <generator class="native" />
        </id>
        <property name="departmentName" type="java.lang.String">
            <column name="DEPARTMENTNAME" />
        </property>
        <set name="employees" table="ZYK_EMPLOYEES" inverse="true" lazy="true">
        	
            <key>
                <column name="DEPARTMENTID" />
            </key>
            <one-to-many class="zhang.hibernate.entities.Employee" />
        </set>
    </class>
</hibernate-mapping>

employee.hbm.xml文件:

**<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2019-5-6 16:51:34 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="zhang.hibernate.entities.Employee" table="ZYK_EMPLOYEES">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="email" type="java.lang.String">
            <column name="EMAIL" />
        </property>
        <property name="phoneNumber" type="java.lang.String">
            <column name="PHONENUMBER" />
        </property>
        <property name="salary" type="float">
            <column name="SALARY" />
        </property>
        <many-to-one name="department" class="zhang.hibernate.entities.Department" column="DEPARTMENTID" >
        </many-to-one>
    </class>
    	<query name="zhangyukangquery"><![CDATA[select id,name,email from Employee e where e.department=:dept]]></query>
        <!--配置命名查询 -->
      <query name="QueryWithSalary"><![CDATA[ FROM Employee e where e.salary>:minSal and e.salary<:maxSal order by e.salary]]></query>
</hibernate-mapping>**

QBC和HQL查询的测试类:

package zhang.hibernate.test;

import java.util.Arrays;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Conjunction;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Restrictions;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import zhang.hibernate.entities.Department;
import zhang.hibernate.entities.Employee;

public class Test2 {
	private SessionFactory SessionFactory = null;
	private Session session = null;
	private Transaction Transaction = null;
	@Before
	public void init() {
		Configuration configuration = new Configuration().configure();
		ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())
				.buildServiceRegistry();
		this.SessionFactory = configuration.buildSessionFactory(serviceRegistry);
		this.session = SessionFactory.openSession();
		Transaction = session.beginTransaction();
	}
	@After
	public void destory() {
		Transaction.commit();
		session.close();
		SessionFactory.close();
	}
	@Test
	public void testhqlmaxandminquery(){
		String hql="from Employee e where e.salary>? and e.department=:dept";
		Department department=new Department();
		department.setDepartmentId(80);
		List<Employee> list = session.createQuery(hql)
									.setFloat(0, 1000).setEntity("dept", department).list();
		System.out.println(list);
	}
	// hql的分页
	@Test
	public void testhqlpage() {
		int pageNo = 3;
		int pageSize = 5;
		String hql = "from Employee e where e.salary>? ";
		List<Employee> list = session.createQuery(hql).setFloat(0, 5000)
								.setFirstResult((pageNo - 1) * pageSize)
								.setMaxResults(pageSize).list();
		System.out.println(list);
	}
	@Test
	public void buildbeansbyfields() {
		String hql = "select new Employee(id,name,email,phoneNumber) "
				+ " from Employee e " 
				+ "where e.department=:dept "
				+ " order by salary";
		Department department = new Department();
		department.setDepartmentId(80);
		List<Employee> list = session.createQuery(hql).setEntity("dept", department).list();
		System.out.println(list);
	}
	@Test
	public void testandQBC(){
		Criteria criteria=session.createCriteria(Employee.class);
		Conjunction conjunction=Restrictions.conjunction();
		Department department=new Department();
		department.setDepartmentId(80);
		conjunction.add(Restrictions.eq("department", department));
		criteria.add(conjunction);
		
		List<Employee> list = criteria.list();
		System.out.println(list);
		
	}
	//qbc查询,查询出数据库中的email是SKING的员工的信息
	@Test
	public void testSKING(){
		Criteria criteria=session.createCriteria(Employee.class);
		Employee employee= (Employee) criteria.add(Restrictions.eq("email", "SKING")).uniqueResult();
		System.out.println(employee);
	}
	//查询数据库中的工资大于10000元的所有的员工的信息
	@Test
	public void testqbc2(){
		Criteria criteria=session.createCriteria(Employee.class);
		criteria.add(Restrictions.gt("salary", 10000f));
		List<Employee> list = criteria.list();
		System.out.println(list);
	}
	/**
	 * 	QBC查询:查询email中的含有字符串的a的所有员工的详细的信息
	 */
	@Test
	public void testqbc(){
		Criteria criteria=session.createCriteria(Employee.class);
		criteria.add(Restrictions.like("email", "A",MatchMode.ANYWHERE));
		List<Employee> list = criteria.list();
		System.out.println(list);
	}
	//命名查询
	@Test
	public void testgetnamequery(){
		Department department=new Department();
		department.setDepartmentId(80);
		Query query = session.getNamedQuery("zhangyukangquery").setEntity("dept", department);
		List<Object[]> list = query.list();
		for(Object[] objs:list){
			System.out.println(Arrays.asList(objs));
		}
		System.out.println(list);
	}
	/**
	 * hql分页
	 */
	@Test
	public void testpage2(){
		String sql="select id,name,email,salary from Employee e  "
				+ "where e.salary>? and email like:emailstr";
		int pageNo=3;
		int pageSize=5;
		List<Employee> list = session.createQuery(sql)
				.setFloat(0, 5000F).setString("emailstr", "%A%").setFirstResult((pageNo-1)*pageSize)
									.setMaxResults(pageSize).list();
		for(Employee emp:list){
			System.out.println(emp.getEmail()+", "+emp.getName()+", "+emp.getSalary());
		}
		System.out.println(list);
	}
	@Test
	public  void testpage(){
		String hql="from Employee e where e.salary>:sal and department=:dept";
		Department department=new Department();
		department.setDepartmentId(80);
		List<Employee> list = session.createQuery(hql).setFloat("sal", 10000f).setEntity("dept", department).list();
		System.out.println(list);
	}
	@Test
	public void testleftjoin(){
		String hql="FROM Employee";
		List<Employee> list = session.createQuery(hql).list();
		System.out.println(list);
		
	}
	//迫切左外连接
	@Test
	public void tesleftjoinfetch(){
		String hql="from Employee e left join fetch e.department where e.department=:dept";
		Department department =new Department();
		department.setDepartmentId(80);
		List<Employee> list = session.createQuery(hql).setEntity("dept", department).list();
		System.out.println(list);
	}
	/**
	 * 查询各个部门的最低的工资和最高的工资
	 */
	@Test
	public void testGroupBy() {
		String hql = "select department, min(e.salary),max(e.salary) "
				+ "from Employee e " + "group by e.department "
				+ "having min(e.salary)>5000";
		List<Object[]> list = session.createQuery(hql).list();
		for (Object[] objs : list) {
			System.out.println(Arrays.asList(objs));
		}
	}
	/**
	 * 获取一个部分的字段
	 */
	@Test
	public void testgetfield() {
		String hql = "select id,name,email,phoneNumber from Employee e "
					+ "where e.department=:dept "
					+ " order by salary";
		Department department = new Department();
		department.setDepartmentId(80);
		Query setFloat = session.createQuery(hql).setEntity("dept", department);
		List<Object[]> list = setFloat.list();
		for (Object[] objs : list) {
			System.out.println(Arrays.asList(objs));
		}
	}
	//获取80号部门的所有的员工的信息
	@Test
	public void testgetdepartmentequal80() {
		String hql = "from Employee e  "
				+ "where e.department=:department";
		Department department = new Department();
		department.setDepartmentId(80);
		List<Employee> list = session.createQuery(hql).setEntity("department", department).list();

		for (Employee employee : list) {
			System.out.println(employee.getName() + ", " + employee.getPhoneNumber() + ", " + employee.getEmail());
		}
	}
	// 带条件的hql查询
	@Test
	public void testhql2() {
		String hql = "from Employee e where e.salary>:sal";
		Department department = new Department();
		department.setDepartmentId(80);
		List<Employee> list = session.createQuery(hql).setFloat("sal", 10000).list();
		System.out.println(list);
	}
	// 获取搜有的员工的信息
	@Test
	public void testhql() {
		List<Employee> list = session.createQuery("From Employee").list();
		System.out.println(list);
	}

	@Test
	public void testgetcustomer() {
		Employee employee = (Employee) session.get(Employee.class, 107);
		System.out.println(employee);
	}
	@Test
	public void testhibernateapi() {
		SessionFactory sessionFactory = null;
		Configuration configuration = new Configuration().configure();
		ServiceRegistry serviceRegistry = 
				new ServiceRegistryBuilder()
				.applySettings(configuration.getProperties())
				.buildServiceRegistry();

		sessionFactory = configuration.buildSessionFactory(serviceRegistry);
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();

		Department department = new Department();
		department.setDepartmentName("zhangyukangdepartment");
		session.save(department);

		transaction.wasCommitted();
		transaction.commit();
		session.close();
		sessionFactory.close();

	}

}
七月的尾巴←_←
关注
专栏目录
Hibernate③单表和多表的查询方式
CSDN
05-18 602
1 单表查询 1.1 QID检索与查询中的效率优化 1.1.1 get()与立即查询 1.1.2 load()与延迟查询 1.2 HQL检索 1.3 QBC检索 2 多表查询 2.1 对象图导航检索 2.2 内链接与迫切内连接 2.3 左外连接与迫切左外连接 2.4 右外连接 更多Hibernate在框架开发 1 单表查询 1.1 QID检索与查询中...
Hibernate-HQL-QBC-QBE
03-18
HQL提供了一种面向对象的查询方式，QBC和QBE则提供了更多灵活性，可以根据需求动态构建查询。同时，理解这些概念也有助于开发者更好地与其他Java ORM框架（如MyBatis）进行比较和选择。在学习和使用过程中，参考官方...
Hibernate HQL 一对多查询
快雪时晴天的专栏
10-02 1876
1、等值连接： /** * 等值查询 查询出来的结构很差 */ public List queryClasses_Student_EQ(){ Session session = sessionFactory.openSession(); List cList = session.createQuery("from Classes
hibernate中一对多关系hql条件查询
Stand by
11-10 7015
当hibernate中难免遇到一对多的情况,并且需要对多方添加条件,使用sql查询会简单很多,hql的语法如下 Teacher对应下有多个Student Teacher中Set students; select t from Teacher t,Student s where t.tNo ='001' and s.sName like '张%' and s in elements(t
QBC Hibernate 多表查询
今天最成功
03-07 360
1.java 实体对象     package com.helloworld.domain; // Generated 2012-3-7 18:14:29 by Hibernate Tools 3.2.1.GA /** * TbAccount generated by hbm2java * @author liuqing */ public class TbA...
hibernate关联映射(注解) —— 基于主键的双向一对一关联映射(@OneToOne)
GeorgeAshe的博客
06-21 209
//初始化  User user = new User();  UserMore more = new UserMore();  //设置关联关系  user.setMore(more);  more.setUser(user);  //持久化  session.save(user);  public class User  {      @Id      @GeneratedValue(stra...
java中使用QBC的好处_使用QBC的方式应用多对多关系中的查询
weixin_34739699的博客
02-27 153
关系描述User实体和Group实体是多对多的关系，实体和表的对应关系如下：Java Bean表Usertb_userGrouptb_grouptb_user表的字为：ID,UserName,FirstName,LastNametb_group表的字段为：ID,Name其中关联关系中间表为:tb_userGroup，其字段为：ID,UserID(外键，引用tb_user表的id),GroupI...
Hibernate实例开发 HQL 与 QBC 查询
08-05
本教程将深入探讨Hibernate中的两种查询方式：HQL（Hibernate Query Language）和QBC（Query By Example）。通过实例开发，我们将了解这两种查询方法的使用和它们之间的差异。 首先，HQL是Hibernate专门设计的一种...
hibernate映射和查询
11-06
**hibernate映射与查询** Hibernate 是一个流行的 Java 应用程序开发框架，它提供了一个持久层解决方案，简化了数据库操作。对于初学者来说，理解 Hibernate 的映射和查询机制是至关重要的，因为它们构成了 ...
Hibernate_QBC和Hibernate_QBE
04-13
文件中可能还涵盖了如何配置Hibernate、创建实体类、映射文件，以及如何在实际项目中运用QBC和QBE来提高查询效率和代码可维护性。 总结来说，QBC和QBE是Hibernate提供的两种实用查询方式，分别适合不同的场景。QBC...
Hibernate初探之一对多映射
不积跬步，无以千里
01-23 329
1.Hibernate Query Language课程介绍 HQL查询子句 检索对象——from子句（指定要查询的持久化对象） 选择——select子句（选择查询持久化对象中的指定属性 ） 限制——where子句（限制持久化对象的查询范围） 排序——order by子句（对查询结果进行排序） 学习目标： 1、了解HQL定义以及HQL语句形式； 2、掌握Query对象的使用； 3
Hibernate 超简单的一对多和多对一查询
kd_bright的博客
03-12 1万+
这里使用的Teacher类和Student类（假设一个Teacher对应多个学生，一个学生对应一个老师）所需jar包开始建表1（表名 teacher）2（表名 student）主键都为自增长创建实体类Teacher类package com.bright.po; import java.util.Set; public class Teacher { private Integer id; ...
Hibernate之QBC持久层封装（一）
weixin_33736649的博客
07-08 104
Hibernate之QBC QBC查询就是通过使用Hibernate提供的Query By Criteria API来查询对象，这种API封装了SQL语句的动态拼装，对查询提供了更加面向对象的功能接口。 一真都是使用Hibernate的QBC来对操作数据 ，对持久层DaoTemplate做了一些封装； 不善言语表达，直接放代码，字数原因不提供GE...
mysql 一对多映射_Hibernate关联关系映射之一对多关联关系
weixin_39837207的博客
01-27 70
本次以一个示例方式进行演示，某个单位有多个部门，每个部门中又有很多不同的员工，在存储时需要建立一张员工表和一张部门表，存储全部的部门和员工信息，而这两张表中通过外键进行关联，从而能根据部门名称查询出该部门的所有员工，同时又能根据员工名称查本次以一个示例方式进行演示，某个单位有多个部门，每个部门中又有很多不同的员工，在存储时需要建立一张员工表和一张部门表，存储全部的部门和员工信息，而这两张表中通过外...
hibernate的一对多和多对一关系映射
ch_平凡~~生活！
07-26 532
//dep.hbm.xml的代码  "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  package="com.total">
【Hibernate九】HQL之多表查询（一对多和多对多）
热门推荐
温故而知新
07-17 4万+
一、一对多 以班级Classes和学生Student为例： 回忆sql语句: //内链接,两种方式效果一样,查询的是两边都有的数据 SELECT c.*,s.* FROM classes c,student s WHERE s.cid=c.cid; SELECT c.cname,s.sname FROM classes c INNER JOIN student s O
hibernate关于多对多映射和多对一的hql查询
搬砖小鱼，请多指教呦
06-12 1086
public void queryCustomerbymerchantId(){ SessionFactory sf = HibernateUtil.getSessionFactory(); Session session = sf.getCurrentSession(); Transaction ts = session.beginTransaction(); try { ...
hibernate中使用QBC进行多表条件查询
影子
01-02 1603
两个表关系如上图，区域和分区为一对多的关系，对分区进行条件查询，需要用到区域里的省市区属性，这样就需要对这两张表进行查询。 Criteria criteria = this.getSession().createCriteria(Subarea.class); criteria.createAlias("region", "re"); criteria.add(Restrictions.li
Hibernate的HQL,QBC 查询语言（包括多表联合查询join）
xn_28的专栏
04-24 7632
引用链接：http://takeme.iteye.com/blog/1722522   参考链接： in和not in用法：http://blog.csdn.net/shiqidide/article/details/7327460   或   http://blog.csdn.net/shiqidide/article/details/7327460 Enum映射策略：http://b
精通Hibernate：HQL检索与QBC查询详解
Hibernate是一种广泛使用的轻量级Java ORM（对象关系映射）框架，本文将深入探讨其核心功能之一——HQL（Hibernate Query Language）。HQL是Hibernate官方推荐的主要检索方式，它提供了类似于SQL的查询语法，但以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值