`

Hibernate操作对象

阅读更多
1. Hibernate中四种对象状态

临时状态(transient):刚用new语句创建,还没有被持久化,并且不处于Sesssion的缓存中。处于临时状态的Java对象被称为临时对象。
持久化状态(persistent):已经被持久化,并且加入到Session的缓存中。处于持久化状态的Java对象被称为持久化对象。
删除状态(removed):不再处于Session的缓存中,并且Session已经计划将其从数据库中删除。处于删除状态的Java对象被称为删除对象。
游离状态(detached):已经被持久化,但不再处于Session的缓存中。处于游离状态的Java对象被称为游离对象。

临时对象
内存          session缓存
c1  -->  C1
c2  -->  C2

持久化对象
内存          session缓存
c1  -->           C1
c2  -->           C2

删除对象
内存          session缓存
c1  -->  C1

游离对象
内存          session缓存
c2  -->  C2

新建项目Hibernate05


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>
        <!-- 数据库连接设置 -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate4</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <!-- 方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <!-- 控制台显示SQL -->
        <property name="show_sql">true</property>
        <!-- 自动更新表结构 -->
        <property name="hbm2ddl.auto">update</property>
        <!-- Mapper -->
        <mapping resource="com/andrew/model/Class.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

HibernateUtil.java

package com.andrew.util;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
public class HibernateUtil {
    private static final SessionFactory sessionFactory = buildSessionFactory();
    private static SessionFactory buildSessionFactory() {
        // 1. 实例化配置文件
        Configuration configuration = new Configuration().configure();
        // 2. 实例化服务登记
        ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
                .applySettings(configuration.getProperties()).build();
        // 3. 获取Session工厂
        return configuration.buildSessionFactory(serviceRegistry);
    }
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

Class.java

package com.andrew.model;
public class Class {
    private long id;
    private String name;
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Class.hbm.xml

<?xml version="1.0"?>
<!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.andrew.model">
    <class name="Class" table="t_class">
        <id column="classId" name="id">
            <generator class="native"/>
        </id>
        <property name="name" column="className"/>
    </class>
</hibernate-mapping>

StudentTest.java

package com.andrew.service;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import com.andrew.model.Class;
import com.andrew.util.HibernateUtil;
public class StudentTest {
    public static void main(String[] args) {
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
        Session session = sessionFactory.openSession(); // 1. 生成一个session
        session.beginTransaction(); // 2. 开启事务
        Class c1 = new Class(); // 临时对象1
        c1.setName("10级1班");
        
        Class c2 = new Class();  // 临时对象2
        c2.setName("10级2班");
        
        session.save(c1); // 持久化对象
        session.save(c2); // 持久化对象
        
        session.delete(c2); // 删除对象
        
        session.getTransaction().commit(); // 提交事务
        session.close(); // 关闭session
        
        System.out.println(c1.getName()); // 游离对象
        System.out.println(c2.getName()); // 删除对象
    }
}

运行结果:
Hibernate: insert into t_class (className) values (?)
Hibernate: insert into t_class (className) values (?)
Hibernate: delete from t_class where classId=?
10级1班
10级2班


2. Session常用方法讲解

新建项目Hibernate05-02


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>
        <!-- 数据库连接设置 -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate4</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <!-- 方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <!-- 控制台显示SQL -->
        <property name="show_sql">true</property>
        <!-- 自动更新表结构 -->
        <property name="hbm2ddl.auto">update</property>
        <!-- Mapper -->
        <mapping resource="com/andrew/model/Student.hbm.xml"/>
        <mapping resource="com/andrew/model/Class.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

HibernateUtil.java

package com.andrew.util;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
public class HibernateUtil {
    private static final SessionFactory sessionFactory = buildSessionFactory();
    private static SessionFactory buildSessionFactory() {
        // 1. 实例化配置文件
        Configuration configuration = new Configuration().configure();
        // 2. 实例化服务登记
        ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
                .applySettings(configuration.getProperties()).build();
        // 3. 获取Session工厂
        return configuration.buildSessionFactory(serviceRegistry);
    }
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

Class.java

package com.andrew.model;
import java.util.HashSet;
import java.util.Set;
public class Class {
    private long id;
    private String name;
    private Set<Student> students = new HashSet<Student>();
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }
}

Student.java

package com.andrew.model;
public class Student {
    private long id;
    private String name;
    private Class c;
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Class getC() {
        return c;
    }
    public void setC(Class c) {
        this.c = c;
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", c=" + c.getName() + "]";
    }
}

Class.hbm.xml

<?xml version="1.0"?>
<!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.andrew.model">
    <class name="Class" table="t_class">
        <id column="classId" name="id">
            <generator class="native"/>
        </id>
        <property name="name" column="className"/>
        <set name="students" cascade="delete" inverse="true">
            <key column="classId"></key>
            <one-to-many class="com.andrew.model.Student"/>
        </set>
    </class>
</hibernate-mapping>

Student.hbm.xml

<?xml version="1.0"?>
<!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.andrew.model">
    <class name="Student" table="t_student">
        <id column="stuId" name="id">
            <generator class="native"/>
        </id>
        <property name="name" column="stuName"/>
        <many-to-one name="c" column="classId" class="com.andrew.model.Class" cascade="save-update"></many-to-one>
    </class>
</hibernate-mapping>

StudentTest.java

package com.andrew.service;
import java.util.Iterator;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.andrew.model.Class;
import com.andrew.model.Student;
import com.andrew.util.HibernateUtil;
public class StudentTest {
    private SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
    private Session session;
    @Before
    public void setUp() throws Exception {
        session = sessionFactory.openSession(); // 1. 生成一个session
        session.beginTransaction(); // 2. 开启事务
    }
    @After
    public void tearDown() throws Exception {
        session.getTransaction().commit(); // 3. 提交事务
        session.close(); // 4. 关闭session
    }
    ...
}


2.1) save()方法将一个临时对象转变成持久化对象;

@Test
public void testSaveClassAndStudent() {
    Class c = new Class();
    c.setName("10级1班");
    Student s1 = new Student();
    s1.setName("张三");
    s1.setC(c);
    Student s2 = new Student();
    s2.setName("李四");
    s2.setC(c);
    session.save(s1);
    session.save(s2);
}

运行结果:
Hibernate: insert into t_class (className) values (?)
Hibernate: insert into t_student (stuName, classId) values (?, ?)
Hibernate: insert into t_student (stuName, classId) values (?, ?)


2.2) load()方法 VS get()方法

都是根据OID从数据库中加载一个持久化对象。
区别1:假如数据库中不存在与OID对应的记录,Load()方法会抛出异常,而get()方法返回null;
区别2:load方法默认采用延迟加载策略,get方法采用立即检索策略;

@Test
public void testLoadClass(){
    Class c = (Class)session.load(Class.class, Long.valueOf(1));
    System.out.println(c.getStudents());
}

运行结果:
debug中c是没有值的,下面使用的时候才会获取值
运行结果:
Hibernate: select class0_.classId as classId1_0_0_, class0_.className as classNam2_0_0_ from t_class class0_ where class0_.classId=?
Hibernate: select students0_.classId as classId3_0_0_, students0_.stuId as stuId1_1_0_, students0_.stuId as stuId1_1_1_, students0_.stuName as stuName2_1_1_, students0_.classId as classId3_1_1_ from t_student students0_ where students0_.classId=?
[Student [id=1, name=张三, c=10级1班], Student [id=2, name=李四, c=10级1班]]

@Test
public void testGetClass(){
    Class c = (Class)session.get(Class.class, Long.valueOf(1));
    System.out.println(c.getStudents());
}

运行结果:
debug中c是有值的,下面可以直接使用
运行结果:
Hibernate: select class0_.classId as classId1_0_0_, class0_.className as classNam2_0_0_ from t_class class0_ where class0_.classId=?
Hibernate: select students0_.classId as classId3_0_0_, students0_.stuId as stuId1_1_0_, students0_.stuId as stuId1_1_1_, students0_.stuName as stuName2_1_1_, students0_.classId as classId3_1_1_ from t_student students0_ where students0_.classId=?
[Student [id=2, name=李四, c=10级1班], Student [id=1, name=张三, c=10级1班]]

2.3) update()方法将一个游离对象转变为持久化对象
@Test
public void testUpdateClass(){
    Session session1 = sessionFactory.openSession();
    session1.beginTransaction();
    Class c = (Class)session1.get(Class.class, Long.valueOf(1));
    session1.getTransaction().commit(); // 提交事务
    session1.close();
    
    Session session2 = sessionFactory.openSession();
    session2.beginTransaction();
    c.setName("10级10班");
    session2.update(c);
    session2.getTransaction().commit(); // 提交事务
    session2.close();
}

1    10级1班
运行结果:
Hibernate: select class0_.classId as classId1_0_0_, class0_.className as classNam2_0_0_ from t_class class0_ where class0_.classId=?
Hibernate: update t_class set className=? where classId=?
1    10级10班


2.4) saveOrUpdate()方法包含了save()和update()方法

@Test
public void testSaveOrUpdateClass() {
    Session session1 = sessionFactory.openSession();
    session1.beginTransaction();
    Class c = (Class)session1.get(Class.class, Long.valueOf(1));
    session1.getTransaction().commit(); // 提交事务
    session1.close();
    
    Session session2 = sessionFactory.openSession();
    session2.beginTransaction();
    c.setName("11级1班");
    Class c2 = new Class();
    c2.setName("11级2班");
    session2.saveOrUpdate(c);
    session2.saveOrUpdate(c2);
    session2.getTransaction().commit(); // 提交事务
    session2.close();
}

1    10级10班
运行结果:
Hibernate: select class0_.classId as classId1_0_0_, class0_.className as classNam2_0_0_ from t_class class0_ where class0_.classId=?
Hibernate: insert into t_class (className) values (?)
Hibernate: update t_class set className=? where classId=?
1    11级1班
2    11级2班


2.5) merge()方法,合并对象

@Test
public void testMergeClass() {
    Session session1 = sessionFactory.openSession();
    session1.beginTransaction();
    Class c = (Class)session1.get(Class.class, Long.valueOf(1));
    session1.getTransaction().commit(); // 提交事务
    session1.close();
    Session session2 = sessionFactory.openSession();
    session2.beginTransaction();
    
    Class c2 = (Class)session2.get(Class.class, Long.valueOf(1));
    c.setName("12级1班");
    session2.merge(c);
    
    session2.getTransaction().commit(); // 提交事务
    session2.close();
}

1    11级1班
2    11级2班
运行结果:
Hibernate: select class0_.classId as classId1_0_0_, class0_.className as classNam2_0_0_ from t_class class0_ where class0_.classId=?
Hibernate: select class0_.classId as classId1_0_0_, class0_.className as classNam2_0_0_ from t_class class0_ where class0_.classId=?
Hibernate: update t_class set className=? where classId=?
1    12级1班
2    11级2班


2.6) delete()方法,删除对象

@Test
public void testDeleteStudent() {
    Student student = (Student)session.load(Student.class, Long.valueOf(1));
    session.delete(student);
}

运行结果:
Hibernate: select student0_.stuId as stuId1_1_0_, student0_.stuName as stuName2_1_0_, student0_.classId as classId3_1_0_ from t_student student0_ where student0_.stuId=?
Hibernate: delete from t_student where stuId=?
分享到:
评论

相关推荐

    Hibernate操作持久化对象

    Hibernate 操作持久化对象是Java开发中用于简化数据库交互的重要工具。它是一个开源的Java持久化框架,由Gavin King创建,并逐渐发展成为Java世界中主流的持久化解决方案。Hibernate的核心在于提供对象-关系映射(ORM...

    hibernate相关配置 3种状态

    3. Hibernate操作对象的生命周期: - 新建一个对象并设置属性,此时对象处于瞬时态。 - 调用Session的save()或saveOrUpdate()方法,对象进入持久态,Hibernate会为对象生成一个唯一的数据库ID。 - 当Session的...

    精通Hibernate:Java对象持久化详解.zip

    Hibernate作为一款强大的对象关系映射(ORM)框架,极大地简化了Java应用中的数据库操作,使得开发者能够更专注于业务逻辑而不是繁琐的SQL代码。 在Java开发中,持久化是将应用程序中的对象状态保存到持久存储介质...

    Hibernate 操纵持久化对象

    通过使用Hibernate,开发者可以以面向对象的方式操作数据,提高了开发效率和代码的可读性。 **二、持久化对象(Persistent Objects)** 在Hibernate中,持久化对象是指具有与数据库表相对应状态的Java对象。一旦一...

    精通Hibernate:Java对象持久化技术详解.pdf

    在Hibernate中,实体类代表数据库表,实体类的实例对应表中的记录,属性对应字段,这样就将复杂的SQL操作转化为简单的对象操作。 其次,书中详细讲解了Hibernate的配置。这包括了Hibernate的XML配置文件(hibernate...

    Java 精通Hibernate对象持久化技术权威指南

    《Java精通Hibernate对象持久化技术权威指南》是一本深度探讨Java开发中如何高效地使用Hibernate进行对象持久化的专业书籍。本书旨在帮助Java开发者熟练掌握Hibernate框架,实现数据库操作的简化和自动化,提升软件...

    hibernate操作数据库笔记

    使用Hibernate的Session对象操作数据库 1.初始化Hibernate:在要使用Hibernate的类的方法中实例化Configuration对象并用Configuration对象的configure()方法将hibernate.cfg.xml中的配置加载到内存,即: ...

    精通Hibernate:Java对象持久化技术详解

    1. **对象关系映射**:Hibernate通过XML配置或注解方式,将Java类与数据库表建立映射关系,使得开发者可以像操作对象一样操作数据库记录。 2. **Session接口**:它是Hibernate的主要工作接口,负责对象的加载、保存...

    精通Hibernate:java对象持久化技术

    【精通Hibernate:Java对象持久化技术】主要涵盖了Java应用程序的分层体系结构、软件模型以及对象持久化的概念,特别是如何使用Hibernate这一ORM框架进行持久化操作。以下是详细的知识点解析: 1. **应用程序分层...

    MyEclipse由表自动生成Hibernate实体对象_白杨

    通过以上知识点的详细阐述,我们可以了解到如何在MyEclipse中利用Hibernate进行数据库表到Java实体对象的反向工程操作,以及操作过程中需要关注的各个环节和注意事项。这对于提升开发效率和保证开发质量具有重要的...

    Hibernate实体对象操纵

    在Java开发中,Hibernate是一款非常重要的对象关系映射(ORM)框架,它极大地简化了数据库操作,使得开发者可以使用面向对象的方式来处理数据库数据。本篇文章将深入探讨Hibernate中的实体对象操纵,包括实体的概念...

    Hibernate操作数据库的方法

    Hibernate操作数据库时,主要通过以下几个核心组件来实现持久层操作: 1. **Session**:Session是Hibernate用来和数据库进行交互的一个轻量级对象,它相当于JDBC中的Connection。Session对象是应用程序与数据库进行...

    Hibernate持久化对象的生命周期

    在Java编程中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它使得开发者能够以面向对象的方式处理数据库操作。Hibernate的核心概念之一就是持久化对象的生命周期,这涉及到对象在数据库中的状态及其与...

    使用Hibernate完成对象持久化

    Hibernate是一个强大的对象关系映射(ORM)框架,它简化了Java应用对数据库的操作,使得开发者能够以面向对象的方式处理数据,而无需直接编写大量的SQL语句。 ### Hibernate的基本原理 Hibernate的核心在于提供了...

    hibernate操纵实体对象

    `HibernateSessionFactory.java`以及`BatchUpdateTest.java`这四个文件涵盖了Hibernate中的核心操作和测试场景,它们一起构成了一个完整的数据库操作示例,展示了如何高效地使用Hibernate处理Java实体对象。...

    Hibernate 对象持久化

    Hibernate提供了一种面向对象的查询语言——HQL(Hibernate Query Language),类似于SQL,但它是面向对象的,可以直接操作实体类和其属性。此外,Hibernate还支持Criteria查询和Criteria API,提供了更灵活的查询...

    java使用hibernate操作数据库jar

    5. 操作对象:通过Session对实体对象进行CRUD操作。 6. 提交或回滚事务:操作完成后,提交事务使更改生效,或者在出现异常时回滚事务。 7. 关闭Session和SessionFactory:操作结束后,关闭Session以释放资源,...

    妙解Hibernate 3.x:叩响面向对象思想之门 PDF

    面向对象思想是现代软件开发的重要基石,而Hibernate是这一思想在数据库操作中的体现。本书通过深入浅出的讲解,帮助读者不仅掌握Hibernate的使用,更进一步理解面向对象设计原则,从而在项目开发中更好地应用这些...

Global site tag (gtag.js) - Google Analytics