HibernateTools实现pojo类 数据库schma mapping映射的相互转换

标签: hibernatetools pojo 数据库 | 发表时间:2014-05-31 08:02 | 作者:xqf309
出处:http://blog.csdn.net

核心

利用HibernateTools,用POJO类,Mapping映射文件,数据库表有其中的一项,就能生成其他两项。


概述

    在使用Hibernate开发系统持久层时,按照一般开发流程,首先会从业务分析中获得业务实体,从而获得系统中真正需要的实体类,然后写Hibernate的mapping映射文件,最后根据映射文件,生成数据库表,以上这三步是Hibernate开发的起始。

    根据开发习惯的不同,有些项目组可能会先写POJO类,有的项目可能会先设计数据库,有的项目组可能先写映射文件,其实完成其中的一项时,类结构或者表结构就可以确定了。

既然已经能确定结构了,完全可以使用工具来代替手工完成剩余的工作。

 

前提

    安装Eclipse插件HibernateTools,eclipse插件安装百度下教程非常多,建议采用copy安装或者link安装,再有就是HibernateTools的版本对应着特定的Eclipse版本,所以安装前请先检查自己的eclipse版本。

 

   然后建立项目,本文建立的是Dynamic Web Project,采用了mysql数据库,建立项目后,引入mysql的驱动jar,引入Hibernate(本文用了4.3.5版本)的包,即lib下required文件夹中所有jar

 

   安装完了插件,首先利用tool生成Hibernate配置文件,项目右键-->new,安装完HibernateTools后,多了4种类型的文件,选择第一种:


根据使用的数据库,填入必须的属性:


生成hibernate.cfg.xml的代码:

<span style="font-family:KaiTi_GB2312;font-size:18px;"><?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="hibernate.bytecode.use_reflection_optimizer">false</property>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.password">123456</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.search.autoregister_listeners">false</property>
       
        
    </session-factory>
</hibernate-configuration></span>

相互转换

接下可以进入正题了,本文分别从三项中的每一项入手,生成其他两项。 

思路一:由POJO类生成mapping映射文件和DDL

POJO类的代码写起来非常方便,因此首先介绍这种方法,个人认为这种方法效率最高。首先建立两个POJO类

package org.hibernate.test;


public class Student implements java.io.Serializable {

	private int id;
	private String name;

	public Student() {
	}

	public Student(int id) {
		this.id = id;
	}

	public Student(int id, String name) {
		this.id = id;
		this.name = name;
	}

	public int getId() {
		return this.id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

package org.hibernate.test;


import java.util.ArrayList;
import java.util.List;


public class Class implements java.io.Serializable {

	private int id;
	private String name;
	private List students = new ArrayList(0);

	public Class() {
	}

	public Class(int id) {
		this.id = id;
	}

	public Class(int id, String name, List students) {
		this.id = id;
		this.name = name;
		this.students = students;
	}

	public int getId() {
		return this.id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public List getStudents() {
		return this.students;
	}

	public void setStudents(List students) {
		this.students = students;
	}

}

接下来一步一步生成另外两项,首先项目右键-->new,选择Hibernate下面的第四项,建立mapping映射文件,根据已存在的POJO类,生成Mapping文件


添加两个已经存在的POJO类


下一步,可以预先查看生成的hbm.xml文件,有特殊要求的可以再生成的文件基础上稍作修改。

生成代码:

<span style="font-family:KaiTi_GB2312;font-size:18px;"><?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">
<!-- Generated 2014-5-30 21:29:20 by Hibernate Tools 4.0.0 -->
<hibernate-mapping>
    <class name="org.hibernate.test.Student" table="STUDENT">
        <id name="id" type="int">
            <column name="ID" />
            <generator class="assigned"></generator>
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
    </class>
</hibernate-mapping></span>

<span style="font-family:KaiTi_GB2312;font-size:18px;"><?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">
<!-- Generated 2014-5-30 21:29:20 by Hibernate Tools 4.0.0 -->
<hibernate-mapping>
    <class name="org.hibernate.test.Class" table="CLASS">
        <id name="id" type="int">
            <column name="ID" />
            <generator class="assigned"></generator>
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <list name="students" inverse="false" table="STUDENT" lazy="true">
            <key>
                <column name="ID" />
            </key>
            <list-index>
                <column name="idx" />
            </list-index>
            <one-to-many class="org.hibernate.test.Student" />
        </list>
    </class>
</hibernate-mapping></span>

mapping映射文件生成了,接下来生成ddl,项目右键-->new,选择Hibernate Console  Configuration



选择好对应的项后,finish,然后需要在工具栏添加Hibernate code Generation,Windows-->Customer Perspective


然后工具栏多了一个很像运行按钮的图标,单击下拉按钮,选第二项




单击Exporters选项卡,可以看到HibernateTools工具能导出和生成的项很多,可以根据配置有针对性的选择自己想要的项,这里我们勾选Schema Export,然后单击图标1下面的Properties的Add,后出现图标2所示的窗体


选择第二项,这就是要生成我们想要的ddl,如图,当然上图还勾选了DAO Code,生成了操作试题的DAO代码(HibernateTools确实很贴心)


这是生成后的图片

ddl的建表语句:

<span style="font-family:KaiTi_GB2312;font-size:18px;">create table CLASS (ID integer not null, NAME varchar(255), primary key (ID));
create table STUDENT (ID integer not null, NAME varchar(255), idx integer, primary key (ID));
alter table STUDENT add index FKBACA0E1BE081A5FD (ID), add constraint FKBACA0E1BE081A5FD foreign key (ID) references CLASS (ID);
</span>


DAO代码如下:

<span style="font-family:KaiTi_GB2312;font-size:18px;">package org.hibernate.test;

// Generated 2014-5-30 23:18:05 by Hibernate Tools 4.0.0

import java.util.List;
import javax.naming.InitialContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.LockMode;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Example;

/**
 * Home object for domain model class Class.
 * @see org.hibernate.test.Class
 * @author Hibernate Tools
 */
public class ClassHome {

	private static final Log log = LogFactory.getLog(ClassHome.class);

	private final SessionFactory sessionFactory = getSessionFactory();

	protected SessionFactory getSessionFactory() {
		try {
			return (SessionFactory) new InitialContext()
					.lookup("SessionFactory");
		} catch (Exception e) {
			log.error("Could not locate SessionFactory in JNDI", e);
			throw new IllegalStateException(
					"Could not locate SessionFactory in JNDI");
		}
	}

	public void persist(Class transientInstance) {
		log.debug("persisting Class instance");
		try {
			sessionFactory.getCurrentSession().persist(transientInstance);
			log.debug("persist successful");
		} catch (RuntimeException re) {
			log.error("persist failed", re);
			throw re;
		}
	}

	public void attachDirty(Class instance) {
		log.debug("attaching dirty Class instance");
		try {
			sessionFactory.getCurrentSession().saveOrUpdate(instance);
			log.debug("attach successful");
		} catch (RuntimeException re) {
			log.error("attach failed", re);
			throw re;
		}
	}

	public void attachClean(Class instance) {
		log.debug("attaching clean Class instance");
		try {
			sessionFactory.getCurrentSession().lock(instance, LockMode.NONE);
			log.debug("attach successful");
		} catch (RuntimeException re) {
			log.error("attach failed", re);
			throw re;
		}
	}

	public void delete(Class persistentInstance) {
		log.debug("deleting Class instance");
		try {
			sessionFactory.getCurrentSession().delete(persistentInstance);
			log.debug("delete successful");
		} catch (RuntimeException re) {
			log.error("delete failed", re);
			throw re;
		}
	}

	public Class merge(Class detachedInstance) {
		log.debug("merging Class instance");
		try {
			Class result = (Class) sessionFactory.getCurrentSession().merge(
					detachedInstance);
			log.debug("merge successful");
			return result;
		} catch (RuntimeException re) {
			log.error("merge failed", re);
			throw re;
		}
	}

	public Class findById(int id) {
		log.debug("getting Class instance with id: " + id);
		try {
			Class instance = (Class) sessionFactory.getCurrentSession().get(
					"org.hibernate.test.Class", id);
			if (instance == null) {
				log.debug("get successful, no instance found");
			} else {
				log.debug("get successful, instance found");
			}
			return instance;
		} catch (RuntimeException re) {
			log.error("get failed", re);
			throw re;
		}
	}

	public List findByExample(Class instance) {
		log.debug("finding Class instance by example");
		try {
			List results = sessionFactory.getCurrentSession()
					.createCriteria("org.hibernate.test.Class")
					.add(Example.create(instance)).list();
			log.debug("find by example successful, result size: "
					+ results.size());
			return results;
		} catch (RuntimeException re) {
			log.error("find by example failed", re);
			throw re;
		}
	}
}</span>

到此,我们就由POJO类,生成了hbm.xml文件和DDL


思路二:由hbm.xml生成POJO类和DDL

...

思路三:由数据库表(或DDL)生成POJO类和hbm.xml

...


思路二三请见下一博客!


邮件地址:[email protected],转载请注明出处!


作者:xqf309 发表于2014-5-31 0:02:27 原文链接
阅读:151 评论:0 查看评论

相关 [hibernatetools pojo 数据库] 推荐:

HibernateTools实现pojo类 数据库schma mapping映射的相互转换

- - CSDN博客架构设计推荐文章
利用HibernateTools,用POJO类,Mapping映射文件,数据库表有其中的一项,就能生成其他两项.     在使用Hibernate开发系统持久层时,按照一般开发流程,首先会从业务分析中获得业务实体,从而获得系统中真正需要的实体类,然后写Hibernate的mapping映射文件,最后根据映射文件,生成数据库表,以上这三步是Hibernate开发的起始.

HibernateTools实现pojo类 数据库schma mapping映射的相互转换 二

- - CSDN博客Web前端推荐文章
接着上一篇博客: HibernateTools实现pojo类 数据库schma mapping映射的相互转换. 思路二:由数据库表,生成Mapping映射文件和POJO类.    虽然可以实现,但个人觉着先设计数据库,然后再生成类不符合Hibernate的面对对象持久化的思维方式. 好了,还是说步骤吧,首先在test数据库建立两张表,分别为course表和teacher表.

POJO中使用ThreadLocal实现Java嵌套事务

- - ImportNew
大多嵌套事务都是通过EJB实现的,现在我们尝试实现对POJO的嵌套事务. 这里我们使用了ThreadLocal的功能. 所以内层事务或外层事务可以在不影响其他事务的条件下进行回滚或提交. 新建的事务嵌套在外层事务中. 如果内层事务完成(不论是回滚或是提交),外层的事务就可以进行回滚或提交,这样的操作并不会影响内层事务.

数据库sharding

- - 数据库 - ITeye博客
当团队决定自行实现sharding的时候,DAO层可能是嵌入sharding逻辑的首选位置,因为在这个层面上,每一个DAO的方法都明确地知道需要访问的数据表以及查询参数,借助这些信息可以直接定位到目标shard上,而不必像框架那样需要对SQL进行解析然后再依据配置的规则进行路由. 另一个优势是不会受ORM框架的制约.

数据库索引

- - CSDN博客推荐文章
索引是由用户创建的、能够被修改和删除的、实际存储于数据库中的物理存在;创建索引的目的是使用户能够从整体内容直接查找到某个特定部分的内容. 一般来说,索引能够提高查询,但是会增加额外的空间消耗,并且降低删除、插入和修改速度. 1.聚集索引:表数据按照索引的顺序来存储的. 2.非聚集索引:表数据存储顺序与索引顺序无关.

数据库事务

- - 数据库 - ITeye博客
事务传播发生在类似以下情形:. 假设methodB的配置是:. 如果methodA在事务里,那么methodB也在这个事务中运行. 如果methodA不在事务里,那么methodB重新建立一个事务运行. 如果methodA在事务里,那么methodB也在这个事务中运行. 如果methodA不在是事务里,那么methodB在非事务中运行.

数据库优化

- - 数据库 - ITeye博客
程序运行效率,优化应用程序,在SP编写过程中应该注意以下几点: . a) SQL的使用规范: .   i.尽量避免大事务操作,慎用holdlock子句,提高系统并发能力.   ii.尽量避免反复访问同一张或几张表,尤其是数据量较大的表,可以考虑先根据条件提取数据到临时表中,然后再做连接.   iii.尽量避免使用游标,因为游标的效率较差,如果游标操作的数据超过1万行,那么就应该改写;如果使用了游标,就要尽量避免在游标循环中再进行表连接的操作.

数据库调优

- - 数据库 - ITeye博客
1、1、调整数据结构的设计. 这一部分在开发信息系统之前完成,程序员需要考虑是否使用ORACLE数据库的分区功能,对于经常访问的数据库表是否需要建立索引等. 这一部分也是在开发信息系统之前完成,程序员在这一步需要考虑应用程序使用什么样的体系结构,是使用传统的Client/Server两层体系结构,还是使用Browser/Web/Database的三层体系结构.

MySQL数据库的修复

- Xin - 博客园-首页原创精华区
找到mysql的安装目录的bin/myisamchk工具,在命令行中输入:. 然后myisamchk 工具会帮助你恢复数据表的索引. 好象也不用重新启动mysql,问题就解决了. 当你试图修复一个被破坏的表的问题时,有三种修复类型. 如果你得到一个错误信息指出一个临时文件不能建立,删除信息所指出的文件并再试一次--这通常是上一次修复操作遗留下来的.