Hibernate学习笔记-操作部分

最新推荐文章于 2024-08-31 23:40:08 发布
最新推荐文章于 2024-08-31 23:40:08 发布
阅读量192 收藏
点赞数
分类专栏： Java学习 文章标签： mysql hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34059311/article/details/109569347
版权

Hibernate学习笔记-操作部分

教程来自：https://how2j.cn/

  • 使用JDBC做数据库相关功能开发会做很多重复性的工作，比如创建连接，关闭连接，把字段逐一映射到属性中。
    Hibernate把这一切都封装起来了，使得数据库访问变得轻松而简单，代码也更加容易维护。

文章目录

一、Hibernate操作

1. 插入

hibernate的基本步骤是：

  1. 获取SessionFactory
  2. 通过SessionFactory 获取一个Session
  3. 在Session基础上开启一个事务
  4. 通过调用Session的save方法把对象保存到数据库
  5. 提交事务
  6. 关闭Session
  7. 关闭SessionFactory
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import bean.Person;

public class testHibernate {
	public static void main(String[] args) {

		SessionFactory sf = new Configuration().configure().buildSessionFactory();

		Session s = sf.openSession();
		s.beginTransaction();

		Person p = new Person();
		p.setName("郭");
		p.setAge(70);
		s.save(p);

		s.getTransaction().commit();
		s.close();
		sf.close();
	}

}

2. 获取

		Person pGet = (Person) s.get(Person.class, 355);

获取与插入都需要先使用Session开启事务，使用id获取需要知道id，并且需要类对象，获取后需要转型为对应的类。

3. 删除

Person pGet = (Person) s.get(Person.class, 355);
s.delete(pGet);

删除需要先获取id对应的对象。

4. 更新

Person pGet2 = (Person) s.get(Person.class, 532);
pGet2.setName("hahaha");
s.update(pGet);

5. hql查询

		String name = "guo";
		Query q = s.createQuery("from Person p where p.name like ?0");
		q.setParameter(0, "%" + name + "%");
		List<Person> ps = q.list();

查询使用HQL语句，这里进行模糊查询，可以看到查询语句中用的不是表名person而是类名称Person，?0表示插入地点，setParameter函数类似ps.setString。Query对象有list()函数可以返回模糊查询结果列表。

6. criteria查询

暂时没搞懂

7. sql查询

String sql = "select * from person p where p.name like '%" + name + "%'";
Query sqlq = s.createSQLQuery(sql);
List<Object[]> pl = sqlq.list();
for (Object[] os : pl) {
	for (Object o : os) {
		System.out.print(o + "\t");
	}
	System.out.println();
}

结果：
sql查询结果


二、Hibernate关系

实体类对象在Hibernate中有3种状态
分别是瞬时，持久和脱管

瞬时 指的是没有和hibernate发生任何关系，在数据库中也没有对应的记录，一旦JVM结束，这个对象也就消失了
持久 指得是一个对象和hibernate发生联系，有对应的session,并且在数据库中有对应的一条记录
脱管 指的是一个对象虽然在数据库中有对应的一条记录，但是它所对应的session已经关闭了

p.setName("郭");
//此时为瞬时状态
s.save(p);
//此时为持久状态
s.getTransaction().commit();
s.close();
//此时为脱管状态

1. 多对一

准备Category类：

package bean;

public class Category {

	private int id;
	private String name;

	public int getId() {
		return this.id;
	}

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

	public String getname() {
		return this.name;
	}

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

准备Category.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 package="bean">
    <class name="Category" table="category_">
        <id name="id" column="id">
            <generator class="native">
            </generator>
        </id>
        <property name="name" />
    </class>
     
</hibernate-mapping>

这里会自动创建category_表，但必须在hibernate.cfg.xml中添加：

        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

表示使用MySQL55Dialect方言，这样才能自动创建表，并且添加外键的表与外键所在表的字符编码形式应该一样，比如都为utf-8。


为Person类添加Category属性

private Category category;

public Category getCategory() {
	return this.category;
}

public void setCategory(Category category) {
	this.category = category;
}

在Product.hbm.xml中设置Category 多对一关系映射 
<many-to-one name="category" class="Category" column="cid"/>

<?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="bean">
    <class name="Person" table="person">
        <id name="id" column="id">
            <generator class="native">
            </generator>
        </id>
        <property name="name" />
        <property name="age" />
        <property name="IQ" />
        <property name="energy" />
        <many-to-one name="category" class="Category" column="cid"/>
    </class>

</hibernate-mapping>

这里在运行时会自动在person表内创建cid列

2. 一对多

一对多的意思就是一个category对应多个person

在Category类里添加Set<Person>集合属性persons

private Set<Person> persons;
public Set<Person> getPersons() {
	return this.persons;
}

public void setPersons(Set<Person> persons) {
	this.persons = persons;
}

在Category.hbm.xml中添加one-to-many映射 
        <set name="persons" lazy="false">
            <key column="cid" not-null="false"/>
            <one-to-many class="Person"/>
        </set>

<set 用于设置一对多(多对多也是他)关系，也可以用list，设置稍复杂点，这里使用简单的set来入门。
name=“products”   对应 Category类中的persons属性
lazy=“false”  表示不使用延迟加载。关于延迟加载，请参考关系的延迟加载
<key column=“cid” not-null=“false” />  表示外键是cid，可以为空
<one-to-many class=“Product” />  表示一对多所对应的类是Product




测试一对多关系：

package test;

import java.util.Set;

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

import bean.Category;
import bean.Person;

public class testcategory {
	public static void main(String[] args) {
		SessionFactory sf = new Configuration().configure().buildSessionFactory();

		Session s = sf.openSession();
		s.beginTransaction();

//		Category c = new Category();
//		c.setName("c1");
//		s.save(c);
//
//		Person p = (Person) s.get(Person.class, 400);
//		p.setCategory(c);
//		s.update(p);
		Category c = (Category) s.get(Category.class, 2);
		Set<Person> ps = c.getPersons();
		for (Person p : ps) {
			System.out.println(p);
		}
		s.getTransaction().commit();
		s.close();
		sf.close();
	}
}

测试结果：
一对多结果



3.多对多

测试多对多关系
多对多关系相当于一个人可以在各个学校中读小学、初中、高中，每所学校也是各个人的母校，即多对多的关系。many-to-many
要实现多对多关系，必须有一张中间表 person_school 用于维护 Person和School之间的关系

下面是School类，包含name、id、Person集合

package bean;

import java.util.Set;

public class School {
	private int id;
	private String name;
	private Set<Person> persons;

	public String getName() {
		return this.name;
	}

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

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

	public int getId() {
		return this.id;
	}

	public Set<Person> getPersons() {
		return this.persons;
	}

	public void setPersons(Set<Person> persons) {
		this.persons = persons;
	}
}

下面是Person类，包含各个属性以及一个School集合

package bean;

import java.util.Set;

public class Person {
	private String name;
	private int age;
	private int IQ;
	private int energy;
	private int id;
	private Category category;
	private Set<School> schools;

	static String copyright;

	// 使用static修饰代码块时，类对象被JVM被加载时就会执行，
	//且只会加载一次。不加static则会在每次实例化时执行
	static {
		System.out.println("Person类对象初始化 copyright by Arlen");
		copyright = "由Arlen所有权";
	}

	public Person() {

	}

	// 增加一个初始化name的构造方法
	public Person(String name) {

		this.name = name;
	}

	public Person(String name, int age) {

		this.name = name;
		this.age = age;
	}

	public Person(String name, int age, int iq) {

		this.name = name;
		this.age = age;
		this.IQ = iq;
	}

	public String getName() {
		return this.name;
	}

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

	public int getIQ() {
		return this.IQ;
	}

	public void setIQ(int iq) {
		this.IQ = iq;
	}

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

	public int getId() {
		return this.id;
	}

	public int getAge() {
		return this.age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getEnergy() {
		return this.energy;
	}

	public void setEnergy(int energy) {
		this.energy = energy;
	}

	public Category getCategory() {
		return this.category;
	}

	public void setCategory(Category category) {
		this.category = category;
	}

	public Set<School> getSchools() {
		return this.schools;
	}

	public void setSchools(Set<School> schools) {
		this.schools = schools;
	}

添加School.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 package="bean">
    <class name="School" table="school">
        <id name="id" column="id">
            <generator class="native">
            </generator>
        </id>
        <property name="name" />
        
        <set name="persons" table="person_school" lazy="false">
            <key column="sid"/>
            <many-to-many column="pid" class="Person"/>
        </set>
    </class>

</hibernate-mapping>

<set>段设置了映射关系，name属性表示School里的persons集合，table属性表示中间表，lazy表示懒加载。

<key column>设置为’sid’，表示school的主键’id’与中间表中’sid’外键关联。

<many-to-many>段column设置为’pid’，中间表中表示Person的主键’id’与中间表的’pid’外键关联。

在Person.hbm.xml中添加多对多映射

<set name="schools" table="person_school" lazy="false">
    <key column="pid"/>
    <many-to-many column="sid" class="School"/>
</set>

测试中间表

package test;

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

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

import bean.Person;
import bean.School;

public class testManyToMany_School {
	public static void main(String[] args) {
		SessionFactory sf = new Configuration().configure().buildSessionFactory();

		Session s = sf.openSession();
		s.beginTransaction();

		// 增加3个人物
		Set<Person> persons = new HashSet();
		for (int i = 0; i < 3; i++) {
			Person p = new Person();
			p.setName("user" + i);
			persons.add(p);
			s.save(p);
		}

		// 学校1是人物1、2、3的母校
		//School s1 = new School();
	    //s1.setName("HUST");
		//s.save(s1);
		School s2 = (School) s.get(School.class, 1);

		s2.setPersons(persons);
		s.save(s2);
		s.getTransaction().commit();
		s.close();
		sf.close();
	}
}

console结果
多对多console结果
mysql结果
在这里插入图片描述

qq_34059311
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用java代码写一个简单的网上购物车程序
終有、過去
10-30 4万+
需求：1、写一个商品类，有商品编号、商品名称、商品分类、商品单价属性。2、写一个商品条目信息类，有商品和数量两个属性，有商品总价格方法。 3、写一个购物车类，有添加商品方法、查看订单信息，删除商品，修改商品，清空购物车，求购物车中所有商品总金额方法。4、写一个测试类，测试上述方法。 商品类： public class Product { private int productId;// 商
类别(Category)的作用（二）---对私有方法的前向引用
Benson的学习笔记
07-31 4528
在上一篇文章 类别(Category)的作用（一）中，详细说明类别的第一个作用，接下来是类别的第二个作用。类别作用二：创建对私有方法的前向引用。 OC语法中，可以对类的实例变量加@private/@public等关键字进行修饰。但是不能对一个类的方法加@private进行限定，那么OC中如何定义私有方法呢？答案是：定义在类名.h文件中的方法/属性一定是公开的，而在类名.m中的类延展(Extensi
Objective-C中public、protected、private的使用[转]
weixin_30500473的博客
08-11 71
1.@public,@protected,@private个人觉得@public和@protected并没有很明确的区别，在他们作用范围内的对象，如果不将对象设置成@property，则该对象相当于 protected对象，只有子类和本身可以访问该对象；如果将对象设置成@property，则可以使使用者访问该对象。@private，顾名思义， 这里声明的就是私有对象 注：可以通过指针的方式访问。...
利用SpringBoot重写黑马旅游网
小赵的呢
05-26 633
还记得刚开始学习JavaEE的跟着视频做了一个黑马旅游网的小项目,项目本身没啥特点,之后自己部署到了服务器的tomcat上,但是由于里面用到了redis缓存,他的配置文件一直报错,最近寻思这用Spring Boot把他集成进去 ........................
Spring系列教材 （二）- 注入对象
Lan_ht的博客
04-01 126
在上例中，对Category的name属性注入了"category 1"字符串 在本例中 ，对Product对象，注入一个Category对象 步骤1:先运行，看到效果，再学习步骤2:模仿和排错步骤3:Product.java步骤4:applicationContext.xml步骤5:TestSpring 步骤1:先运行，看到效果，再学习 老规矩，先下载下载区(点击进入)的可运...
学习笔记-JPA
2401_84046635的博客
04-21 883
学习技术一定要制定一个明确的学习路线，这样才能高效的学习，不必要做无效功，既浪费时间又得不到什么效率，大家不妨按照我这份路线来学习。大家不妨直接在牛客和力扣上多刷题，同时，我也拿了一些面试题跟大家分享，也是从一些大佬那里获得的，大家不妨多刷刷题，为金九银十冲一波！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！[外链图片转存中…(img-pWB9qj4f-1713640576380)]
hibernate学习笔记之一
qq_43663493的博客
08-29 925
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JavaEE架构中取代CMP，完成数据持久化的重.
Hibernate学习笔记----单向多对一
太匆匆
07-21 805
在我们以前的数据库设计中，设计表就不是一件轻松的事情。多种事物之间往往都是有这样那样的关系的。那怎样设计表格，才能既将事情描述明白，又能使数据库设计的比较合理呢？那里我们提供了好多规范，好多约束来满足这些事情。在hibernate中，通过对象来创建表，当然也需要有一些东西来维护各个对象之间的关系，以创建出合适的表。这个东西就是映射。通过映射，可以轻松的将对象间的关系表述的非常清楚明白。对象间关系搞
Hibernate学习笔记----hbm.xml配置详解
太匆匆
07-20 2844
下面是关系映射文件的部分： 简介版：                                                            较全面版：                type="java.lang.Integer">                                       ">           
Hibernate学习笔记第二部分
08-17
在“Hibernate学习笔记第二部分”中，我们将深入探讨这个强大的工具，特别是针对初学者的基础概念和实践操作。 1. **对象关系映射（ORM）**: ORM是Hibernate的核心特性，它允许开发者使用面向对象的编程方式来处理...
jpa-hibernate-inf-skls-course:Hibernate课程
05-14
5. **CRUD操作**：学习如何使用Hibernate进行创建（Create）、读取（Read）、更新（Update）和删除（Delete）操作，包括HQL和Criteria API的使用。 6. **懒加载和即时加载**：理解Hibernate的懒加载机制，以及何时...
hibernate学习笔记01
08-16
### Hibernate学习笔记01 #### 一、Hibernate简介与安装 **Hibernate** 是一款开源的对象关系映射（Object Relational Mapping, ORM）框架，它能够有效地简化Java应用程序与数据库之间的交互，提供了一种更为优雅...
Hibernate学习笔记
03-22
**Hibernate学习笔记** 在Java开发领域，Hibernate是一个非常重要的对象关系映射（ORM）框架，它简化了数据库操作，使得开发者可以使用面向对象的方式来处理数据。这篇笔记将深入探讨Hibernate的核心概念、工作原理...
MySQL——事务与存储过程（一）事务管理（3）事务的回滚
PAP
08-30 803
MySQL——事务与存储过程（一）事务管理（3）事务的回滚
mysql-day02
m0_64370841的博客
08-29 2269
【代码】mysql-day02。
MySQL 函数、约束、多表查询与事务详解
A_cot的博客
08-30 1731
在 MySQL 数据库中，函数、约束、多表查询和事务是非常重要的概念，它们可以帮助我们更好地管理和操作数据。本文将详细介绍这些概念，并通过代码演示来帮助你更好地理解。
如何在 MySQL 中使用 Socket 身份验证 ？
xiaochong0302的博客
08-31 1445
在 MySQL 和 MariaDB 中，可以使用 socket 身份验证，而不是传统的用户名和密码组合。这种方法既安全又方便，因为它使用的是操作系统的用户凭证。
【MySQL】索引使用规则——（覆盖索引，单列索引，联合索引，前缀索引，SQL提示，数据分布影响，查询失效情况）
最新发布
YYDsis的博客
08-31 1320
一.索引使用规则 ※.验证索引效率提升 1.覆盖索引——查询使用了索引，并且需要返回的列，在该索引中已经全部能够找到2.单列索引＆联合索引3.前缀索引——解决冗长字符串与索引问题【1】前缀索引＆索引选择性的介绍【2】前缀索引创建演示：5.SQL提示——指定某个索引/忽略索引/强制索引 6.数据分布影响——MySQL自我评估7.查询失效的几种情况【1】违背——最左前缀法则(联合索引)【2】范围查询右侧失效【3】用or分割开的条件，or后面没索引，所有索引失效【4】索引列上进行运算操作，索引
Hibernate对象持久化：学习笔记与理解
"Hibernate---我的Hibernate学习笔记" 在软件开发领域，分层思想是常见的架构模式，它将系统分为数据表现层、业务逻辑层和数据持久层。数据表现层主要负责用户界面，业务逻辑层处理应用程序的核心功能，而数据持久...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值