Hibernate学习总结-优快云博客

本文详细介绍了Hibernate框架的基础使用方法，从环境搭建、实体类定义到基本的CRUD操作，还涉及了延迟加载、查询语言等内容。

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

Hibernate学习总结

1.lib

第一步当然是导入hibernate所需要的包了

其中c3p0-0.9.1.jar是连接池管理的包，并不是必须的，而是当连接数据库频繁的时候提升性能。

2.创建hibernate.cfg.xml配置文件

该文件是用来配置hibernate相关设置的，包括数据库驱动、url、用户名和密码，SQL方言设置（hibernate会帮我们处理好不同的数据库操作，所以要让它知道我们用的数据库的方言），还有映射设置。

映射设置。

3.创建实体类

实体类必须是包含各个属性的setter和getter的类，cfg.xml中映射采用注解映射，还需要加上各种映射：@Entity,@Table(name="***"),@Id,@Column(name="***"),@OneToMany等等，若是采用这个方式，在cfg.xml中应该是为每个类创建<mapping class="com.zhoudq.Classname"/>;若cfg.xml文件中映射采用配置映射，则不需各种@,而是创建****.hbm.xml(->第四步)

Product.java

package com.how2java.pojo;

import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
@Entity
@Table(name="product_")
public class Product {
	private int id;
	private String name;
	private float price;
	private Category category;
	private Set<User> users;
	private int version;
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	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 float getPrice() {
		return price;
	}
	public void setPrice(float price) {
		this.price = price;
	}
	@ManyToOne
	@JoinColumn(name="cid")
	public Category getCategory() {
		return category;
	}
	public void setCategory(Category category) {
		this.category = category;
	}
	@ManyToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER)
	@JoinTable(
			name="user_product",
			joinColumns=@JoinColumn(name="pid"),
			inverseJoinColumns=@JoinColumn(name="uid"))
	public Set<User> getUsers() {
		return users;
	}
	public void setUsers(Set<User> users) {
		this.users = users;
	}
	public int getVersion() {
		return version;
	}
	public void setVersion(int version) {
		this.version = version;
	}
}

4.配置pojo.hbm.xml

创建实体类之后需要为每个实体实现在数据库中表的映射（可以在一个文件中配置，也可为每个实体类创建一个entity.hbm.xml），这个文件中包括类名、对应的表、属性和对应的字段（属性和字段相同则可省略字段的说明）以及表之间的关联（多对多关联需要加上关联表的信息）；使用这种映射方式在cfg.xml文件中的映射设置为<mapping resource="com/how2java/pojo/Pojo.hbm.xml"></mapping>

pojo.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="com.how2java.pojo">
    <class name="Product" table="product_">
        <id name="id" column="id">
            <generator class="native">
            </generator>
        </id>
        <!-- version元素必须在id后面，可以保证两个session的脏读会失败，称之为乐观锁 -->
        <version name="version" column="var" type="int"/>
        <property name="name" />
        <property name="price" />
        <!-- 多个product对应一个category -->
        <many-to-one name="category" class="Category" column="cid"></many-to-one>
        <!-- Product和User的多对多关系，对应的自己的键和映射的对象的字段及类 -->
        <set name="users" table="user_product" lazy="false">
        	<key column="pid"></key>
        	<many-to-many column="uid" class="User"></many-to-many>
        </set>
    </class>
    
    <class name="Category" table="category">
    	<id name="id" >
    		<generator class="native"></generator>
    	</id>
    	<property name="name"></property>
    	<!-- 一个Category对应多个Product的关系，作为外键的名称和对应的类 -->
    	<set name="products" cascade="all" lazy="false">
    		<key column="cid" not-null="false"/>
    		<one-to-many class="Product"/>
    	</set>
    </class>
     
     <class name="User" table="user">
     	<id name="id" ><generator class="native"></generator></id>
     	<property name="name"/>
     	<!-- User和Product的多对多关系，需要一张辅助表，自己的键字段和映射的键字段和类 -->
     	<set name="products" table="user_product" lazy="false">
     		<key column="uid"/>
     		<many-to-many column="pid" class="Product"></many-to-many>
     	</set>
     </class>
     
     <class name="Product1" table="product1">
     	<id name="id" column="id">
            <generator class="native">
            </generator>
        </id>
        <property name="name" />
        <property name="price" />
     </class>
</hibernate-mapping>

5.使用

使用Configuration().configure().buildSessionFactory()创建一个SessionFactory,用这个会话工厂打开一个会话，用这个会话开始一个事务：

		SessionFactory sf=new Configuration().configure().buildSessionFactory();
		Session s=sf.openSession();
		s.beginTransaction();
                //具体的操作
                s.getTransaction().commit();
		s.close();
		sf.close();

(1)获取

使用get或者load

查询前面的Product类对应的表：Product product=(Product)s.get(Product.class,12)/Product product=(Product)s.load(Product.class,12);

12对应的是id,即get和load只能通过id来查询，两者的区别是load方式是延迟加载，只有属性被访问的时候才会调用sql语句，get方式是非延迟加载，无论后面的代码是否会访问到属性马上执行sql语句

(2)查询

有三种方式：hql(hibernate query language)、criteria、sql

hql:

                String key="iphone";
		Query q=s.createQuery("from Product p where p.name like ?");
		q.setString(0, "%"+key+"%");

可以使用q.list();获取一个List获得结果，也可以使用q.iterate();获取一个Iterator迭代器获得结果;

		List<Product> products=q.list();
		for(Product p:products)
			System.out.println(p.getName());

		Iterator<Product> iterator=q.iterate();
		while(iterator.hasNext()) {
			Product p=iterator.next();
			System.out.println(p.getName());
		}

cirteria:

		Criteria criteria=s.createCriteria(Product.class);
		criteria.add(Restrictions.like("name","%"+key+"%"));
		List<Product> list=criteria.list();

若要使用分页查询，使用

		criteria.setFirstResult(0);//起始记录
		criteria.setMaxResults(5);//最大数量

sql:

		String sql="select * from category c where c.name like '%"+key+"%'";
		Query q=s.createSQLQuery(sql);

获取结果

		List<Object[]> list1=q.list();
		for(Object[] os:list1){
			for(Object field:os)
				System.out.println(field);
		}

(3)增删改

增：可以使用前面的hql和sql，也可使用save()

		Product p=new Product();
		p.setName("iphone7s");
		p.setPrice(7588);
		s.save(p);

删、改：首先获取p:Product p=(Product)s.get(Product.class,?)

s.delete(p)、p.set***(***);s.update(p)

若是一对多、多对多可以使用级联来进行关联删除和更新：在hbm.xml中对应的属性中加入cascade属性，值有"delete","save-update","all"和"none";

分别对应在删除时、更新和保存时、任何情况、任何情况都不进行级联操作。

6.其他

（1）属性、关系延迟加载

属性延迟加载即为load获取对象时只有访问了对象的属性时才会访问数据库

关系延迟加载指两个表的关系为多对多或者一对多时，比如A one to many B,使用lazy="true"时访问A时不会访问B,只有通过A获取B的集合时才会访问B;lazy="false"时则不然;

<class name="User" table="user">
     	<id name="id" ><generator class="native"></generator></id>
     	<property name="name"/>
     	<!-- User和Product的多对多关系，需要一张辅助表，自己的键字段和映射的键字段和类 -->
     	<set name="products" table="user_product" lazy="true">
     		<key column="uid"/>
     		<many-to-many column="pid" class="Product"></many-to-many>
     	</set>
</class>

(2)两种获取Session方式

获取的对象:openSession每次获取的都是不同的对象;getCurrentSession在同一线程下获取的都是同一个对象，多线程中才是不同的对象

事务提交的必要性:openSession的查询不需要提交事务，其它操作都要提交，且需要手动关闭Session;getCurrentSession任何操作都要，且事务提交后Session会自动关闭，再次关闭会抛出异常
(3)实体类的状态

实体类在hibernate中有3种状态：瞬时、持久、托管

瞬时：和hibernate和数据库没有任何关系，jvm关闭就消失。

持久：和hibernate发生联系，且在数据库中有对应的一条记录。

托管：在数据库中有一条记录，但是对应的Session已经关闭。