持久化对象的 四种状态

最新推荐文章于 2021-07-10 21:19:29 发布
最新推荐文章于 2021-07-10 21:19:29 发布
阅读量5.6k 收藏 2
点赞数 1
分类专栏： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chuck_kui/article/details/51533095
版权

持久化对象的状态













~~~~~~~~~~~~~~~~~~~~~~~~~~~分割线~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

1. 项目结构


2. hibernate.cfg.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="hibernate.connection.username">root</property>
    	<property name="hibernate.connection.password">chuck</property>
    	<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    	<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property>
    	
    	<property name="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
    	<property name="hibernate.show_sql">true</property>
    	<property name="hibernate.format_sql">true</property>
    	<property name="hibernate.hbm2ddl.auto">update</property>
    	<property name="hibernate.connection.isolation">2</property>
    	
    	
    	<mapping resource="com/baidu/hibernate/app/Person.hbm.xml"  />
    	
    	
    </session-factory>
    
</hibernate-configuration>
3.持久化类 Person.java 
package com.baidu.hibernate.app;

import java.util.Date;

public class Person {
	
	private Integer id;
	private String name;
	private String interest;
	private Date birth;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getInterest() {
		return interest;
	}
	public void setInterest(String interest) {
		this.interest = interest;
	}
	public Date getBirth() {
		return birth;
	}
	public void setBirth(Date birth) {
		this.birth = birth;
	}
	public Person() {
		super();
	}
	public Person(String name, String interest, Date birth) {
		super();
		this.name = name;
		this.interest = interest;
		this.birth = birth;
	}
	@Override
	public String toString() {
		return "Person [id=" + id + ", name=" + name + ", interest=" + interest
				+ ", birth=" + birth + "]";
	}

}
4. 对象-关系映射 Person.hbm.xml 
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.hibernate.app">

    <class name="Person" table="PERSON" >
  
        <id name="id" type="java.lang.Integer" >
            <column name="ID" />
            <generator class="hilo" />
        </id>
        
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        
        <property name="interest" type="java.lang.String">
            <column name="INTEREST" />
        </property>
        
        <property name="birth" type="java.util.Date">
            <column name="BIRTH" />
        </property>
    </class>
    
</hibernate-mapping>
~~~~~~~~~~~~~~~~~分割线~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~下面是方法测试类~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5. 方法测试类 TestHibernatePerson.java

①  掌握 persist() 和save() 的区别

② 掌握 get() 和load()  的区别

③ 如何才能避免update 方法不盲目的触发 UPDATE 的SQL语句呢？ 如何配置

④ saveOrUpdate() 方法 在什么情况下触发 save() 方法，什么情况下触发update() 方法 。什么样的对象也会被视为游离对象？

⑤ 能否 在删除后即把OID 置为空呢？ 如何配置


package com.baidu.hibernate.app;

import static org.junit.Assert.*;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class TestHibernatePerson {
	
	private SessionFactory sessionFactory;
	private Session session;
	private Transaction transaction;
	
	
	@Before
	public void init(){
		Configuration configuration = new Configuration().configure();
		ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
					.applySettings(configuration.getProperties())
					.buildServiceRegistry();
		
		sessionFactory = configuration.buildSessionFactory(serviceRegistry);
		
		session = sessionFactory.openSession();
		transaction = session.beginTransaction();
		System.out.println("init");
	}
	
	@After
	public void destroy(){
		transaction.commit();
		System.out.println("WO  在 commit 后");
		session.close();
		sessionFactory.close();
		System.out.println("distroy");
	}
	
	
	
	/**
	 * 1. save() 方法
	 * 	①. 使一个临时对象变为持久化对象
	 * 	②. 为对象分配ID
	 *  ③. 在flush 缓存时，会发送一条INSERT 语句
	 *  ④. 在save() 方法之前设置的 ID 是无效的
	 *  ⑤. 持久化对象的ID 是不能被修改的
	 * 
	 * save()方式两条sql 语句：
	 * 			 ①.发送一条select 语句
	 * 			 ②. 在发送一条update 语句
	 * 
	 * 执行完save()方法后，执行commit 是 会在发送一条insert 语句
	 */
	@Test
	public void testSave() {
		Person person = new Person();
		person.setName("ZhaoYun");
		person.setInterest("music2");
		person.setBirth(new Date());
		person.setId(20);
		
		System.out.println(person);
		System.out.println("wo zai save 前");
		session.save(person);
		System.out.println("wo zai save 后");
		
		System.out.println(person);
		System.out.println("WO  在 commit 前");
	}
	
	
	/**
	 * persist(): 也会执行INSERT 操作
	 * 
	 *  persist() 和save() 的区别：
	 * 			当对一个OID 不为null 的对象执行save()方法时，会把该对象以一个新的oid保存到数据库中，
	 * 			但是，当执行persist()方法时，则会抛出一个异常
	 */
	@Test
	public void testPersist(){
		Person person = new Person();
		person.setName("Zhao");
		person.setInterest("music");
		person.setBirth(new Date());
//		person.setId(30);//如果在最新persist 方法前的这里 这种的 id 属性，这会抛出异常
						//org.hibernate.PersistentObjectException: detached entity 
						//passed to persist: com.baidu.hibernate.app.Person	
		session.persist(person);
		
		System.out.println("WO  在 commit 前");
	}
	
	/**
	 * get() 和load() 方法
	 * 1. 执行get 方法： 会立即查询加载对象，
	 * 2. 执行load 方法， 若不使用该对象，则不会立即执行查询操作，而返回一个代理对象
	 * 
	 * 		get方法 是立即检索，load 方法是延迟检索。
	 * 
	 * 3. load 方法可能会抛出 org.hibernate.LazyInitializationException: 
	 * 			could not initialize proxy - no Session 异常
	 * 		原因：因为load 是延迟检索，在需要初始化代理对象之前，已经关闭了Session 导致
	 * 
	 * 4. 若数据库中没有对应的记录，session 也没有被关闭：
	 * 		get 返回 null
	 * 		load 若不使用该对象的任何属性，则不会抛异常
	 * 			 若需要初始化时，则会抛出异常。
	 */
	@Test
	public void testLoad(){
		Person person = (Person) session.load(Person.class, 1);
		
		session.close();
		
		System.out.println(person);
	}
	
	@Test
	public void testGet(){
		Person person = (Person) session.get(Person.class, 1);
		//System.out.println(person);
	}
	
	/**
	 * update：
	 * 
	 * 1. 若更新一个持久化对象，不需要显示的调用update() 方法,因为Transaction
	 * 	  的commit() 方法时，会先执行session 的flush 方法。
	 * 
	 * 2. 更新一个游离对象，需要显式的调用session的update方法，只有显示的调用update() 方法，才会把一个游离对象变成了一个持久化对象
	 * 
	 * 3. 如果调用获取对象后，重新设置了对象的属性，但是属性设置前后没有变化，
	 * 		即：数据库中记录id=1 的name属性是 LiuBei， 修改后的name属性 还是LiuBei ，
	 * 		不论是否显示的调用update() 方法，都发送update 的SQL语句 。
	 * 
	 * 注意： 前提： 当显示的调用了update() 方法时：
	 * 	①. 无论要更新的游离对象和数据表中的是否一致，都会发送UPDATE 的 SQL语句。
	 * 		
	 * 		如何才能避免update 方法不在盲目的触发 UPDATE 的SQL语句呢？
	 * 			为了解决这个问题，需要在.hbm.xml 文件的class 中添加 
	 * 			select-before-update=true(默认为false)，但通常不需要设置该属性
	 * 			配置详解见下 A
	 * 
	 *  ②. 对于游离对象，可以修改其ID， 但若在数据表中没有和修改后的ID对应的记录，且又调用了update() 方法，则会抛出异常
	 *  						若在数据表中有和修改后的ID对应的记录，且又调用了update() 方法，则会更新数据表中
	 *  						和修改后的ID对应的记录
	 * 		
	 *  ③. 当update() 方法 关联一个游离对象时，如果在Session 的缓存中已经存在相同的OID 的持久化对象，则会抛出异常
	 *  	因为在session 缓存中不能有两个OID 相同的对象同时存在 : 即缓存中不能同时存在两个Id 相同的对象，
	 *  	对应同一条数据库的记录
	 */
	
	@Test
	public void testUpdate(){
		Person person = (Person) session.get(Person.class, 1);
		
		transaction.commit();;
		session.close();
		
		session = sessionFactory.openSession();
		transaction = session.beginTransaction();
		
		person.setName("Liu");
		session.update(person);
		System.out.println(person);
	
	}
	
	
	/**
	 * Session 的 saveOrUpdate() 方法同时包含了 save() 与 update() 方法的功能
	 * 
	 *  判定对象是否为临时对象的标准
	 *  		① Java 对象的 OID 为 null
	 *  		② 映射文件中为 <id> 设置了 unsaved-value  属性, 
	 *  			并且 Java 对象的 OID 取值与这个 unsaved-value 属性值匹配
	 * 			配置详解见下 B
	 * 注意：
	 * 	① 若 OID 不为null， 但是对应该ID的记录，在数据表中又不存在，则会抛出异常：org.hibernate.StaleStateException
	 *  ② 了解：OID 值等于id 的 unsaved-value 属性值的对象，也被认为是一个游离对象。	
	 *  	详解：Person.hbm.xml 配置中 的 id name="id" type="java.lang.Integer" unsaved-value="200"
	 *  		则id=200 的对象会被认为是游离对象
	 *  	
	 */
	@Test
	public void testSaveOrUpdate(){
		Person person = new Person("Tom", "eating fish", new Date());
		person.setId(200);
		session.saveOrUpdate(person);
	}
	
	
	/**
	 *delete: 执行删除操作，只要OID 和数据表中一条记录对应，就会准备执行delete 操作 
	 * 		  若OID 在数据表中没有对应的记录，则会抛出异常
	 * 
	 * 能否 在删除后即把OID 置为空呢？ 可以
	 * 		Hibernate 的 cfg.xml 配置文件中有一个 hibernate.use_identifier_rollback 属性, 其默认值为 false, 
	 * 		若把它设为 true, 将改变 delete() 方法的运行行为:delete() 方法会把持久化对象或游离对象的 OID 
	 * 		设置为 null, 使它们变为临时对象 
	 * 
	 * 		配置详解见下 C
	 */
	
	@Test
	public void testDelete(){
		Person person = new Person();
		//person.setId(851968);//这时person 对象是 当new 的，还未被保存到数据库的数据表中，因此是游离对象
		//session.delete(person);
		
		
		person = (Person) session.get(Person.class, 884736);// 这时person 是从数据库总获取的 是一个持久化对象
		session.delete(person);
	}
	
	
	/**
	 * evict:从session 缓存中把指定的持久化对象移除
	 * 
	 */
	@Test
	public void testEvict(){
		Person person = (Person) session.get(Person.class, 819200);
		Person person2 = (Person) session.get(Person.class, 917504);
		
		person.setName("AA");
		person2.setName("BB");
		
		session.evict(person);
	}
	
	
	/**
	 * Hibernate 如何调用存储过程
	 * 
	 * 可以通过调用 Work 接口 来完成存储过程: 直接通过 JDBC API 来访问数据库的操作
	 * 
	 * Session 的 doWork(Work) 方法用于执行 Work 对象指定的操作, 
	 * 				即调用 Work 对象的 execute() 方法. 
	 * Session 会把当前使用的数据库连接传递给 execute() 方法.
	 * 
	 */
	@Test
	public void testDoWork(){
		
		session.doWork(new Work(){
			
			@Override
			public void execute(Connection connection) throws SQLException {
				System.out.println(connection);
				
			}
		});
	}		
	
}

③ 如何才能避免update 方法不盲目的触发 UPDATE 的SQL语句呢？ 如何配置 

详解A：需要在.hbm.xml 文件的class 中添加 select-before-update=true

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.hibernate.app">

	<!-- 
		如何才能避免update 方法不在盲目的触发 UPDATE 的SQL语句呢？
			为了解决这个问题，需要在.hbm.xml 文件的class 中添加 
			select-before-update=true(默认为false)，但通常不需要设置该属性
	 -->

    <class name="Person" table="PERSON" select-before-update=true>

        <id name="id" type="java.lang.Integer"  unsaved-value="200">
            <column name="ID" />
            <generator class="hilo" />
        </id>
        
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        
        <property name="interest" type="java.lang.String">
            <column name="INTEREST" />
        </property>
        
        <property name="birth" type="java.util.Date">
            <column name="BIRTH" />
        </property>
    </class>
    
</hibernate-mapping>

④ 调用saveOrUpdate() 方法 什么样的对象也会被视为游离对象？如何配置

详解B：需要在.hbm.xml 文件的id 中配置 

              因为unsaved-value 的值配置为多少 ，这会认为 id = 为多少  的对象也是游离对象，

              如下：unsaved-value=1 ，这id=1  的对象就会被认为也是游离对象

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.hibernate.app">

    <class name="Person" table="PERSON" select-before-update=true>
    	
    	<!-- 
    		OID 值等于id 的 unsaved-value 属性值的对象，也被认为是一个游离对象。
    				
    			例如：<id name="id" type="java.lang.Integer"  unsaved-value="1">
				 因为unsaved-value 的值是1 ，这会认为 id = 1  的对象 也是游离对象    				
    	 -->
    	
        <id name="id" type="java.lang.Integer"  unsaved-value="200">
            <column name="ID" />
            <generator class="hilo" />
        </id>
        
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        
        <property name="interest" type="java.lang.String">
            <column name="INTEREST" />
        </property>
        
        <property name="birth" type="java.util.Date">
            <column name="BIRTH" />
        </property>
    </class>
    
</hibernate-mapping>

⑤ 能否 在删除后即把OID 置为空呢？ 如何配置

详解C：需要在hibernate.cfg.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="hibernate.connection.username">root</property>
    	<property name="hibernate.connection.password">chuck</property>
    	<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    	<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property>
    	
    	<property name="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
    	<property name="hibernate.show_sql">true</property>
    	<property name="hibernate.format_sql">true</property>
    	<property name="hibernate.hbm2ddl.auto">update</property>
    	<property name="hibernate.connection.isolation">2</property>
    	
    	<!-- 能否 在删除后即把OID 置为空呢？ 可以
    		Hibernate 的 cfg.xml 配置文件中有一个 hibernate.use_identifier_rollback 属性, 其默认值为 false, 
    		若把它设为 true, 将改变 delete() 方法的运行行为:delete() 方法会把持久化对象或游离对象的 OID 
    		设置为 null, 使它们变为临时对象 
    	 -->
    	<property name="hibernate.use_identifier_rollback">true</property>
    	
    	<mapping resource="com/baidu/hibernate/app/Person.hbm.xml"  />
    	
    	
    </session-factory>
    
</hibernate-configuration>




chuck_kui
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
持久层（JDBC、Mybatis）
ZHANGLEl的博客
02-20 904
持久层（JDBC、Mybatis）
持久化层的Java对象可处于哪些状态？这些状态有哪些特征？
在交流中成长
08-25 821
当应用程序通过new语句创建了一个对象，这个对象的生命周期就开始了，当不再有任何引用变量引用它，这个对象就结束生命周期，它占用的内存就可以被JVM的垃圾回收器回收。对于需要被持久化的Java对象，在它的生命周期中，可处于以下三个状态之一： (1) 临时状态（transient）：刚刚用new语句创建，还没有被持久化，不处于Session的缓存中。处于临时状态的Java对象被称为
孙卫琴的《精通JPA与Hibernate》的读书笔记：持久化层对象的四种状态
csdnuserlala的博客
04-30 362
站在持久化层的角度，一个Java对象在它的生命周期中，可处于以下四个状态之一： （1） 临时状态（transient）：刚用new语句创建，还没有被持久化，并且不处于持久 （2） 化缓存中。处于临时状态的Java对象被称为临时对象。 （3） 持久化状态（persistent）：已经被持久化，并且加入到持久化缓存中。处于持久化状态的Java对象被称为持久化对象。 （4） 删除状态（removed）：不再处于持久化缓存中，并且Session已经计划将其从数据库中删除。处于删除状态的Java对象被称为被删除对象.
第七章 Caché 持久性对象介绍
yaoxin521123的博客
03-19 1188
文章目录 第七章 Caché 持久性对象介绍持久化类介绍默认的SQL映射保存对象标识符:ID和OID对象ID映射到SQLSQL中的对象ID特定于持久类的类成员存储定义索引外键触发器其他类成员继承管理继承查询附录 第七章 Caché 持久性对象介绍 持久化类 持久类是继承自%persistent的任何类。持久对象就是这样一个类的实例。 %Persistent类是%RegisteredObject的...
持久化对象的三种状态
天才小站
09-13 1464
一下简述：不准确，大概描述。 瞬时态：没有id且没有与session关联           （刚创建对象） 持久态：有id且和session关联                            （session加入缓存操作的过程） 托管态：有id且和session失去关联，与数据库产生关联    （保存之后） ☆注意： 持久化对象可以自动更新数据库 （依赖于一级缓存） 例如
深入学习Hibernate持久化对象的三个状态
08-29
在理解Hibernate持久化对象的三个状态之前，首先要明白Hibernate是一个对象关系映射（ORM）框架，它将数据库操作转化为对Java对象的操作。这三个状态决定了对象与数据库之间的一致性及生命周期，分别是： 1. **瞬时...
C# 对象持久化详解
08-31
在C#编程中，对象持久化是一个重要的概念，它允许我们在程序运行时将对象的状态保存到持久化的存储介质，如磁盘，以便后续能够恢复这些对象的状态。这在需要跨会话或者跨进程保持数据一致性的场景中尤其有用。本文将...
精通Hibernate：Java对象持久化详解.zip
08-12
在Java开发中，持久化是将应用程序中的对象状态保存到持久存储介质（如数据库）的过程。Hibernate通过提供一种对象-关系映射机制，使得Java对象可以直接与数据库表进行交互，而无需编写大量的SQL语句。这种映射机制...
vuex实现数据状态持久化
12-13
需要注意的是，虽然`vuex-persistedstate`提供了一种方便的方式来实现状态的持久化，但并不是所有状态都适合持久化。例如，敏感信息如用户认证信息、临时性的缓存数据等，可能需要在用户离开页面时清除，不应保存到...
hibernate对象三种状态
08-14
在Java的持久化框架Hibernate中，对象存在三种不同的状态，分别是持久态（Persistent）、自由态（Transient）和游离态（Detached）。这三种状态分别对应了对象与数据库的关联程度，理解它们对于高效地使用Hibernate...
持久对象的生命周期（瞬时态、持久态、脱管态）
坚持是唯一的成功
06-06 3129
在Hibernate中，持久化对象在操作过程中可以分为三个时期，这三个时期是与Session的周期相关的，因为Hibernate中的操作都是基于Session完成的。所以Session对象的生命周期也关系着持久化对象的生命周期。持久化对象的三种生命周期分别是瞬时态（Transient）、持久态（Persistent）和脱管态（Detached）。 1.      瞬时态 瞬时态的对象时刚刚用n
对象持久化
achun2050的专栏
05-16 1760
什么是持久化？简单地说，持久化就是把数据同步保存到数据库或某些存储设备中。在软件的分层体系结构中，持久化层是与数据库打交道的逻辑层。在数据库中对数据的增加、删除、查找和修改操作由持久化层来处理。最常见的操作是在ASP或JSP的页面代码中混杂了很多连接数据库、操作数据库的语句，这实际上是把持久层和展现层耦合到了一起，使得代码的编写和维护都很困难，程序结构非常不清晰。对于大型应用，这个问题尤为突出，因
java临时对象持久对象_Java对象持久性：联盟状态
cunfu6353的博客
07-09 830
java临时对象持久对象 在这个虚拟小组中，InfoQ.com（Floyd Marinescu）和ODBMS.org（Roberto V. Zicari）的编辑询问了一组领先的持久性解决方案架构师，以他们对Java社区中持久性联盟的当前状态的看法。 小组成员： Mike Keith ：JPA 1.0联合规范负责人，架构师，Oracle TopLink和Java持久性技术 Ted N...
004---持久对象的生命周期介绍(一)
wjt276的专栏
10-19 169
久化对象的状态： 1、   瞬时对象(Transient Object)：使用new操作符初始化的对象不是立刻就持久的。它们的状态是瞬时的，也就是说它们没有任何跟数据库表相关联的行为，只要应用不再引用这些对象(不再被任何其它对象所引用)，它们的状态将会丢失，并由垃圾回收机制回收 2、   持久化对象(Persistent Object)：持久实例是任何具有数据库标识的实例，它有持久化管理器...
持久对象生命周期
run的博客
05-23 155
                save()or update()                           evict()、close()、lock()瞬时对象——————————&gt;持久对象————————————&gt;托管对象            &lt;——————————              &lt;————————————                    ...
Arrays.asList() 返回的List 进行add() 和remove()操作报错
wangebie的博客
06-19 707
java.util下面的Arrays和Collections两个类不能产生对象，但是却有很多实用的方法。Array.toString()可以快速打印数组对象Arrays.asList()方法可以接受一个数组，并将其转换为List对象。这里要注意，返回的对象java.util.Arrays$ArrayList对象，而不是java.util.ArrayList对象。这两个对象均继承了AbstractL...
持久对象（编程思想）
weixin_33714884的博客
08-18 107
    持有对象 java中引用太多了，所以使用容器装载。 泛型： 容器中装载不同对象，取出时候强制类型转换容易出错 class Apple { private static long counter; private final long id = counter++; public long id() { return id;} } class Orange {} p...
wxWidgets：持久对象概述
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-10 278
wxWidgets：持久对象概述wxWidgets：持久对象概述使用永久窗口定义自定义持久化窗口 wxWidgets：持久对象概述 持久对象只是在销毁时自动保存状态并在重新创建时自动恢复状态的对象，即使在另一个程序调用期间也是如此。 大多数情况下，持久对象实际上是持久窗口，因为在程序重新启动时自动恢复 UI 状态特别方便，但任何类的对象都可以持久化。此外，持久性是以非侵入性方式实现的，因此根本不需要修改原始对象类来添加对保存和恢复其属性的支持。 持久化框架包括以下组件： wxPersistenceManag
Hibernate对象持久化：关联关系详解
在软件开发中，对象持久化是将内存中的对象状态保存到非易失性存储（如数据库）中的过程，以便在后续的程序运行中能够恢复这些对象的状态。Hibernate是一个流行的Java持久化框架，它简化了对象与数据库之间的交互，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值