精华内容
下载资源
问答
  • Hibernate持久化类编写的规则 一、持久化类的概述 1、什么是持久化类 持久化:将内存当中的一个对象持久化到数据库当中的过程。Hibernate框架就是用来进行持久化的框架。 持久化类:一个Java对象与数据库的表建立了...

    Hibernate持久化类编写的规则

    一、持久化类的概述

    1、什么是持久化类

    持久化:将内存当中的一个对象持久化到数据库当中的过程。Hibernate框架就是用来进行持久化的框架。
    持久化类:一个Java对象与数据库的表建立了映射关系,那么这个类在Hibernate当中就可以称为持久化类
    持久化类 = Java类 + 映射文件

    二、持久化类的编写规则

    1、持久化类的编写规则

    (1)对持久化类提供一个无参数的构造方法Hibernate底层需要通过反射来生成实例
    例如:
    在这里插入图片描述
    (2)对属性需要私有,对私有属性提供共有的get和set方法Hibernate当中要获取,设置这个对象的值。
    (3)对持久化类通过一个唯一的标识OID与数据库的主键对应:Java当中通过对象的地址来区分是否是同一个对象,数据库当中通过主键来确定是否是同一个记录,在Hibernate当中通过持久化类的OID的属性来区分是否是同一个对象。
    在这里插入图片描述
    在这里插入图片描述
    (4)持久化类当中的属性尽量使用包装类的类型。Integer Long Double :因为基本数据类型的默认值是0,那么这个0就会有很多的歧义。(包装类的类型默认是null)
    在这里插入图片描述
    (5)持久化类不要使用final进行修饰:延迟加载本身是Hibernate的一个优化的手段。返回的是一个代理对象(Javassist可以对没有实现接口的类来产生代理—使用了十分底层的字节码增强的技术来,继承这个类进行代理,如果该类使用final就不能被继承,也就不能产生代理对象,延迟加载也就失效了,Hibernate的优化也就失效了,load方法就会和get方法变得一样)。

    测试该特性

    public final class Customer {
    	private Long cust_id;
    	private String cust_name;
    	private String cust_source;
    	private String cust_industry;
    	private String cust_level;
    	private String cust_phone;
    	private String cust_mobile;
    	public Long getCust_id() {
    		return cust_id;
    	}
    	public void setCust_id(Long cust_id) {
    		this.cust_id = cust_id;
    	}
    	public String getCust_name() {
    		return cust_name;
    	}
    	public void setCust_name(String cust_name) {
    		this.cust_name = cust_name;
    	}
    	public String getCust_source() {
    		return cust_source;
    	}
    	public void setCust_source(String cust_source) {
    		this.cust_source = cust_source;
    	}
    	public String getCust_industry() {
    		return cust_industry;
    	}
    	public void setCust_industry(String cust_industry) {
    		this.cust_industry = cust_industry;
    	}
    	public String getCust_level() {
    		return cust_level;
    	}
    	public void setCust_level(String cust_level) {
    		this.cust_level = cust_level;
    	}
    	public String getCust_phone() {
    		return cust_phone;
    	}
    	public void setCust_phone(String cust_phone) {
    		this.cust_phone = cust_phone;
    	}
    	public String getCust_mobile() {
    		return cust_mobile;
    	}
    	public void setCust_mobile(String cust_mobile) {
    		this.cust_mobile = cust_mobile;
    	}
    	public Customer() {
    		// TODO Auto-generated constructor stub
    	}
    	public Customer(Long cust_id, String cust_name, String cust_source, String cust_industry, String cust_level,
    			String cust_phone, String cust_mobile) {
    		super();
    		this.cust_id = cust_id;
    		this.cust_name = cust_name;
    		this.cust_source = cust_source;
    		this.cust_industry = cust_industry;
    		this.cust_level = cust_level;
    		this.cust_phone = cust_phone;
    		this.cust_mobile = cust_mobile;
    	}
    	@Override
    	public String toString() {
    		return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + ", cust_source=" + cust_source+ ", cust_industry=" + cust_industry + ", cust_level=" + cust_level + ", cust_phone=" + cust_phone+ ", cust_mobile=" + cust_mobile + "]";
    	}
    }
    

    并且这时返回的对象是真实的对象不是代理对象

    @Test
    	// 查询:
    	public void demo02() {
    		Session session = HibernateUtils.openSession();
    		Transaction tx = session.beginTransaction();// 创建数据库事务对象开启事务
    		// 使用load方法查询
    		Customer customer = session.load(Customer.class, 2l);
    		System.out.println(customer);
    		tx.commit();// 提交事务// load方法发送SQL语句
    		session.close();
    	}
    

    使用Debug模式测试代码
    在这里插入图片描述

    三、主键生成策略

    1、主键的分类:

    A、自然主键
    自然主键:主键的本身就是表当中的一个字段(实体当中的具体的属性)。
    a、创建一个人员表、人员都会有一个身份证号(唯一的不可重复的),使用了身份证号作为主键的,这种主键就称为的自然主键。
    B、代理主键:主键的本身不是表中必须的一个字段(不是实体当中某个具体的属性)。
    a、创建一个人员表,没有使用人员当中的身份证号,用了一个与这个表不相关的字段ID,(PND)。这种主键称为代理主键。
    b、在实际的开发当中,尽量要使用代理主键
    c、一旦自然主键参与到业务逻辑当中。后期就有可能修改源代码。(好的程序的设计要满足OCP原则:对程序的一个扩展是open的。对修改原码是close的)

    2、Hibernate的主键生成策略

    在实际开发中一般是不允许用户手动设置主键,一般会将主键数据库,手动编写程序进行设置。
    在hibernate当中为了减少程序的编写,提供了很多的主键生成的策略。
    Aincrement:hibernate中提供的一个自动增长的一个机制。(mysql当中不会选自动增长,使用的Hibernate当中的)适用于short,int,long类型的主键。
    在单线程的程序当中使用
    a、首先发送一条语句,select max(id) from 查到表id:然后让id+1作为下一条记录的一个记录的主键。
    Bidentity:适用于short、int、long类型的主键,使用的是数据库底层的自动增长的机制。适用于有自动增长机制的数据库(MySQL,MSSQL)但是Oracle没有找到增长机制的。
    Csequnence:序列 适用于short、int、long类型的主键,采用的是序列的方式。(Oracle支持序列)。MySQL就不能使用sequnence
    D : uuid:适用于字符串主键。使用Hibernate当中一种随机方式生成字符串类型的主键
    Enative:本地策略,可以在identity和sequnence之间来进行自动切换
    Fassigned:Hibernate会放弃外键的管理,需要通过自己手动编写程序或者用户自己进行设置。
    Gforeign:外部的。一对一的一种关联映射的情况下使用。(例如两个表的主键是一一对应的)

    3、上述主键生成策略的案例

    Aincrement:
    在映射文件当中修改对应的生成键策略对应的class
    在这里插入图片描述

    public class HibernateUtils {
    	public static final Configuration cfg;
    	public static final SessionFactory sf;
    	static {
    		cfg = new Configuration().configure();
    		sf = cfg.buildSessionFactory();
    	}
    	public static Session openSession() {
    		return sf.openSession();
    	}
    }
    
    public class HibernateDemo1 {
    	@Test
    	// 保存一条记录
    	//演示increment
    	public void demo01() {
    		Session session = HibernateUtils.openSession();
    		Transaction transaction = session.beginTransaction();
    		Customer customer = new Customer();
    		customer.setCust_name("王细");
    		session.save(customer);
    		transaction.commit();
    		session.close();
    	}
    	@Test
    	// 保存一条记录
    	//演示increment
    	public void demo02() {
    		Session session = HibernateUtils.openSession();
    		Transaction transaction = session.beginTransaction();
    		Customer customer = new Customer();
    		customer.setCust_name("王被");
    		session.save(customer);
    		transaction.commit();
    		session.close();
    	}
    }
    

    1、使用Debug模式分别调试两个方法,分别在不同的线程当中调试
    当第一个方法执行时
    会先查询表当中的id的值,然后加1
    将对应的属性的值放入到加1的id对应的表的项内
    此时将数据插入到对应的表当中后,不提交事务

    2、开始用第二个方法
    会先查询表当中的id的值,然后加1
    将对应的属性的值放入到加1的id对应的表的项内
    对应相同的id上插入对应的数据,然后会报错
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    Bidentity:
    在映射文件当中修改对应的生成键策略对应的class
    在这里插入图片描述

    @Test
    	// 保存一条记录
    	//演示identity
    	public void demo03() {
    		Session session = HibernateUtils.openSession();
    		Transaction transaction = session.beginTransaction();
    		Customer customer = new Customer();
    		customer.setCust_name("王被");
    		session.save(customer);
    		transaction.commit();
    		session.close();
    	}
    

    使用数据库的自动增长机制
    在这里插入图片描述

    D : uuid:
    将Customer的id改为String类型的
    在这里插入图片描述
    在映射文件当中修改对应的生成键策略对应的class
    在这里插入图片描述

    @Test
    	// 保存一条记录
    	//演示uuid
    	public void demo04() {
    		Session session = HibernateUtils.openSession();
    		Transaction transaction = session.beginTransaction();
    		Customer customer = new Customer();
    		customer.setCust_name("王被");
    		session.save(customer);
    		transaction.commit();
    		session.close();
    	}
    

    在这里插入图片描述
    在这里插入图片描述
    Fassigned:
    在映射文件当中修改对应的生成键策略对应的class
    在这里插入图片描述
    直接执行会报错,因为,没有设置主键的值,需要手动设置
    在这里插入图片描述
    在这里插入图片描述

    @Test
    	// 保存一条记录
    	//演示assigned
    	public void demo05() {
    		Session session = HibernateUtils.openSession();
    		Transaction transaction = session.beginTransaction();
    		Customer customer = new Customer();
    		customer.setCust_id(4556L);
    		customer.setCust_name("王被");
    		session.save(customer);
    		transaction.commit();
    		session.close();
    	}
    

    在这里插入图片描述
    一般用native和identity的比较多(int Long 的主键)
    映射文件当中
    在这里插入图片描述
    在这里插入图片描述

    四、持久化类的三种状态

    Hibernate是持久层的一个框架,通过持久化类完成ORM操作。Hibernate为了更好的管理持久化类,就将持久化类分为三种状态。
    持久化类=Java类+映射

    1、瞬时态:没有持久化标识OID,没有被纳入Session对象的管理

    这种对象没有唯一的标识OID,没有被session所管理。

    2、持久态:有持久化标识OID,已经被纳入Session对象的管理

    这种对象有唯一的标识OID,被session所管理,这种对象就是持久态的对象。
    持久化类的持久态对象。可以自动更新数据库

    3、托管态:有持久化标识OID,但没有被Session对象管理

    这种对象有唯一标识的OID,没有被session管理,这个就称为托管态的对象。

    区分这三种状态的对象

    在这里插入图片描述

    五、Hibernate持久化类的三种状态转换

    三种状态转换图
    在这里插入图片描述

    1:瞬时态的对象

    A :获得瞬时态对象
    获得:将与表建立好映射的类,new创建该类的对象,就创建了session的瞬时太对象
    在这里为

    Customer customer = new Customer();
    

    B:状态转换
    瞬时态,可以转换成为持久态(瞬时态->持久态)

    save(Object obj);//通过save方法将瞬时态转换成为持久态
    saveOrUpdate(Object obj);
    

    瞬时太,可以转换成为托管态(瞬时太->托管态)

    customer.setCust_id(1);//对象设置了id
    

    2:持久态的对象

    A :获得持久态对象

    get(Object.class,id);
    Customer customer = session.get(Customer.class,1L);//直接获得持久态对象
    
    load(Object.class,id);
    Customer customer = session.load(Customer.class, 2l);
    
    find(Object.class,id);
    Customer customer = session.find(Customer.class, 2l);
    
    iterate(Object.class,id);
    Customer customer = session.iterate(Customer.class, 2l);
    

    B:状态转换
    持久态,可以转换成为瞬时态(持久态->瞬时态)

    delete();、
    session.delete(Object obj);
    

    持久态,可以转换成为托管态(持久态->托管态)

    close();
    session.close();
    
    clear();
    session.clear();
    
    evict(Object obj);
    session.evict();
    

    3:托管态的对象

    A :获得托管态对象

    Customer customer = new Customer();
    customer.setCust_id(1L);
    

    B:状态转换
    托管态,可以转换成为持久态(托管态->持久态)

    update(Object obj);
    session.update(Object obj);
    saveOrUpdate(Object obj);
    session.saveOrUpdate(Object obj);
    

    在这里插入图片描述
    托管态,可以转换成为瞬时态(托管态->瞬时态)

    Customer customer = new Customer();
    customer.setCust_id(null);
    

    六、Hibernate持久态对象特性

    1、持久化类的持久态对象自动更新数据库

    @Test
    	// 持久态对象可以自动更新数据库----》依赖了Hibernate里面的一级缓存
    	public void demo02() {
    		Session session = HibernateUtils.openSession();// 链接数据库开启session域
    		Transaction transaction = session.beginTransaction();// 开启事务
    		//获得持久态对象
    		Customer customer = session.get(Customer.class, 1l);//持久态对象可以自动更新数据库
    		//当对应更改的数据与数据库当中的数据不同的时候,就不会更改数据库当中的数据
    		//当对应数据的数据与数据库当中的数据不同的时候就会更改其中的数据
    		customer.setCust_name("王南");
    		//这里可以不用去更新数据库
    		//session.update(customer);
    		transaction.commit();
    		session.close();// 关闭session对象,销毁对象
    	}
    
    展开全文
  • 持久化类设计

    千次阅读 2014-10-12 19:23:33
    持久化类设计 注意: 持久化类通常建议有一个持久化标识符(ID) 持久化标识符通常建议使用封装类(基本类型有默认值) 持久化类通常建议手动给定一个无参数的构造器(因为有一些操作,是反射进行的) 属性通常建议...
    持久化类设计
    注意:
    持久化类通常建议有一个持久化标识符(ID)
    持久化标识符通常建议使用封装类(基本类型有默认值)
    持久化类通常建议手动给定一个无参数的构造器(因为有一些操作,是反射进行的)
    属性通常建议提供getting、setting方法
    持久化类不能是final
    持久化类中如果使用了集合类型属性,只能使用接口类型进行声明(List,Set,Map)
    展开全文
  • Hibernate中的持久化类

    千次阅读 2017-02-18 16:11:41
    Hibernate中的持久化类一、什么是持久化类:持久化是将程序数据在持久状态和瞬时状态间转换的机制。 持久化类(persistent class):是指它的实例可以被hibernate持久化地保存到数据库中,并且能从数据库读取的类。...

    Hibernate中的持久化类

    一、什么是持久化类:

    持久化是将程序数据在持久状态和瞬时状态间转换的机制。
    持久化类(persistent class):是指它的实例可以被hibernate持久化地保存到数据库中,并且能从数据库读取的类。

    持久化类 = 实体类 + 映射文件。

    二、持久化类的编写规范

    1. 提供一个无参数 public访问控制符的构造器:因为会用到反射。
    2. 提供一个标识属性,映射数据表主键字段 。
      • java区分两个对象是否是同一个对象,使用地址判断。
      • 数据库区分两条记录是否一致,使用主键判断。
      • Hibernate区分持久化对象是否是同一个对象,根据唯一标识判断。
    3. 为所有属性提供public访问控制符的set/get方法,框架中存值和取值的时候使用。
    4. 标识属性应尽量使用基本数据类型的包装类型
      • 使用基本类型的包装类型一个好处是,可以区分数据是没有传值默认生成的,还是本身就是这个默认值,比如一个表示数量的整数类型,如果使用int,没有传值时,数据库中会出现0,如果使用Integer,没有传值时,数据库中是null。
    5. 持久化类尽量不要使用final进行修饰。
      • 用final修饰的类不能被继承,因此无法生成代理对象,由于延迟加载返回的是代理对象,因此延迟加载就会失效。
    展开全文
  • 主要介绍了Java的Hibernate框架中的Session和持久化类,Hibernate是Java的SSH三大web开发框架之一,需要的朋友可以参考下
  • 主要介绍了Java的Hibernate框架中的持久化类和映射文件,Hibernate是Java的SSH三大web开发框架之一,需要的朋友可以参考下
  • 主要介绍了Myeclipse 自动生成可持久化类的映射文件的方法的相关资料,这里提供了详细的实现步骤,需要的朋友可以参考下
  • 1、什么是持久化类持久化类:指的是一个Java类和数据库表建立了映射关系 持久化类=Java类+映射文件 2、持久化类编写规则: (1)对持久化类提供无参数的构造方法:Hibernate的底层需要反射创建持久化类的实例...

    1、什么是持久化类:

    持久化类:指的是一个Java类和数据库表建立了映射关系

    持久化类=Java类+映射文件

    2、持久化类编写规则:

    (1)对持久化类提供无参数的构造方法:Hibernate的底层需要反射创建持久化类的实例。

    (2)对持久化类的属性私有化,对私有属性提供公有的getset方法。

    (3)持久化类要有一个唯一标识OID与表的主键对应

    (4)持久化类的属性尽量使用包装类。

    (5)持久化类尽量不要使用final修饰:延迟加载,需要产生代理对象,这个代理对象使用javassit技术实现,就是产生了一个子类对象。

                          解释例子:使用load方法获取数据时,会延迟加载,产生代理对象,但是用final修饰后,不会产生延迟加载和代理对象。

    展开全文
  • Hibernate采用低侵入式设计,这种设计对持久化类几乎不作任何要求。也就是说,Hibernate操作的持久化类基本上都是普通、传统的Java对象(POJO)。对于这种Java类,程序开发中可以采用更为灵活的领域建模方式。 虽然...
  • Android中使用Ormlite实现持久化(二)--持久化类的详细配置.docx
  • 持久化类主键生成策略+例子 jpa 4种 hibernate 13种
  • 二:hibernate的持久化类和对象标识符

    千次阅读 2017-07-03 21:34:54
    二 hibernate的持久化类和对象标识符 1.1持久化类的编写规范 1.1.1什么是持久化类: Hibernate是持久层的ORM映射框架,专注于数据的持久化工作。所谓的持久化,就是将内存中的数据永久存储到关系型数据库中。那么...
  • Hibernate中根据数据库中各表,使用myEclipse的返向工程,自动生成hibernate.cfg.xml 配置文件 与person.hbm.xml映射文件和持久化类 (图文介绍)
  • 有碰到过改变了一个持久化类的值但是没有主动更新到数据库结果hibernate自动把值更新到数据库了。看了网上的一些帖子和解答感觉语焉不详,说什么持久化类只要做了改变hibernate就会自动更新到数据库,照这个说法我们...
  • 利用XDoclet从Java持久化类生成hibernate mapping,hibernate.cfg.xml和mysql数据库脚本。
  • 持久化类 首先,开宗明义,再一次提醒大家,持久化类=Java类+映射配置文件。 持久化类的三种状态 Hibernate是一个持久层框架,它通过持久化类来完成ORM基本操作。Hibernate为了更好的管理持久化类,于是它就将持久化...
  • 一个简单的java持久化类,接受ResultSet参数,转化为对象数组
  • Hibernate持久化类什么是持久化类呢?在Hibernate中持久化类的英文名称是Persistent Object(简称PO),PO=POJO+hbm映射配置文件。 对于Hibernate中的PO,有如下编写规则: 必须提供一个无参数的public构造方法。 ...
  • 持久化类的属性及访问方法

    千次阅读 2010-10-20 23:59:00
    持久化类的访问者有两个,一是JAVA应用程序,二是hibernate 写:Java应用程序通过setter设置持久化对象的属性,hibernate通过getter获取持久化对象的属性并生成相应的SQL语句对表格进行操作。 读:hibernate通过...
  • 持久化java必须遵循的原则: 1.通常这个需要一个id.建议一般使用封装类型 2.这个不能是final修饰的 3.需要给这个提供一个无参数的构造器 4.需要给所有属性提供getter/setter方法 5.如果涉及集合数据的...
  • Hibernate持久化类的要求

    千次阅读 2010-02-28 23:24:00
    我们在使用Hibernate的持久化类时,应该遵守如下规则:1、提供一个无参的构造器:方便Hibernate使用Constructor.newInstance()来创建持久化类的实例。为了方便Hibernate的运行时生成代理,构造器的访问控制修饰符...
  • PO类(持久化类

    千次阅读 2016-07-04 08:47:58
    PO:Persistent Object 持久化对象。 持久化对象,在Hibernate经常会遇见这样的概念。Hibernate实体状态有三种状态:瞬时态,持久态,游离态。 1).瞬时态(暂态):(Transient)实体在内存中自由存在,它与数据库...
  • Hibernate持久化类中对象的3种状态

    千次阅读 2014-10-10 23:13:11
    Hibernate中,持久化类的实例对象的状态可以分为3类: 瞬时对象(Transient Objects):处于临时状态的对象属于瞬时对象。 java对象何时会进入临时状态? (1) 当通过new语句刚创建了一个Java对象,它处于临时...
  • 本文主要介绍如何使用MyEclipse Hibernate Tool工具自动生成持久化类。 如果DB Browser视图没有打开,则通过Window—>Show View—>Other,选择DB Browser项。   在DB Browser视图中点击New按钮。 在...
  • 在实体类中我要添加一个额外的字段用来存储一些变量 ,但是在ORM持久化类的时候我用了@Transient,最后还是报错表中没有这个列 。找了好久导包到错了, 但是用这个注解的时候一定要注意 :就是导入包import javax....
  • hibernate持久化类映射文件*.hbm.xml

    千次阅读 2013-03-19 20:09:20
    通过 POJO 类的数据库映射文件,Hibernate可以理解持久化类和数据表之间的对应关系,也可以理解持久化类属性与数据库表列之间的对应关系。 在运行时 Hibernate 将根据这个映射文件来生成各种 SQL 语句。 hibernate...
  • 持久化类: package com.hisaige.entity; @Entity @Table(name="user_info") public class User { 获取数据库表名: Class<?> cls = Class.forName("... S...
  • hibernate由数据库表导为映射文件和持久化类的流程 1.新建一个web项目,加一个包(这个包里加映射文件和持久化类),加一个配置文件,这个文件内容,可以复制。也可以接下来通过导成hibernate工程的时候自动生成。 ...
  • Hibernate Reverse Engineering 生成ORM持久化类的问题 报错1: 点击"Hibernate Reverse Engineering"出现如下错误: "This wizard generates Hibernate3.0 OR mappings(*.hbm.xml).The project your select ...
  • 在Hibernate应用中,持久化类的访问方法被谁调用? 选自> 作者:孙卫琴 来源:www.javathinker.org 如果转载,请标明出处,谢谢 在Hibernate应用中,持久化类的访问方法有两个调用者: (1) Java应用程序:调用...
  • java持久化类为什么要实现序列化

    千次阅读 2016-09-28 16:26:06
    之前听老师讲过在Java里面,有时候要实现序列,也就是和Serializable接口相关的东西,但感觉当时好抽象忘了,上网上找了好久,看到了一篇博文。 ====================================================...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 410,611
精华内容 164,244
关键字:

持久化类