hibernate 03

最新推荐文章于 2021-02-16 04:24:04 发布
最新推荐文章于 2021-02-16 04:24:04 发布
阅读量147 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cdd233333/article/details/80932043
版权

使用HQL查询所有记录

预见结果集

多个就用list处理 

单个就用 uniqueResult

        @Test
	public void fun1() {
		Session session = HibernateUtil.getOpensession();
		Transaction transaction = session.beginTransaction();
		
		String hql = "from com.lanou3g.User";
		Query<User> query = session.createQuery(hql);
		List<User> list = query.list();
		System.out.println(list);
		transaction.commit();
		session.close();
	}
        @Test
	public void fun2() {
		Session session = HibernateUtil.getOpensession();
		Transaction transaction = session.beginTransaction();
		String hql = "from com.lanou3g.User where id = 2";
		Query<User> query = session.createQuery(hql);
		User user = query.uniqueResult();
		System.out.println(user);
		transaction.commit();
		session.close();
	}

使用问号占位符替代 

?从0开始

        @Test
	public void fun3() {
		Session session = HibernateUtil.getOpensession();
		Transaction transaction = session.beginTransaction();
		String hql = "from com.lanou3g.User where id = ?";
		Query<User> query = session.createQuery(hql);
		query.setParameter(0, 2);
		User user = query.uniqueResult();
		System.out.println(user);
		transaction.commit();
		session.close();
	}

使用冒号占位符

冒号后面是占位符的名字

注意 冒号后面不要加空格

替换时 直接使用名字即可

        @Test
	public void fun4() {
		Session session = HibernateUtil.getOpensession();
		Transaction transaction = session.beginTransaction();
		String hql = "from com.lanou3g.User where username = :username and password = :password";
		Query<User> query = session.createQuery(hql);
		query.setParameter("username", "wanglong");
		query.setParameter("password", "123");
		User user = query.uniqueResult();
		System.out.println(user);
		transaction.commit();
		session.close();
	}

分页

        @Test
	public void fun5() {
		Session session = HibernateUtil.getOpensession();
		Transaction transaction = session.beginTransaction();
		String hql = "from User";
		Query<User> query = session.createQuery(hql, User.class);
		query.setFirstResult(0);
		query.setMaxResults(2);
		List<User> list = query.list();
		System.out.println(list);
		transaction.commit();
		session.close();
	}

测试1对多

<?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 package="com.lanou3g">
	<class name="Customer" table="cst_customer">
		<id name="cust_id" column="cust_id">
			<generator class="native"></generator>
		</id>
		<property name="cust_name" column="cust_name"></property>
		<property name="cust_source" column="cust_source"></property>
		<property name="cust_industry" column="cust_industry"></property>
		<property name="cust_level" column="cust_level"></property>
		<property name="cust_linkman" column="cust_linkman"></property>
		<property name="cust_phone" column="cust_phone"></property>
		<property name="cust_mobile" column="cust_mobile"></property>
		<!-- 配置一对多关系 
			name表示实体类对象属性名
			column:两张表联系的外键
			注意:外键名要一致 否则会多建一个外键
			class 与哪个类进行一对多
		-->
		<!-- 级联操作
			作用:简化代码
			cascade 
			sava-update 级联保存和更新
			delete 级联删除
			all		sava-update+delete
			建议 最多使用sava-update
		 -->
		 <!--inverse反转
		 	默认值是false
		 	不放弃维护外键
		 	作用:提高效率的
		 	一对多的表关系
		 	如果要放弃维护外键关系
		 	只能是一的一方放弃
		   -->
		<set name="linkmans" cascade="save-update" inverse="true">
			<key column="lkm_cust_id"></key>
			<one-to-many class="Linkman"/>
		</set>	
	</class>
</hibernate-mapping>
<?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 package="com.lanou3g">
	<class name="Linkman" table="cst_linkman">
		<id name="lkm_id" column="lkm_id">
			<generator class="native"></generator>
		</id>
		<property name="lkm_name" column="lkm_name"></property>
		
		<property name="lkm_gender" column="lkm_gender"></property>
		<property name="lkm_phone" column="lkm_phone"></property>
		<property name="lkm_mobile" column="lkm_mobile"></property>
		<property name="lkm_email" column="lkm_email"></property>
		<property name="lkm_qq" column="lkm_qq"></property>
		<property name="lkm_position" column="lkm_position"></property>
		<property name="lkm_memo" column="lkm_memo"></property>
		<!-- 配置多对一的关系
			name表示多对一对象的属性名
			class表示的是多对一对象的类
			column表示的是外键
			注意:上面在配置properties时不要重复配置外键
		 -->
		<many-to-one name="customer" class="Customer" column="lkm_cust_id"></many-to-one>
	</class>
</hibernate-mapping>
public class Demo02 {
	@Test
	public void fun1() {
		Session session = HibernateUtil.getOpensession();
		Transaction transaction = session.beginTransaction();
		//创建一个客户两个联系人
		//表示客户和联系人的关系
		//将以上添加到数据库中
		Customer customer = new Customer();
		customer.setCust_name("蓝鸥科技");
		Linkman l1 = new Linkman();
		l1.setLkm_name("欣姐");
		Linkman l2 = new Linkman();
		l2.setLkm_name("韦姐");
		Set<Linkman> linkmans = customer.getLinkmans();
		linkmans.add(l1);
		linkmans.add(l2);
		l1.setCustomer(customer);
		l2.setCustomer(customer);
		session.save(customer);
		//session.save(l1);
		//session.save(l2);
		transaction.commit();
		session.close();
		
	}
	//为id为1的客户添加一个联系人
	@Test
	public void fun2() {
		Session session = HibernateUtil.getOpensession();
		Transaction transaction = session.beginTransaction();
		
		Customer customer = session.get(Customer.class, 1);
		Linkman l1 = new Linkman();
		l1.setLkm_name("hh");
		Set<Linkman> linkmans = customer.getLinkmans();
		linkmans.add(l1);
		l1.setCustomer(customer);
		session.save(l1);
		
		
		transaction.commit();
		session.close();
	}
	//删除id为1的客户的id为1的联系人
	@Test
	public void fun3() {
		Session session = HibernateUtil.getOpensession();
		Transaction transaction = session.beginTransaction();
		
		Customer customer = session.get(Customer.class, 1);
		Linkman linkman = session.get(Linkman.class, 1);
		
		Set<Linkman> linkmans = customer.getLinkmans();
		linkmans.remove(linkman);
		linkman.setCustomer(null);
		
		
		
		transaction.commit();
		session.close();
		
	}
}
测试多对多 
<?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 package="com.lanou3g">
<!--配置表与实体类的关系 
	name:实体类全类名
	table:表名
	package:填包名 填上后 底下再写全类名 可以省略包名
 -->
	<class name="User" table="sys_user">
		<id name="user_id" column="user_id">
			<generator class="native"></generator>
		</id>
		<property name="user_code" column="user_code"></property>
		<property name="user_name" column="user_name"></property>
		<property name="user_password" column="user_password"></property>
		<property name="user_state" column="user_state"></property>
		<!-- 配置多对多关系 
			name 容器名字
			table 中间表的名字
			column 中间表引用我的id
		many-to-many class 对应的那个表的类名 
		column  对应那个表外键
		-->
		<!-- 多对多时必须要有一方放弃对外键的维护 -->
		<set name="roles" table="sys_user_role" inverse="true">
			<key column="user_id"></key>
			<many-to-many class="Role" column="role_id"></many-to-many>
		</set>
		
	</class>
</hibernate-mapping>
<?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 package="com.lanou3g">
	<class name="Role" table="sys_role">
		<id name="role_id" column="role_id">
			<generator class="native"></generator>
		</id>
		<property name="role_name" column="role_name"></property>
		<property name="role_memo" column="role_memo"></property>
		
		<!-- 配置多对多关系 
			name 容器名字
			table 中间表的名字
			column 中间表引用我的id
		many-to-many class 对应的那个表的类名 
		column  对应那个表外键
		-->
		<set name="users" table="sys_user_role">
			<key column="role_id"></key>
			<many-to-many class="User" column="user_id"></many-to-many>
		</set>
		
	</class>
</hibernate-mapping>
        @Test
	public void fun1() {
		//创建两个员工
		//创建两个角色 保姆 保镖
		//这两员工 都是保姆也是保镖
		Session session = HibernateUtil.getOpensession();
		Transaction transaction = session.beginTransaction();
		User u1 = new User();
		u1.setUser_name("王龙");
		User u2 = new User();
		u2.setUser_name("王一鸣");
		Role r1 = new Role();
		r1.setRole_name("保姆");
		Role r2 = new Role();
		r2.setRole_name("保镖");
		Set<Role> roles1 = u1.getRoles();
		roles1.add(r1);
		roles1.add(r2);
		Set<Role> roles2 = u2.getRoles();
		roles2.add(r2);
		roles2.add(r2);
		r1.getUsers().add(u1);
		r1.getUsers().add(u2);
		r2.getUsers().add(u1);
		r2.getUsers().add(u1);
		session.save(u1);
		session.save(u2);
		session.save(r1);
		session.save(r2);
		
		transaction.commit();
		session.close();
	}
	//为王龙添加一个新角色
	@Test
	public void fun2() {
		
		Session session = HibernateUtil.getOpensession();
		Transaction transaction = session.beginTransaction();
		User user = session.get(User.class, 1);
		Role role = new Role();
		role.setRole_name("讲师");
		Set<Role> roles = user.getRoles();
		roles.add(role);
		role.getUsers().add(user);
		session.save(user);
		session.save(role);
		
		transaction.commit();
		session.close();
	}
	
	//为王龙删除一个id为3的角色
	@Test
	public void fun3() {
		
		Session session = HibernateUtil.getOpensession();
		Transaction transaction = session.beginTransaction();
		User user = session.get(User.class, 1);
		Role role = session.get(Role.class, 3);
		user.getRoles().remove(role);
		role.getUsers().remove(user);
		
		
		
		transaction.commit();
		session.close();
	}











CddCddCddCddCddCdd
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ssh框架之hibernate--hibernate环境的搭建（Ⅱ 配置实体类和数据库表的映射关系）
Leo的博客
05-26 1912
ssh框架之hibernate--hibernate环境的搭建（Ⅱ 配置实体类和数据库表的映射关系）1. 创建xml格式的配置文件映射配置文件名称和位置没有固定要求。建议：位置：在实体类所在包里面创建；名字：实体类名称.hbm.xml。2. 配置是xml格式，在配置文件中首先引入xml约束。&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;!DOCT...
Hibernate 设置表与表关系
wltulongdao001的博客
04-10 260
一对多表 明确表中字段和表的主从关系分析实体类中的属性。 编写实体类 实例： 编写客户实体类和联系人实体类 客户与联系人是一对多的关系 private Long cust_id; private String cust_name; private String cust_source; private String cust_industry; priv...
论Hibernate的实体与表间的关系…
Osheep-昔日暖阳
03-29 1524
一对一关系映射：（xml配置版） ---->>>:外表主键即为外键也为主键，主表主键值和外键主键值一至，外表依赖主表产生记录。 stuff 多对一关系映射：（xml配置版） ---->>>:外表主键即为外键也为主键，主表主键值和外键主键值一至，外表依赖主表产生记录。 "http://hiberna
hibernate的对象与数据库表的映射
zhang__liuchen的博客
03-12 1183
Customer.java /** * 客户管理的实体类 * @author zhang *CREATE TABLE `cst_customer` ( `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)', `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名...
Hibernate框架复习11-hibernate多表实体类与映射文件配置（步骤）
04-20 236
第一步 创建好数据库表，以及配置好表的外键联系 第二步 在工程中创建好pojo类，注意数据类型要和数据库中的对应 第三步 创建好实体类的映射文件，并配置好基本字段的映射关系（这个时候不要配置外键，外键单独配置） 第四步 维护pojo类中的对象关系，在一对多的一的表中创建集合（一般是set集合）维护关系，在一对多关系的多中创建一的对象维护关系 第五步 在映射配置文件中配置多表之间的...
hibernate03笔记.pdf
最新发布
11-28
hibernate03笔记.pdf
3.Hibernate 03 表关系详细教案1
08-04
在本教程中，我们将深入探讨Hibernate中的表关系映射，这是ORM（对象关系映射）框架的核心特性之一。Hibernate允许开发者以面向对象的方式处理数据库操作，简化了数据访问层的编程工作。 1. Hibernate表关系映射...
hibernate_03
09-09
《Hibernate_03》 本资源包主要涵盖了Hibernate框架的第三章源码，是学习和深入理解Hibernate不可或缺的一部分。Hibernate作为一个强大的对象关系映射（ORM）框架，它极大地简化了Java开发者与数据库之间的交互，...
hibernate_day03笔记
12-22
hibernate_day03笔记
hibernate03:多对一单向关联、多对一双向关联
08-12
在Java世界中，Hibernate是一个非常流行的ORM（对象关系映射）框架，它允许开发者将数据库操作转换为面向对象的方式，从而简化了数据访问。本文主要探讨的是Hibernate中的两种关联关系：多对一单向关联和多对一双向...
Hibernate(2)实体对象
qq_38125626的博客
07-22 141
目录 一、.Hibernate实体的创建规则 二、hibernate主键生成策略 三、hibernate对象状态 四、hibernate一级缓存 五、指定hibernate操作数据库的隔离级别 六、hibernate中的事务控制 一、.Hibernate实体的创建规则 1.持久化类需要提供无参的构造方法 2.持久化类的属性需要私有，对私有的属性提供共有的get和...
Hibernate常见误区——正确区分值对象和实体对象
SpringsSpace
02-08 199
声明：该部分内容参考http://blog.csdn.net/gudong2945/article/details/7050196         值对象和实体对象是Hibernate的重要概念，当然在jpa中也有相应的概念,他们在语义上是相同的。常常听 到人们抱怨Hibernate中对象之间的映射关系配置很难，而且经常出现一些莫名奇妙的问题。其真正原因是没有 正确的区分值对象和实体对象而...
java hibernate 表关联_Hibernate多表关联查询讲解
weixin_31016735的博客
02-16 926
本文向大家介绍Hibernate多表关联查询，可能好多人还不了解Hibernate多表关联查询，没有关系，看完本文你肯定有不少收获，希望本文能教会你更多东西。一、Hibernate简介Hibernate是一个JDO工具它的工作原理是通过文件(一般有两种：xml文件和properties文件)把值对象和数据库表之间建立起一个映射关系。这样，我们只需要通过操作这些值对象和Hibernate提供的一些基...
hibernate 之 表与表之间的关系
weixin_41974635的博客
10-29 218
表与表之间的关系 一对多 商品和商品类别（一个类别有多个商品） 客户和联系人属于一对多的关系 外键添加在多的一方 多对多 订单和商品关系（一个订单里面有多个商品，一个商品属于多个订单） 用户和角色属于多对多关系 多对多建表，需要创建第三张表（至少有两个字段作为外键，指向两个表的主键） 一对一 妻子和丈夫 hibernate一对多操作 （1）一对多映射配置 第一步：创建实体类，客户和联系人 第二部：让两个实体类之间互相表示 （1）在客户实体类里面表示多个联系人 //h
Hibernate 实体对象的识别
javacoffe的专栏
07-13 3118
 实体对象的识别：   在基本的Java编程中，对象的识别也是一个必须要面对的问题，在Java中可以通过”==”运算符来判断两个对象是否具有相同的引用，还可以通过从根类Object继承而来的”equals()”方法，来判断两个对象的值是否相等。基于这两个Java提供的工具，我们可以轻松的判断两个对象的差别，但是在面对持久化逻辑时，这两个工具就遇到了它爱莫能助的新问题，比如我们现在有两个实体
Java框架 Hibernate入门笔记三 对象状态和表间关系
qq_33982232的博客
02-19 155
一.Hibernate中的对象的三种状态 实体类对象在Hibernate中有3种状态 分别是瞬时，持久和脱管 瞬时 指的是没有和hibernate发生任何关系，在数据库中也没有对应的记录，一旦JVM结束，这个对象也就消失 持久 指得是一个对象和hibernate发生联系，有对应的session,并且在数据库中有对应的一条记录 脱管 指的是一个对象虽然在数据库中有对应的一条记录，但是它所对应的ses...
Hibernate笔记整理1（几种对象和配置文件）
weixin_42260782的博客
09-08 125
虽然这个框架现在用的很少了，但是还是回头总结一下，把代码，配置之类的笔记贴过来，以后需要回头看一下也是不错的 Configuration对象 //Configuration功能：配置加载类，用于加载主配置，orm元数据加载 public class Demo { @Test //保存客户 public void fun1(){ //1创建，调用空参构造 Configuration conf=new Configuration(); //2读取指定配置文件=> 空参加载方法，加载src
JavaWeb框架复习笔记-Hibernate（表与表之间的关系）
廖子默
07-11 206
一对多 就比如一个员工属于一个公司，而一个公司有很多员工。 多对多 就比如用户和角色之间的关系，一个用户可以是多种角色，一种角色也可以有多种用户 实现一对多的流程 1.创建相应的实体类 2.让两个实体类互相表示他们的关系 3.生成他们的映射文件 先生成最基本的映射关系 接下来配置表与表之间的关联 4.创建hibernate核心配置文件，将映射文件引入 5.写个测试类测试一下表...
hibernate基本的配置-xml(实体映射)和简单使用
liangwenrong的博客
03-09 2966
hibernate基本配制简单使用
Hibernate: Association与Collection映射详解
本资源聚焦于Hibernate中的关联（Association）和集合映射（Collection Mapping），是03-Hibernate系列教程的一部分。由知名作者和开发者开发，提供深入讲解和实例，主要针对Java Enterprise Edition (Java EE) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值