Hibernate学习之一对多基础查询（二）

最新推荐文章于 2023-04-22 22:10:50 发布
最新推荐文章于 2023-04-22 22:10:50 发布
阅读量265 收藏
点赞数 1
分类专栏： java Hibernate 文章标签： hibernate java hql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mister_yang/article/details/81213431
版权

一。Hibernate的基础查询

     1.对象导航查询
     2.hql查询
     3.hql条件查询
     4.hql模糊查询
     5.hql排序查询
     6.hql分页查询
     7.hql投影查询
     8.hql记录数查询

     9.hibernate对sql的支持

     这些基本查询讲完以后够基本用的，下一期作者会讲一下Hibernate的高级查询。

二。Hibernate配置文件

     (1)People.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC   
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
    	<class name="com.ies.entity.People" table="t_people">
    		<id name="pid" column="pid">
    			<generator class="native"></generator>
    		</id>
    		<property name="pname" column="pname"></property>
    		<property name="page" column="page"></property>
    		
    		<set name="setCar" cascade="save-update,delete">
    			<!-- 一对多，有外键，
					hibernate机制：双向维护外键，在一和多那一方都配置外键
					key的column属性表示外键名称
			 	-->
    			<key column="pid"></key>
    			<one-to-many class="com.ies.entity.Car"/>
    		</set>
    	</class>
    </hibernate-mapping>

     (2).Car.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC   
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
    	<class name="com.ies.entity.Car" table="t_car">
    		<id name="cid" column="cid">
    			<generator class="native"></generator>
    		</id>
    		<property name="cname" column="cname"></property>
    		<property name="cage" column="cage"></property>
    		<!-- name:少的一方在多的一方类中的表示
    			column:外键
    			class：外键所指的类名
    			 -->
			<many-to-one name="people" column="pid" class="com.ies.entity.People"></many-to-one>
    	</class>
    </hibernate-mapping>

（3）src/hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    <hibernate-configuration>
		<session-factory>
			<!-- 1数据库信息 -->
			<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
			<property name="hibernate.connection.url">jdbc:mysql:///mydb3</property>
			<property name="hibernate.connection.username">root</property>
			<property name="hibernate.connection.password">000000</property>
			
			<!-- 2.hibernate 其他配置-->
				<!-- 配置事务的隔离级别 -->
			<property name="hibernate.connection.isolation">4</property>
				<!-- 显示底层sql语句 -->
			<property name="hibernate.show_sql">true</property>
				<!-- 输出底层sql语句格式 -->
			<property name="hibernate.format_sql">true</property>
				<!-- hibernate会自动创建表 
					update:若表存在则更新，没有则创建
				-->
			<property name="hibernate.hbm2ddl.auto">update</property>
				<!-- 配置数据库方言,做分页的时候会使用到
					让hibernate框架识别不同的数据库
					方言一定要写成这样不能修改其他的  否则无法创建表
				 -->
			<property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
			<!-- 配置 Session 绑定本地线程 -->
			<property name="hibernate.current_session_context_class">thread</property>
			<!-- 引入配置文件 -->
			<mapping resource="com/ies/entity/Car.hbm.xml"/>
			<mapping resource="com/ies/entity/People.hbm.xml"/>
					
		</session-factory>    
    
    </hibernate-configuration>

三。Hibernate配置文件对应实体类

     (1)People.java

package com.ies.entity;

import java.util.HashSet;
import java.util.Set;

/*
 * people
 */
public class People {
	
	private Integer pid;
	private String pname;
	private String page;
	
	private Set<Car> setCar = new HashSet<>();
	
	public Integer getPid() {
		return pid;
	}
	public void setPid(Integer pid) {
		this.pid = pid;
	}
	public Set<Car> getSetCar() {
		return setCar;
	}
	public void setSetCar(Set<Car> setCar) {
		this.setCar = setCar;
	}
	public String getPname() {
		return pname;
	}
	public void setPname(String pname) {
		this.pname = pname;
	}
	public String getPage() {
		return page;
	}
	public void setPage(String page) {
		this.page = page;
	}
	@Override
	public String toString() {
		return "People [pid=" + pid + ", pname=" + pname + ", page=" + page + "]";
	}
}

(2)Car.java

package com.ies.entity;

/*
 * animal
 */
public class Car {
	
	private Integer cid;
	private String cname;
	private String cage;
	
	private People people;

	public Integer getCid() {
		return cid;
	}

	public void setCid(Integer cid) {
		this.cid = cid;
	}

	public String getCname() {
		return cname;
	}

	public void setCname(String cname) {
		this.cname = cname;
	}

	public String getCage() {
		return cage;
	}

	public void setCage(String cage) {
		this.cage = cage;
	}

	public People getPeople() {
		return people;
	}

	public void setPeople(People people) {
		this.people = people;
	}

	@Override
	public String toString() {
		return "Car [cname=" + cname + ", cage=" + cage + "]";
	}
}

四。查询Demo

HibernateUtil.java

获取sessionFactory和session对象。

package com.ies.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
	private static SessionFactory sessionFactory = null;
	static {
		Configuration  cfg = new Configuration();
		cfg.configure();
		/**
		 * 创建session的对象
		 * 读取核心配置文件的内容。
		 * 会根据映射关系，在数据库里把表创建
		 */
		sessionFactory = cfg.buildSessionFactory();
	}
	
	public  static SessionFactory getSessionFactory() {
		return sessionFactory;
	}
	
	public static Session openSession() {
		return sessionFactory.openSession();
	}
		
	public static Session currentSession() {
		return sessionFactory.getCurrentSession();
	}

	public static void main(String[] args) {
		
	}
}

 1.对象导航查询

package com.ies.test;

import java.util.List;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.persister.collection.ElementPropertyMapping;
import org.hibernate.query.Query;
import org.junit.Test;

import com.ies.entity.Car;
import com.ies.entity.People;
import com.ies.util.HibernateUtil;
import com.sun.org.apache.xml.internal.resolver.helpers.PublicId;

import sun.security.x509.PrivateKeyUsageExtension;


public class HqlQueryDemo {
	private SessionFactory sessionFactory = null;
	private Session session = null;
	private Transaction transaction  = null;
/*
	 * 对象导航查询=====================================
	 */
	@Test
	public void testSelect() {
		try {
			sessionFactory = HibernateUtil.getSessionFactory();
			session = sessionFactory.openSession();
			Transaction transaction = session.beginTransaction();
			People people = session.get(People.class, 5);
			Set<Car> cars = people.getSetCar();
			for (Car car : cars) {
				System.out.println(car.toString());
			}
			People people2 = session.load(People.class, 5);
			Set<Car> cars2 = people2.getSetCar();
			for (Car car : cars2) {
				System.out.println(car.toString());
			}
			transaction.commit();
		}catch (Exception e) {
			transaction.rollback();
			e.printStackTrace();
		}finally {
			session.close();
			sessionFactory.close();
		}
	}
}

2.hql查询

/*
	 * ================hql=================查询
	 */
	@Test
	public void testHql() {
		try {
			sessionFactory = HibernateUtil.getSessionFactory();
			session = sessionFactory.openSession();
			transaction = session.beginTransaction();
			String hql = "FROM People";
			Query query = session.createQuery(hql);
			List<People> list = query.list();
			for (People people : list) {
				System.out.println(people.toString());
			}
			transaction.commit();
		}catch (Exception e) {
			transaction.rollback();
			e.printStackTrace();
		}finally {
			session.close();
			sessionFactory.close();
		}
	}

 3.条件查寻

/*
	 *条件查寻
	 */
	@Test
	public void testHqlWithConditions() {
		try {
			sessionFactory = HibernateUtil.getSessionFactory();
			session = sessionFactory.openSession();
			transaction = session.beginTransaction();
			String hql = "";
			//hibernate4.x的jar才可以这样写
			hql = "FROM People where pid = ?1";
			Query query = session.createQuery(hql);
			query.setParameter(1, 3);
			List<People> list = query.list();
			for (People people : list) {
				System.out.println(people.toString());
			}
			transaction.commit();
		}catch (Exception e) {
			transaction.rollback();
			e.printStackTrace();
		}
	}

4. hql模糊查询

/*
	 * hql =======模糊查询=====
	 */
	@Test
	public void testHqlWithConditions2() {
		try {
			sessionFactory = HibernateUtil.getSessionFactory();
			session = sessionFactory.openSession();
			transaction = session.beginTransaction();
			String hql = "FROM People where pname like ?1";
			Query query = session.createQuery(hql);
			query.setParameter(1, "%t%");
			List<People> list = query.list();
			for (People people : list) {
				System.out.println(people.toString());
			}
			transaction.commit();
		}catch (Exception e) {
			transaction.rollback();
			e.printStackTrace();
		}finally {
			session.close();
			sessionFactory.close();
		}
	}

5.hql排序查询

/*
	 * 排序查询
	 */
	@Test
	public void testHqlInOrder() {
		try {
			sessionFactory = HibernateUtil.getSessionFactory();
			session = sessionFactory.openSession();
			transaction = session.beginTransaction();
			String hql="From People order by pid desc";
			Query query = session.createQuery(hql);
			List<People> list = query.list();
			for (People people : list) {
				System.out.println(people.toString());
			}
			transaction.commit();
		}catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
			sessionFactory.close();
		}
	}

6.hql分页查询

/*
	 * 投影查询
	 */
	@Test
	public void testHqlInPortion() {
		try {
			sessionFactory = HibernateUtil.getSessionFactory();
			session = sessionFactory.openSession();
			transaction = session.beginTransaction();
			String hql = "SELECT pid,pname FROM People";
			Query query = session.createQuery(hql);
			List<Object[]> list = query.list();
			for (Object[] objects : list) {
				System.out.println(objects[0]+"="+objects[1]);
			}
			transaction.commit();
		}catch (Exception e) {
			transaction.rollback();
			e.printStackTrace();
		}finally {
			session.close();
			sessionFactory.close();
		}
	}

7.投影查询，即对象部分属性查询

/*
	 * 投影查询
	 */
	@Test
	public void testHqlInPortion() {
		try {
			sessionFactory = HibernateUtil.getSessionFactory();
			session = sessionFactory.openSession();
			transaction = session.beginTransaction();
			String hql = "SELECT pid,pname FROM People";
			Query query = session.createQuery(hql);
			List<Object[]> list = query.list();
			for (Object[] objects : list) {
				System.out.println(objects[0]+"="+objects[1]);
			}
			transaction.commit();
		}catch (Exception e) {
			transaction.rollback();
			e.printStackTrace();
		}finally {
			session.close();
			sessionFactory.close();
		}
	}

8.hql查询记录数

/*
	 * 查询记录数
	 */
	@Test
	public void testHqlCount() {
		try {
			sessionFactory = HibernateUtil.getSessionFactory();
			session = sessionFactory.openSession();
			transaction = session.beginTransaction();
			String hql = "SELECT COUNT(pid) FROM People";
			Query query = session.createQuery(hql);
			Object object = query.uniqueResult();
			long l = (long)object;
			int count = (int)l;
			System.out.println("记录数："+count);
			transaction.commit();
		}catch (Exception e) {
			transaction.rollback();
			e.printStackTrace();
		}finally {
			session.close();
			sessionFactory.close();
		}
	}

9.hibernate对sql的支持

/*
	 * 
	 */
	@Test
	public void testSql() {
		try {
			sessionFactory = HibernateUtil.getSessionFactory();
			session = sessionFactory.openSession();
			transaction = session.beginTransaction();
			String sql = "select * from t_people";
			SQLQuery sqlQuery = session.createSQLQuery(sql);
			sqlQuery.addEntity(People.class);
			List<People> list = sqlQuery.list();
			for (People person : list) {
				System.out.println(person.toString());
			}
			transaction.commit();
		}catch (Exception e) {
			transaction.rollback();
			e.printStackTrace();
		}finally {
			session.close();
			sessionFactory.close();
		}
	}

这一期的查询暂时先到这，如有什么疑问请联系作者

 

Java小色痞
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hibernate 一对多/多对一 级联新增,查询
Soul717的博客
10-23 690
1. 什么是关联(association) 关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性。例如: public class A{ private B b = new B; public A(){} } 2.关联的分类：关联可以分为一对一、一对多/多对一、多对多关联 关联是有方向的 #关键点都在数据库中的外键上面 3案例 .如何建立订单项和订单一对多双向关...
Hibernate学习之 : 一对多关联映射
03-06
在Java世界中，ORM（对象关系映射）框架如...总之，理解并熟练运用Hibernate的一对多关联映射是提升Java企业级开发效率的关键技能之一。通过不断的实践和学习，开发者可以更好地应对各种复杂的数据库操作需求。
hibernate快速入门（一）
m0_63270506的博客
05-09 347
目录 如何使用： 具体操作： 概览: 1、创建 Maven ⼯程，pom.xml 2、编写hibernate.cfg.xml文件 3、创建实体类和创建实体关系映射⽂件： 4、实体关系映射⽂件注册到 Hibernate 的配置⽂件中。 5、使⽤ Hibernate API 完成数据操作。 6、pom.xml 中需要配置 resource。 主流 ORM 框架 Object Relation Mapping 对象关系映射，将面向对象映射成面向关系。 如何使用： 1、导⼊相关.
Hibernate一对多条件查询
天才来源于积累
08-07 2024
给出以下三张表:Customer(//顾客表 Id int, Name varchar, ) Order(//订单 Long id, c_id int, Private double ) Family(//家庭 Long id, c_id int, Private address ) Javabean如下： public class Customer implements Serializ
Hibernate（二）——一对多查询
weixin_30216561的博客
04-26 227
1. 前言 本章节我们讨论Hibernate一对多查询的处理。 在上一章节中（Hibernate（一）——入门），我们探讨了Hibernate执行最基本的增删改查操作。现在我们将情况复杂化：加入我们在查询用户信息的时候需要同时查询其登录日志，这样就涉及到一对多查询。那么一对多查询要怎么实现么？ 2. jar包准备 在本节中，除了上一章节中用到...
Hibernate学习之一对多关联
OracleX
08-23 126
注意事项： 1.单向一对多　　 只需在“一”放进行配置2.双向一对多 　　需要在关联双方都加以配置，而且需要在一的一方设置inverse=true 首先是实体类： TAddress.java（多的一方） public class TAddress implements Serializable { private static final long serialVersionU...
hibernate学习资料
10-23
《Hibernate学习之旅：SSH框架中的持久化神器》 在IT领域，SSH（Spring、Struts、Hibernate）被誉为经典的Java Web开发三大框架。其中，Hibernate作为数据持久化工具，以其强大的对象关系映射（ORM）能力，极大地...
Hibernate初之单表映射学习例子
04-17
10. **实体关系映射**：虽然标题提到“单表映射”，但可以扩展讨论到多对一、一对多、多对多等关联关系的映射。 通过这个“Hibernate初之单表映射学习例子”，初学者可以掌握Hibernate的基本操作，为进一步深入学习...
hibernate学习总结文档
12-09
Hibernate 支持多种关联关系，如一对一（OneToOne）、一对多（OneToMany）、多对一（ManyToOne）和多对多（ManyToMany）。关联关系可以通过外键或代理键实现，配置包括懒加载（lazy loading）和级联操作（cascading...
hibernate搭建基础demo
02-01
**hibernate搭建基础demo** Hibernate 是一个强大的Java对象关系映射（ORM）框架，它...通过这个基础，你可以进一步学习更复杂的事务管理、查询优化、缓存机制等高级特性，从而更好地利用Hibernate进行数据库开发。
Hibernate多对多关联添加及查询示例
04-24
Hibernate多对多关联添加及查询示例
hibernate(一对多，多对一映射)操作
07-18
hibernate基于 一对多、多对一映射写的一个增加，查询，删除，修改的demo，内附数据库脚本
Hibernate的一对多的关系查询
Kato_op的博客
05-14 2140
Hibernate的一对多的关系查询 不管一对多还是多对一,在另一个实体类中声明一个实体类对象属性来封装数据, 将查询的多个表的数据封装这个实体类的对象里面，通过配置来说实现。 配置的步骤 创建一个可以存储多个表数据的实体类，实体类根据数据库的关系建立映射关系 在Customer的实体类中添加多一个属性 //将外表的查询数据封装到一个实体类中,然后用一个集合来封装 priv...
Hibernate中的一对多和多对多关系
最新发布
互联说
04-22 858
Hibernate是一个优秀的ORM框架，它简化了Java应用程序与关系型数据库之间的数据访问。在Hibernate中，我们可以使用一对多和多对多的关系来处理复杂的数据模型。本文将介绍Hibernate中的一对多和多对多，包括配置和操作。
Hibernate 超简单的一对多和多对一查询
心疼笔记本
10-10 224
这里使用的Teacher类和Student类（假设一个Teacher对应多个学生，一个学生对应一个老师） 所需jar包 开始建表 1（表名 teacher） 2（表名 student） 主键都为自增长 创建实体类 Teacher类 package com.bright.po; import java.util.Set; public class Teacher { ...
hibernate 一对多自关联查询（如菜单表）
f_1314520的博客
10-25 2095
hibernate 有自带的菜单查询功能，当查询的节点有几千条时，hibernate自带的菜单查询会造成卡顿的情况，但一般情况下hibernate自带的菜单查询减少程序员的代码量， 简化了代码 相关测试数据（MySQL） -- 一对多双向自关联 -- 菜单表 -- t_hibernate_sys_tree_node -- t：表 -- sys：模块名缩写(system) -- tree_noe：表...
Hibernate (超详细一对一，一对多，多对一，多对多)
念念不忘，必有回响
09-27 3637
（一对一，双向关联）对应关系： 一个人对应一个地址 整体路径结构 Person类 public class Person implements Serializable { /** * */ private static final long serialVersionUID = 1L; private Integer personid; private Str...
hql语句：一对多查询
09-07 6834
一对多的查询又包含以下情况： 1、等值连接 2、内连接 3、迫切内连接 4、左外连接 5、迫切左外连接1、等值连接：一对多查询的时候，由于使用的hql语句，是根据类来查询的，所以hql语句这样表示： /** * 等值连接 */ public void Connect_equal(){ Session session=sessionFacto

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值