码迷,mamicode.com
首页 > Web开发 > 详细

Hibernate---对象的三种状态

时间:2018-06-06 10:50:49      阅读:227      评论:0      收藏:0      [点我收藏+]

标签:关系   host   use   自己   自己实现   ppi   runtime   用户名   begin   

      Hibernate---对象的三种状态

  简而言之,hibernate本就是面向对象的基于ORM的框架,位于dao层,对数据进行操作的框架。我就谈谈hibernate的对象的三种状态。他们分别为:游离,持久和瞬时。通过代码来详解一下吧。

  hibernate.cgf.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 元素用于配置Hibernate中的属性
            键:值
        -->
        <!-- hibernate.connection.driver_class : 连接数据库的驱动  -->
        <property name="hibernate.connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
        <!-- hibernate.connection.username : 连接数据库的用户名 -->
        <property name="hibernate.connection.username">root</property>
        <!-- hibernate.connection.password : 连接数据库的密码 -->
        <property name="hibernate.connection.password">root</property>
        <!-- hibernate.connection.url : 连接数据库的地址,路径 -->
        <property name="hibernate.connection.url">
            jdbc:mysql://localhost:3306/Hibernate
        </property>

        <!-- show_sql: 操作数据库时,会 向控制台打印sql语句 -->
        <property name="show_sql">true</property>
        <!-- format_sql: 打印sql语句前,会将sql语句先格式化  -->
        <property name="format_sql">true</property>
        <!-- hbm2ddl.auto: 生成表结构的策略配置
            update(最常用的取值): 如果当前数据库中不存在表结构,那么自动创建表结构.
            如果存在表结构,并且表结构与实体一致,那么不做修改
            如果存在表结构,并且表结构与实体不一致,那么会修改表结构.会保留原有列.
            create(很少):无论是否存在表结构.每次启动Hibernate都会重新创建表结构.(数据会丢失)
            create-drop(极少): 无论是否存在表结构.每次启动Hibernate都会重新创建表结构.每次Hibernate运行结束时,删除表结构.
            validate(很少):不会自动创建表结构.也不会自动维护表结构.Hibernate只校验表结构. 如果表结构不一致将会抛出异常.
        -->
        <property name="hbm2ddl.auto">update</property>

        <!-- 数据库方言配置
            org.hibernate.dialect.MySQLDialect (选择最短的)
        -->
        <property name="hibernate.dialect">
            org.hibernate.dialect.MySQLDialect
        </property>


        <!-- hibernate.connection.autocommit: 事务自动提交
            <property name="hibernate.connection.autocommit">true</property>
        -->

        <!-- 将Session与线程绑定=> 只有配置了该配置,才能使用getCurrentSession -->
        <property name="hibernate.current_session_context_class">
            thread
        </property>
        <!-- 引入ORM 映射文件
            填写src之后的路径
        -->
        <mapping resource="resource/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

  user.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">
<!-- ORM元数据  表对象关系映射文件
    package : 配置该配置文件中类所在的包.  -->
<hibernate-mapping package="com.huhu.domain">
    <!-- class: 配置实体与表的关系
        name : 填写实体的完整类名
        table: 与实体对应表的名称
        dynamic-insert:动态插入 默认值是false
                        true=>如果字段值为null,不参与insert语句
         dynamic-update:动态更新  默认值"false"
                         true=> 没改动过的属性,将不会生成到update语句中
     -->
    <class name="com.huhu.domain.User" table="t_user">
        <!-- id: 配置实体与表中 id对应
            name: user对象中标识主键的属性名称
            column: 主键在表中的列名
            length: 列的数据长度
            unsaved-value(不常用): 指定主键为什么值时,当做null来处理.
           access(强烈推荐不要用):field 那么在操作属性时,会直接操作对应的字段而不是get/set方法
         -->
        <id name="id" column="id">
            <!-- generator:主键生成策略
                     1.increment  数据库自己生成主键. 先从数据库中查询最大的ID值,将ID值加1作为新的主键
                    2.identity  依赖于数据的主键自增功能
                    3.sequence	序列,依赖于数据中的序列功能(Oracle).
                    4.hilo(纯了解,永远用不到) : Hibernate自己实现序列的算法,自己生成主键. (hilo算法 )
                    5.native 自动根据数据库判断,三选一. identity|sequence|hilo
                    6.uuid  生成32位的不重复随机字符串当做主键
                    7.assigned 自己指定主键值. 表的主键是自然主键时使用.

             -->
            <generator class="native"></generator>
        </id>
        <!-- property : 实体中属性与表中列的对应
             name : 实体中属性名称
             column : 表中列的名称
             length : 数据长度
             precision: 小数点后的精度
             scale:	有效位数
             insert(一般不用): 该属性是否加入insert语句.
             update(一般不用): 该属性是否加入update语句.
             not-null : 指定属性的约束是否使用 非空
             unique : 指定属性的约束是否使用 唯一
         -->
        <!--
            type: 表达该属性的类型
            可以用三种方式指定属性
            java类型		 		 数据库类型指定			Hibernate类型指定
            java.lang.String	varchar				string
         -->
        <property name="name" column="name"></property>
        <property name="password" column="password"></property>
    </class>
</hibernate-mapping>

  User

package com.huhu.domain;

// Hibernate
public class User {
    private Integer id;
    private String name;
    private String password;

    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 getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", password=" + password
                + "]";
    }


}

  HibernateUtils

package com.huhu.utils;

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

//完成Hibernate工具类
//封装配置文件读取操作
//封装Sessionfactroy创建操作
//封装session获得操作
public class HibernateUtils {

	private static SessionFactory sf;
	
	static{
		//1加载配置
		Configuration  conf = new Configuration().configure();
		//2 根据Configuration 配置信息创建 SessionFactory
		sf = conf.buildSessionFactory();
		//
		Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("虚拟机关闭!释放资源");
				sf.close();
			}
		}));
		
	}
	
	
	public static org.hibernate.Session  openSession(){
				
				//3 获得session
				Session session = sf.openSession();
				
				return session;
	}
	
	public static org.hibernate.Session  getCurrentSession(){
		//3 获得session
		Session session = sf.getCurrentSession();
		
		return session;
}
	
	public static void main(String[] args) {
		System.out.println(openSession());
	}
}

  HibernateDemo1

package com.huhu.a_state;

import com.huhu.domain.User;
import com.huhu.utils.HibernateUtils;
import org.hibernate.Session;

/**
 * 对象的三种状态
 */
public class HibernateDemo1 {


    //三种状态
    public void fun1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();
        //--------------------------------------
        User u = new User();          //status : 瞬时状态
        u.setName("tom");           //status : 瞬时状态
        u.setPassword("1234");      //status : 瞬时状态

        //保存
        session.save(u);            //status : 持久状态
        //调用save方法时,数据库有没有对应记录
        //没有记录,但最终会被同步到数据库中,仍时持久状态
        //--------------------------------------
        session.getTransaction().commit();      //status : 持久状态
        session.close();            //status : 游离状态
    }


    // 三种状态的转换  瞬时=》持久
    public void fun2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();
        //--------------------------------------
        User u = new User();           //status : 瞬时状态
        u.setName("he");             //status : 瞬时状态
        u.setPassword("123456");     //status : 瞬时状态

        session.save(u);             //status : 持久状态
        //--------------------------------------
        session.getTransaction().commit();      //status : 持久状态
        //事务提交时会把持久对象保存到数据库
        //increment=>hibernate 自动查询最大id,然后生成主键
        //assigned =>自动生成主键
        session.close();
    }

    // 瞬时=》游离 瞬时:没有关联没有id 游离:没有关联有id(与数据库对应的id)
    public void fun3() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();
        //--------------------------------------//status : 持久状态
        User u = new User();
        u.setId(2);         //此时为游离状态
        //--------------------------------------
        session.getTransaction().commit();      //status : 持久状态
        //事务提交时会把持久对象保存到数据库
        session.close();
    }

    //持久=》瞬时1 持久:有关联,有id,瞬时:无关联无id
    public void fun4() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();
        //--------------------------------------//status : 持久状态
        //通过get方法,得到持久状态对象
        User u = (User) session.get(User.class, 2); //持久状态
        //--------------------------------------
        session.getTransaction().commit();
        //事务提交时会把持久对象保存到数据库
        session.close();  //游离状态
        u.setId(null);
    }

    //持久=》瞬时1  持久:有关联,有id,瞬时:无关联无id
    public void fun5() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();
        //--------------------------------------//status : 持久状态
        //通过get方法,得到持久状态对象
        User u = (User) session.get(User.class, 4); //持久状态
        session.evict(u);       //将User对象和session的关联移除
        u.setId(null);          //瞬时对象
        //--------------------------------------
        session.getTransaction().commit();
        session.save(u);
        //事务提交时会把持久对象保存到数据库
        session.close();  //游离状态
    }

    //  持久=》游离   持久:有关联,有id
    public void fun6() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();
        //--------------------------------------//status : 持久状态
        //通过get方法,得到持久状态对象
        User u = (User) session.get(User.class, 4); //持久状态
        session.evict(u);       //将User对象和session的关联移除
        //--------------------------------------
        session.getTransaction().commit(); //游离
        session.close();  //游离状态
    }

    // 游离=》瞬时  瞬时:无关联无id
    public void fun7() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();
        //--------------------------------------//status : 持久状态
        //通过get方法,得到持久状态对象
        User u = (User) session.get(User.class, 4); //持久状态

        session.evict(u);       //瞬时
        u.setId(null);          //瞬时
        //--------------------------------------
        session.getTransaction().commit(); //瞬时
        session.close();  //瞬时状态
    }

    //    游离=》持久  是否与session关联
    public void fun8() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();
        //--------------------------------------//status : 持久状态
        //通过get方法,得到持久状态对象
        User u = (User) session.get(User.class, 4); //持久状态

        session.evict(u);       //游离
        session.update(u);      //持久
        //--------------------------------------
        session.getTransaction().commit(); //持久  打印updata语句
        session.close();  //瞬时状态
    }

    public void fun9() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();
        //--------------------------------------//
        //通过get方法,得到持久状态对象
        User u = (User) session.get(User.class, 4);

        u.setName("nenen");
        //--------------------------------------
        session.getTransaction().commit();
        session.close();  //瞬时状态
    }

    public static void main(String[] args) {
        HibernateDemo1 d = new HibernateDemo1();
        //d.fun1();
        d.fun9();
    }
}

 

    代码显而易见。如果觉得不明显再来一个图吧。

  技术分享图片

 

  总结下吧:

 三种状态有什么用:

    1.持久状态:我们使用hibernate主要时为了持久化数据

    2.对于对象的状态: 我们期望我们现需要同步到数据库的数据,都被转化为持久化 

 持久话对象的特点:
    hibernate会自动将持久话对象的变化同步到数据库.

  所以说hibernate是一个面向对象的框架,利用对象的操作数据。
  

 

Hibernate---对象的三种状态

标签:关系   host   use   自己   自己实现   ppi   runtime   用户名   begin   

原文地址:https://www.cnblogs.com/meiLinYa/p/9143184.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!