Hibernate框架笔记

最新推荐文章于 2022-09-05 00:29:31 发布
原创 最新推荐文章于 2022-09-05 00:29:31 发布 · 460 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Hibernate #持久层框架 #java web访问数据库

本文详细介绍了Hibernate框架的基础概念、配置方法及一对一、一对多、多对多的关联配置。此外还展示了如何通过Hibernate进行数据的增删查改操作，并提供了分页查询的实战案例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Hibernate框架基础

概述

Hibernate框架是持久层的框架，让我们只需在框架配置文件中配置驱动、数据库用户、密码、需要连接的数据库名等就可以连接Mysql、Oracle等就可以自动连接、访问数据库，不需要再用JDBC，方便项目的移植。Hibernate可以通过映射文件（后缀为.hbm.xml）配置表与对象的映射关系，因此可以通过此框架我们可以方便地通过操作对象的方式来增删查改数据库。

Hibernate至少需要的jar包

在这里插入图片描述
其中mysql-connector-java-5.1.46.jar是Mysql数据库的驱动，不同的数据库用不同的驱动

Hibernate框架总配置文件

默认的总配置文件是在src文件夹下的hibernate.cfg.xml。（eclipse在编译时会表src下的xml文件放到字节码文件所在目录）

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property><!--不同数据库用不同驱动-->
        <property name="connection.url">
        	jdbc:mysql://localhost:3306/要连接的数据库
        </property>
        <property name="connection.username">root</property>
        <property name="connection.password">这里写密码</property>
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hbm2ddl.auto">update</property><!--加载时自动根据映射文件更新表结构-->
        <property name="hibernate.show_sql">true</property><!--调试时输出sql执行语句-->
        <mapping resource="t/Test.hbm.xml"/><!--映射文件位置-->
    </session-factory>
</hibernate-configuration>

在连接的数据库应该事先建好，但表不用建。
property name="hbm2ddl.auto"标签值为update表示hibernate启动时根据映射文件更新数据库，原来的列不会删除。

持久化对象

先说一下术语
PO：持久化对象，与数据库的一张表对应，其中的属性对应表各个列（字段）的数据类型。
VO：持久化视图对象，与数据库的一张视图对应，其中的属性对应视图各个列的数据类型。
以上对象一般都是JavaBean，JavaBean的规范是属性应是private，再分别设置public的setter和getter方法。
类需要对应的映射文件才能与数据库的表或视图产生关系。

Hibernate映射文件

后缀为.hbm.xml，一般与对应的类文件放在一起，文件名一般与对应的类名相同，映射文件需要在总配置文件中指定其位置才能被框架读取。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 注意包名。不写的话下面要写全限定名 -->
<hibernate-mapping package="t">
    <!-- 类名对应表名 -->
    <class name="Test">
        <!-- 主键使用id标签。然后对应属性名与列名 -->
        <id name="id" type="int" column="id">
            <!-- 自增长主键不同数据库有不同类型的自增长类型 -->
            <generator class="increment"></generator>
        </id>
        <!-- 非主键映射关系，注意类型并不是单纯的java类型也不是数据库类型，而是一种hibernate中间类型，注意大小写特别是String在这里开头要小写 -->
        <property name="t" type="string"/>
    </class>
</hibernate-mapping>

generator class="increment"表示自增长方式生成主键,native表示让框架自动决定主键生成策略。
如果主键由用户指定，则不配置generator标签。

Hibernate，Java，SQL映射关系
【1】常见的映射关系表

Hibernate映射类型Java类型标准SQL类型字节大小
integer/intjava.lang.Integer/intINTEGER4Byte
longjava.lang.Long/longBIGINT8Byte
shortjava.lang.Short/shortSMALLINT2Byte
bytejava.lang.Byte/byteTINYINT1Byte
floatjava.lang.Float/floatFLOAT4Byte
doublejava.lang.Double/doubleDOUBLE8Byte
big_decimaljava.math.BigDecimalNUMERIC
characterjava.lang.Character/java.lang.String/charCHAR定长字符
stringjava.lang.StringVARCHAR变长字符
boolean/yes_no/true_falsejava.lang.Boolean/booleanBIT布尔类型
datejava.util.Date/java.sql.DateDATE日期
timejava.util.Date/java.sql.TimeTIME时间
timestampjava.util.Date/java.util.TimestampTIMESTAMP日期
calendarjava.util.CalendarTIMESTAMP日期
calendar_darjava.util.CalendarDATE日期
binarybyte[]BLOBBLOB
textjava.lang.StringCLOBCLOB
serializable实现java.io.Serializable接口的任意Java类BLOBBLOB
clobjava.sql.ClobCLOBCLOB
blobjava.sql.BlobBLOBBLOB
classjava.lang.ClassVARCHAR定长字符
localejava.util.LocaleVARCHAR定长字符
timezonejava.util.TimeZoneVARCHAR定长字符
currencyjava.util.CurrencyVARCHAR定长字符

【2】Java时间和日期类型的Hibernate映射

映射类型Java类型标准SQL类型描述(java中表示)
datejava.util.Date/java.sql.DateDATE日期：yyyy-MM-dd
timejava.util.Date/java.sql.TimeTIME时间 :HH:mm:ss
timestampjava.util.Date/java.util.TimestampTIMESTAMP日期和时间：yyyy-MM-dd HH:mm:ss
calendarjava.util.CalendarTIMESTAMP同上
calendar_darjava.util.CalendarDATE日期：yyyy-MM-dd

一对一、一对多、多对多的配置

对于一对多配置保证了参照完整性，对于多对多，需要新建一张表来表示他们的关系。

一对一配置

比如Person（人）和Id_Card（身份证）是一对一的关系

单向一对一外键关联

Id_Card单向依赖于Person
此方式生成的表会有外键约束，而共享主键方式则没有。
这是一种特殊的一对多关系，只是增加了一个unique属性。这样就指定了这端为一了。
Person.java:

public class Person {//与ID_Card为一对一关系
	private int id;
	private String name;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

Person.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 注意包名。不写的话下面要写全限定名 -->
<hibernate-mapping package="t">
    <class name="Person">
        <id name="id" type="int" column="id">
            <generator class="native"></generator>
        </id>
        <property name="name" type="string"/>
    </class>
</hibernate-mapping>

Id_Card.java:

public class Id_Card {//与Person是一对一关系
	private int id;
	private String cardNum;
	private Person person;//指定其对应的Person
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getCardNum() {
		return cardNum;
	}
	public void setCardNum(String cardNum) {
		this.cardNum = cardNum;
	}
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
}

Id_Card.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 注意包名。不写的话下面要写全限定名 -->
<hibernate-mapping package="t">
    <class name="Id_Card">
        <id name="id" type="int" column="id">		
        	<generator class="increment"></generator>
        </id>
        <property name="cardNum" type="string"/>
        <!--跟多对一一样，只是增加了一个unique属性。这样就指定了这端为一了。-->
        <many-to-one name="person" class="Person" column="pid" unique="true"></many-to-one>
    </class>
</hibernate-mapping>

插入记录:

Person person=new Person();
Id_Card id_Card=new Id_Card();
id_Card.setPerson(person);
session.save(person);
session.save(id_Card);

单向共享主键方式（推荐）

Id_Card单向依赖于Person，表示在插入Id_Card记录时必须先指明对应的Person。
此方式生成的表没有外键约束
其实用框架访问数据库的话没有外键约束也没什么影响

Person.java:

public class Person {//与ID_Card为一对一关系
	private int id;
	private String name;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

Person.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 注意包名。不写的话下面要写全限定名 -->
<hibernate-mapping package="t">
    <class name="Person">
        <id name="id" type="int" column="id">
            <generator class="native"></generator>
        </id>
        <property name="name" type="string"/>
    </class>
</hibernate-mapping>

Id_Card.java:

public class Id_Card {//与Person是一对一关系
	private int id;
	private String cardNum;
	private Person person;//指定其对应的Person
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getCardNum() {
		return cardNum;
	}
	public void setCardNum(String cardNum) {
		this.cardNum = cardNum;
	}
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
}

Id_Card.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 注意包名。不写的话下面要写全限定名 -->
<hibernate-mapping package="t">
    <class name="Id_Card">
        <id name="id" type="int" column="id">
        <!-- 指定id为外键 -->
            <generator class="foreign">
            	<param name="property" >person</param><!-- 外键指向person属性 -->
            </generator>
        </id>
        <property name="cardNum" type="string"/>
        <!-- name指定属性名,class指定类名 -->
        <one-to-one name="person" class="Person"></one-to-one>
    </class>
</hibernate-mapping>

表结构：
person表
Person
id_card表
在这里插入图片描述
插入Person和Id_Card记录:

			Person person=new Person();
			Id_Card id_Card=new Id_Card();
			id_Card.setPerson(person);//指定对应的person
			session.save(person);
			session.save(id_Card);

在插入id_Card前需要指定对应的person才能插入成功
插入成功:
在这里插入图片描述

双向共享主键方式

双向共享方式在插入一条Person记录前必须指定对应的Id_Card,在插入Id_Card前必须指定对应的Person
Person:

public class Person {//与ID_Card为一对一关系
	private int id;
	private String name;
	private Id_Card id_Card;//指定对应的ID_Card
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Id_Card getId_Card() {
		return id_Card;
	}
	public void setId_Card(Id_Card id_Card) {
		this.id_Card = id_Card;
	}
}

Person.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 注意包名。不写的话下面要写全限定名 -->
<hibernate-mapping package="t">
    <class name="Person">
        <id name="id" type="int" column="id">
            <generator class="native"></generator>
        </id>
        <property name="name" type="string"/>
        <!-- name指定属性名,class指定类名 -->
        <one-to-one name="id_Card" class="Id_Card"></one-to-one>
    </class>
</hibernate-mapping>

Id_Card:

public class Id_Card {//与Person是一对一关系
	private int id;
	private String cardNum;
	private Person person;//指定其对应的Person
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getCardNum() {
		return cardNum;
	}
	public void setCardNum(String cardNum) {
		this.cardNum = cardNum;
	}
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
}

Id_Card.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 注意包名。不写的话下面要写全限定名 -->
<hibernate-mapping package="t">
    <class name="Id_Card">
        <id name="id" type="int" column="id">
        <!-- 指定id为外键 -->
            <generator class="foreign">
            	<param name="property" >person</param><!-- 外键指向person属性 -->
            </generator>
        </id>
        <property name="cardNum" type="string"/>
        <!-- name指定属性名,class指定类名 -->
        <one-to-one name="person" class="Person"></one-to-one>
    </class>
</hibernate-mapping>

插入Person和Id_Card记录:

			Person person=new Person();
			Id_Card id_Card=new Id_Card();
			person.setId_Card(id_Card);//指定对应的id_Card
			id_Card.setPerson(person);//指定对应的person
			session.save(person);
			session.save(id_Card);

双向共享主键方式在插入前需要分别指定对应的id_Card、person才能被插入
插入成功:
在这里插入图片描述

一对多配置

比如Class（班级）和Student（学生）是一对多关系
生成的学生表中有一个外键指向班级的主键，以标识学生属于哪个班级
新建Class类：
Class.java：

public class Class {//与Student是一对多关系
	private int cid;
	private String cname;
	//用集合表示班级包含了哪些学生
	private Set<Student> students = new HashSet<Student>();
	
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	public int getCid() {
		return cid;
	}
	public void setCid(int cid) {
		this.cid = cid;
	}
	public String getCname() {
		return cname;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}
}

新建Student类：

public class Student {//与Class是多对一的关系
	private String sno;//主键
	private String sname;
	//指定学生属于哪个班级
	private Class class1;
	public String getSno() {
		return sno;
	}
	public void setSno(String sno) {
		this.sno = sno;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public Class getClass1() {
		return class1;
	}
	public void setClass1(Class class1) {
		this.class1 = class1;
	}
}

Class类配置文件：
Class.hbm.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 注意包名。不写的话下面要写全限定名 -->
<hibernate-mapping package="t">
	 <!--一,主键属性  -->
    <class name="Class">
        <id name="cid" type="int" column="cid">
            <generator class="native"></generator>
        </id>
        <!-- 二,其它属性 -->
        <property name="cname" type="string"/>
        <!-- 三,集合属性,表示和学生的关系 -->
        <set name="students">
            <!--3.2 生成的Student表需要一个外键指向他的班级的主键,key的 column表示Student表的外键名 -->
            <key column="cid"/>
            <!--3.3 one-to-many的class属性指定多方的类名  -->
            <one-to-many class="Student"/>
        </set>
    </class>
</hibernate-mapping>

Student类配置文件：
Student.hbm.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 注意包名。不写的话下面要写全限定名 -->
<hibernate-mapping package="t">
    <class name="Student">
        <id name="sno" type="string" column="sno"></id><!-- 主键在插入时指定 -->
        <property name="sname" type="string"/>
         <!-- 表示和分类的关系 -->
        <!--3.1name:一的一方对象的名字
              class: 一的一方类名
              column:外键的名字
          -->
        <many-to-one name="class1" class="Class" column="cid"/>
    </class>
</hibernate-mapping>

插入班级和学生记录：

			Class class1=new Class();
			class1.setCname("一班");
			Student student=new Student();
			student.setClass1(class1);
			student.setSno("001");
			student.setSname("张三");
			session.save(class1);
			session.save(student);

插入成功：
在这里插入图片描述
在插入学生记录之前需要指定其班级才能插入成功。

一对多级联删除

当删除Class记录时自动删除对应的所有学生记录的外键（对应外键变成null值）
只需在Class.hbm.xml的set标签加上属性:

cascade="delete"

Class.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 注意包名。不写的话下面要写全限定名 -->
<hibernate-mapping package="t">
	 <!--一,主键属性  -->
    <class name="Class">
        <id name="cid" type="int" column="cid">
            <generator class="native"></generator>
        </id>
        <!-- 二,其它属性 -->
        <property name="cname" type="string"/>
        <!-- 三,集合属性,表示和学生的关系 -->
        <set name="students" cascade="delete">
            <!--3.2 生成的Student表需要一个外键指向他的班级的主键,key的 column表示Student表的外键名 -->
            <key column="cid"/>
            <!--3.3 one-to-many的class属性指定多方的类名  -->
            <one-to-many class="Student"/>
        </set>
    </class>
</hibernate-mapping>

Student映射文件不变
删除之前:
class表
在这里插入图片描述
student表
在这里插入图片描述
删除班级记录：

			Class class1=new Class();
			class1.setCid(3);
			session.delete(class1);

删除后：
class表：

在这里插入图片描述
student表：
在这里插入图片描述

多对多配置

多对多关系不仅需要两种表分别描述两个实体，还要一张表来描述他们的关系。

中间表无其他属性

比如学生（Student）和课程（Course）是多对多关系s_c表描述一个学生选了哪些课程。
Student.java:

public class Student {//与Class是多对一的关系
	private String sno;//主键
	private String sname;
	//指定学生属于哪个班级
	private Class class1;
	//指定学生选了哪些课
	private Set<Course> courses=new HashSet<Course>();
	
	public String getSno() {
		return sno;
	}
	public void setSno(String sno) {
		this.sno = sno;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public Class getClass1() {
		return class1;
	}
	public void setClass1(Class class1) {
		this.class1 = class1;
	}
	public Set<Course> getCourses() {
		return courses;
	}
	public void setCourses(Set<Course> courses) {
		this.courses = courses;
	}
}

Student.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 注意包名。不写的话下面要写全限定名 -->
<hibernate-mapping package="t">
    <class name="Student">
        <id name="sno" type="string" column="sno"></id><!-- 主键在插入时指定 -->
        <property name="sname" type="string"/>
         <!-- 表示和班级的关系 -->
        <!--  name:一的一方对象的名字
              class: 一的一方类名
              column:外键的名字
          -->
        <many-to-one name="class1" class="Class" column="cid"/>
        <!-- 表示和课程的关系 -->
        <!--     set标签的name属性:当前类中集合的名字 
                 table:关系的表名
        -->
       <set name="courses" table="s_c">
            <!--  key的 column表示当前类在关系表中的外键 -->
            <key column="sno" />
                <!--many-to-many表示多对多关系
                   column:表示另一方在关系表中的外键
                   class:表示另一方类名
             -->
            <many-to-many column="cno" class="Course" ></many-to-many>
        </set>
    </class>
</hibernate-mapping>

Course.java:

public class Course {
	private String cno;
	private String cname;
	public String getCno() {
		return cno;
	}
	public void setCno(String cno) {
		this.cno = cno;
	}
	public String getCname() {
		return cname;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}
	
}

Course.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 注意包名。不写的话下面要写全限定名 -->
<hibernate-mapping package="t">
    <class name="Course">
        <id name="cno" type="string" column="cno"></id><!-- 主键在插入时指定 -->
        <property name="cname" type="string"/>

    </class>
</hibernate-mapping>

中间表有其他属性

比如学生（Student）和课程（Course）是多对多关系，成绩表描述他们之间的关系和学生每门课成绩。
学生表（学号，姓名,…）
课程表（课程编号，课程名，…）
成绩（学号，课程编号，成绩,…）
此时就要新建Student、Course、Grade类，并分别进行映射文件配置。配置Student与Grade为多对一关系，Grade与Course为一对多关系。

DAO层对数据的操作(增删查改)

生成session对象

java访问数据库通过session对象，session表示java通过hibernate与数据库的一次会话，当操作数据完成时应关闭session，以提高效率，防止内存溢出。以下是生成session对象及关闭的代码。
HibernateUtil.java：

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

public class HibernateUtil {
	private static SessionFactory sessionFactory;
	private HibernateUtil() {
		// TODO Auto-generated constructor stub
	}
	static {
		Configuration cfg = new Configuration();
		cfg.configure();
		sessionFactory = cfg.buildSessionFactory();
	}
	
	public static Session getSession() {
		Session session = sessionFactory.openSession();
		return session;
	}
}

通过此方法创建和关闭session,避免多线程共享数据的问题。

增加数据

  • 操作对象方式增加
		session = HibernateUtil.getSession();
		transaction = session.beginTransaction();//事务开始
		session.save(test);//增加数据
		transaction.commit();//事务提交
		HibernateUtil.closeSession();

test是一个持久化对象,hibernate会根据持久化对象的主键与数据库中存在的主键确定是增加还是修改.
事务提交表示原子操作完成,提交后数据不可回滚,事务操作是数据库系统提供的功能.

  • 通过HQL语句实现
    增加就不要用hql实现了.
    修改:
			tx=session.beginTransaction();
			//session.save(test);
			Query query=session.createQuery("update Test tt set tt.str=:utest where tt.id=:uid");
			query.setParameter("utest", "aa");
			query.setParameter("uid", 1);
			query.executeUpdate();
			tx.commit();

Test是持久化的类名,而不是表名.
HQL与SQL的一个不同就是HQL指定的是类及其对象,而SQL指定的是表和表的列.

修改数据

		session = HibernateUtil.getSession();
		transaction = session.beginTransaction();//事务开始
		session.update(test);//修改数据
		transaction.commit();//事务提交
		HibernateUtil.closeSession();

删除数据

  • 操作对象方式实现
		Transaction transaction = null;
		session = HibernateUtil.getSession();
		transaction = session.beginTransaction();
		session.delete(test);//删除数据
		transaction.commit();
		HibernateUtil.closeSession();
  • 通过HQL语句删除
			tx=session.beginTransaction();
			Query query=session.createQuery("delete from Test tt where tt.id=:uid");
			query.setParameter("uid", 1);
			query.executeUpdate();//执行hql语句
			tx.commit();

执行增加,删除,修改HQL语句用executeUpdate(),查询用list().

查询数据

  • session通过主键查询
Test test2 = (Test) session.get(Test.class, obj);

Test是持久化对象类
obj即为要查询的主键值

  • HQL语句通过条件实现查询
			Query query=session.createQuery("from Test tt where tt.id=:参数");
			query.setParameter("参数", obj);
			List<Test> tests = query.list();

HQL可省略select.
如果没有where限定则查询所有
查询不需要事务操作.

Hibernate分页

hibernate框架的Criteria类提供了分页功能，只需要告知hibernate从哪一行开始、最大行数即可返回页面所需的数据。

实现

实现创建Page类保存当前页码、每页记录数、总页数、总记录数等信息。如果不想封装也可跳过此步。

Page.java:

public class Page {
	/**
	 * @param perPageRows 每页行数
	 */
	
	private Integer currentPage=1;//当前页,默认为第一页
	private Integer perPageRows=3;//每页的记录数,默认为3
	private Integer totalRows;//总记录数：
	private Integer totalPages;//总页数：
	
	public Integer getCurrentPage() {
		return currentPage;
	}
	public void setCurrentPage(Integer currentPage) {
		this.currentPage = currentPage;
	}
	public Integer getPerPageRows() {
		return perPageRows;
	}
	public void setPerPageRows(Integer perPageRows) {
		this.perPageRows = perPageRows;
	}
	public Integer getTotalRows() {
		return totalRows;
	}
	public void setTotalRows(Integer totalRows) {
		this.totalRows = totalRows;
	}
	public Integer getTotalPages() {
		//计算总页数
		totalPages=totalRows%perPageRows==0?totalRows/perPageRows:totalRows/perPageRows+1;
		return totalPages;
	}
	public void setTotalPages(Integer totalPages) {
		this.totalPages = totalPages;
	}
}

获取对应页面数据

			Criteria criteria=session.createCriteria(Test.class);//设置要查询的持久化对象
			//每页开始的索引数在hibernate中的计算公式是：(currentPage-1)*perPageRows
			criteria.setFirstResult((currentPage-1)*perPageRows);//设置开始查找的行数
			criteria.setMaxResults(perPageRows);//设置最大查找的行数
			@SuppressWarnings("unchecked")
			List<Test> tests = criteria.list();//获取页面数据

其中Test是持久化对象
实际开发中currentPage提供客户端的请求参数获取
以上代码一般封装在DAO层的方法中

案例（对News持久化对象的分页）

首先新建DAO类：
News.java:

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;

import PO.News;

public class NewsDAO {
	
	@SuppressWarnings("unchecked")
	public List<News> findAll() {
		// TODO Auto-generated method stub
		Session session=HibernateUtil.getSession();
		List<News> news;
		Query query = session.createQuery("from News");
		news=query.list();
		session.close();
		return news;
	}
	/**
	 * 
	 * @param currentPage    当前页码
	 * @param pageSize	     页码大小,每页多少行数据
	 * @return			     当前页的数据集合
	 */
	public List<News> findPageList(int currentPage,int pageSize){
		Session session=HibernateUtil.getSession();
		Criteria criteria=session.createCriteria(News.class);
		criteria.setFirstResult((currentPage-1)*pageSize);
		criteria.setMaxResults(pageSize);
		@SuppressWarnings("unchecked")
		List<News> news = criteria.list();
		session.close();
		return news;
	}
}

显示的页面:

<%@page import="java.util.LinkedList"%>
<%@page import="java.util.List"%>
<%@page import="DAO.NewsDAO"%>
<%@page import="PO.News"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<%
String strc=request.getParameter("currentPage");
int currentPage,pageCount,pageSize=3;
NewsDAO newsDAO=new NewsDAO();
int rows=newsDAO.findAll().size();
pageCount=rows%pageSize==0?rows/pageSize:rows/pageSize+1;//计算总页数
if(strc==null){//设置当前页码
	currentPage=1;
} else {
	currentPage = Integer.parseInt(strc);	
}
//System.out.print(currentPage);
List<News> news=newsDAO.findPageList(currentPage, pageSize);//获取当前页的数据
List<String> titles = new LinkedList<String>();
for(News tnews:news){
	titles.add(tnews.getTitle());
}
pageContext.setAttribute("titles", titles);
pageContext.setAttribute("currentPage", currentPage);
pageContext.setAttribute("pageCount", pageCount);
%>
<c:forEach items="${titles }" var="strTi">
<div>${strTi }</div>//页码输出数据
</c:forEach>
<a href="pages.jsp?currentPage=1">第一页</a>
<c:if test="${currentPage!=1 }">
<a href="pages.jsp?currentPage=${currentPage-1 }">上一页</a>
</c:if>
<c:if test="${currentPage!=pageCount }">
<a href="pages.jsp?currentPage=${currentPage+1 }">下一页</a>
</c:if>
<a href="pages.jsp?currentPage=${pageCount }">最后页</a>
</body>
</html>
Hibernate框架学习笔记
qq_38396292的博客
07-17 339
1、什么是框架？ 框架就是一个半成品的项目，提高开发效率 PS：不必纠结于框架本身的实现，只要学会如何使用这个框架即可。 2、什么是Hibernate框架？ 这个框架应用于DAO层 实体类和数据表之间建立了联系，通过操作对象，直接对数据库进行修改。 简介 Hibernate的优点及好处： Hibernate对jdbc 访问数据库的代码做了轻量...
hibernate框架笔记
08-16
### Hibernate框架知识点详解 #### 一、Hibernate框架简介 Hibernate是一个开源的对象关系映射（Object-Relational Mapping，简称ORM）框架，它为Java应用程序提供了强大的数据库交互能力。通过使用Hibernate，...
Hibernate框架的学习笔记
海棠花未眠的博客
07-30 309
前言 学习java当然离不开对于java框架的学习了，其中在江湖很有名气的 ssh（spring+struts2+Hibernate），早想迫不及待的认识他们了，那 么，现在我也记录以下此次学习Hibernate的过程。 什么是Hibernate? 　轻量级JavaEE应用的持久层框架，是一个完全的ORM框架。(说完这句话，肯定有很多人懵圈了，下面我来一个个解释) 　持...
探索Java后端开发: Struts2与Hibernate框架笔记
该文档是关于Hibernate框架的学习笔记，内容可能包括以下几个方面： 1. ORM的基本概念和Hibernate框架简介。 2. Hibernate的配置、Session管理以及事务控制。 3. 映射文件的编写规则与注解的使用。 4. 查询HQL语言...
hibernate框架开发2016版视频 四天学习笔记完整版
04-18
【hibernate框架开发2016版视频 四天学习笔记完整版】 在软件开发领域，特别是Java Web开发中，Hibernate是一个非常重要的对象关系映射（ORM）框架，它极大地简化了数据库操作，使开发者可以更专注于业务逻辑而不是...
hibernate框架学习笔记整理
03-16
### hibernate框架学习笔记整理 #### 一、Hibernate框架简介 **Hibernate框架**是一种用于Java应用的**对象关系映射**(Object-Relational Mapping, ORM)解决方案，它允许开发者使用面向对象的方式操作数据库中的表...
Hibernate框架学习笔记（一）
沉浮于世的博客
07-19 326
1.Hibernate概述：应用于javaee三层框架中的dao层框架，对数据库进行crud操作。         * 不需要写复杂的jdbc代码         *不需要写sql语句         *现在一般都是使用的是hibernate-release-5.0.7.Final   2.ORM思想：Object Relational Mapping(对象关系映射)         ...
Hibernate框架入门(学习笔记)
Lazyafei's Blog
05-25 557
应用程序的分层体系结构 阻抗不匹配问题 什么是O/R Mapping Hibernate简介     应用程序的分层体系结构 表示层-->业务层-->持久层-->数据层 业务层(和用户进行交互，主要实现一些业务逻辑，业务流程) 持久层(把数据永久性地写入数据库中) Hibernate可以直接把业务层操作的对象直接映射到关系数据库中。 而过去常用jdbc实现数据与数据库的交互时
Hibernate框架——入门基础笔记（详细介绍）
Lemon
10-22 692
一、hibernate 基础 1、ORM 框架 对象关系映射（Object Relational Mapping，简称ORM）是通过使用描述对象和数据库之间映射的元数据，将面向对象语言程序中的对象自动持久化到关系数据库中。 ORM（Object Relational Mapping）框架采用元数据来描述对象与关系映射的细节，元数据一般采用XML格式，并且存放在专门的对象一映射文件中。 2、h...
Hibernate框架学习笔记（二）
沉浮于世的博客
07-20 330
6.实体类的编写规则         1.实体类里面的属性都是私有的。         2.其对应的set和get方法都是public。         3.要求实体类有属性所谓唯一值。         4.实体类属性建议不使用基本数据类型，而是使用基本数据类型对应的包装类。             int----&gt;Integer             char---&gt;C...
Hibernate学习笔记
小猴子的博客
08-30 270
文章目录Hibernate学习笔记如何使⽤具体操作Hibernate 级联操作Hibernate 实现⼀对多与多对多Hibernate 延迟加载⼀对多多对多Hibernate 配置⽂件Hibernate.xml实体关系映射⽂件hibernate-mapping 属性class 属性id 属性property 属性实体关系映射⽂件属性cascade：⽤来设置级联操作Hibernate HQL1、查询对象2、分⻚查询3、where 条件查询4、模糊查询5、order by6、查询实体对象的属性7、占位符8、级联
Hibernate-学习笔记汇总
anduchencang的博客
09-05 1075
通过关系属性完成多表操作，看似是一张表的操作，实质是多张表的处理。存在问题：HQL翻译的SQL语句，执行效率低，特殊的表操作不支持。
Hibernate个人学习总结
weixin_44877172的博客
11-08 820
1.所有的持久化类必须要有一个无惨构造器，因为hibernate是使用java反射机制为我们创建对象的。构造器的访问级别可以是private,然而当生成代理的时候至少使用的是package级别的访问控制 2.hibernate的核心配置文件可以是properties或xml(hibernate.properties或hibernate.cfg.xml) 3.@Transient：表示该字段不映射到DB中，该注解无属性 4.@OneToMany(mappedBy=“在多的一方中一的属性名”):该属性是让一的一
java hibernate 分页取数_Hibernate全套增删改查+分页
weixin_39736379的博客
02-16 114
1.创建一个web工程2.导入jar包3.创建Student表4.创建实体类packagecom.entity;public classStudent {privateInteger sid;privateString sname;privateString password;privateString sex;privateInteger cid;publicStudent() {}public...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值