hibernateTools生成hbm，pojo，dao

合集下载

HibernateTool_自动生成JPA实体

HibernateTool_自动生成JPA实体开发向导描述修改记录开发向导描述 (1)修改记录 (1)1开发向导概要 (3)1.1向导适用范围 (3)1.2开发涉及的技术 (3)1.3开发使用工具和版本 (3)1.4 开发环境以及操作步骤 (4)1.4.1 安装Hibernate Tools (4)方法1 下载插件后安装Hibernate插件 (4)方法2 自动安装Hibernate插件 (7)1.4.2 新建工程配置及生成实体 (8)1.4.2.1 新建java工程配置相关包 (8)1.4.2.2 创建Hibernate configuration File (11)1.4.2.3 创建Hibernate Console Configuration (13)1.4.2.4 创建Hibernate Reverse Engineering File(reveng.xml) (14)1.4.2.5 创建实体 (16)1.5 将生成的实体用户开发 (23)1.5. 1 复制实体到项目的源目录下 (24)1.5.2 修改实体 (26)1.5.2.1 关注1：实现的接口改变 (26)1.5.2.2 关注2：按照情况可以去掉集合类属性（不是必须） (27)1.5.2.3 关注3：主键生成原则 (27)1.5.2.4 关注4：删掉不必要的构造方法（不是必须） (29)1.5.2.5 关注5：在hibernate.cfg.xml中增加实体的引用，增加后spring将接管实体的生命周期。

(31)1开发向导概要在eclipse3.2种集成hibernateT ools，自动生成JPA实体。

1.1向导适用范围向导适用的人群是项目中Web开发者，以及相关测试和管理人员。

1.2开发涉及的技术采用Java技术进行项目的开发，选择技术框架主要是目前流行的开源的技术架构。

Spring2.5Struts2.12Hibernate3.2或者3.31.3开发使用工具和版本Eclipse3.5 + hibernatetools(eclipse plugin)Tomcat6.0.18Jdk6Postgresql8.3RC1.4 开发环境以及操作步骤准备好eclipse3.2【3.2～3.6均可】，建议使用3.2.1.4.1 安装Hibernate Tools方法1 下载插件后安装Hibernate插件把插件放到eclipse目录下面在eclipse目录下面新建links文件夹新增一个文件hibernatetools.link内容如下：path = E:/eclipse/subeclipse_hibernateTools重启eclipse即可。

hbm映射文件配置和主键生成策略

hbm映射文件配置和主键生成策略1.hbm文件配置①配置类到指定数据库中表的映射.<?xml version="1.0" encoding="UTF-8"?>.<!DOCTYPE hibernate-mapping PUBLIC."-//Hibernate/Hibernate Mapping DTD 3.0//EN"."/dtd/hibernate-mapping-3.0.dtd">..<hibernate-mapping>...<class name="cn.itcast.domain.Customer" table="customer"catalog="hibernate3day1">....<id name="id" column="id" type="int">..<generator class="native"></generator>.</id>..<property name="name" column="name" type="ng.String"not-null="true"></property> .<property name="age" column="age" type="int"></property>.<property name="city">.<column name="city" sql-type="varchar(20)"></column>  .</property>.</class>...<sql-query name="login">.<![CDATA[select * from user where username= ? and password =?]]>.</sql-query>..</hibernate-mapping>* 在配置过程中，省略column 和 type ，如果不写column 生成列名就是属性名，不写type将按照类中属性类型自动映射* 配置列其它属性 unique="true" 唯一not-null="true" 非空length="20" 长度2.主键的生成策略在<id>元素中通过 <generator class="生成策略"></generator> 指定数据表主键生成策略常用六种主键生成策略①incrementincrement 标识符生成器由 Hibernate 以递增的方式为代理主键赋值原理：select max(id) ， insert max(id)+1* 使用 increment 创建数据表没有主键自增长，通过hibernate在程序内部完成自增* 好处跨平台，缺点高并发访问时，可以出现主键冲突问题②identity （无线程问题）---- Mysqlidentity 标识符生成器由底层数据库来负责生成标识符, 它要求底层数据库把主键定义为自动增长字段类型原理：依赖数据库内部自增长，和hibernate无关* 创建数据表 `id` int(11) NOT NULL AUTO_INCREMENT* 优点，无需程序处理，数据库自己完成主键增长，缺点 Mysql支持自增主键，oracle 不支持③sequence --- Oraclesequence 标识符生成器利用底层数据库提供的序列来生成标识符原理：依赖数据库序列支持，和hibernate程序无关* Oracle 支持序列， Mysql 不支持序列* 序列原理create sequence customer_seq;insert into customer(id) values(customer_seq.nextval); 自动序列+1④nativenative 标识符生成器依据底层数据库对自动生成标识符的支持能力,来选择使用 identity, sequence 或 hilo 标识符生成器.* Mysql 自动选择 identity ， oracle 自动选择 sequence⑤uuiduuid 的主键生成，采用String 类型主键随机生成32位字符串⑥assigned前五种策略，都是代理主键生成策略assigned 是自然主键生成策略 ---- 必须用户在程序中指定（无法自动生成）* 复合主键（联合主键），一个数据表中多列共同作为主键 -----复合主键是一种特殊 assigned 策略.<composite-id>..<key-property name="firstname"></key-property>.<key-property name="secondname"></key-property>.</composite-id>错误：Caused by: org.hibernate.MappingException: composite-id class must implement Serializable: cn.itcast.domain.Person复合主键类必须实现序列化接口。

hibernate配置

属性可以是update、create和drop-create三个值。
目录
1 Hibernate概述 2 第一个Hibernate程序 3 Hibernate的配置文件 4 深入理解持久化对象 5 Hibernate的映射文件 6持久化对象如果PO 实例与Session实例关联起来，且该实例关联到数据库的记录
脱管对象如果PO实例曾经与Session实例关联过，但是因为Session的关闭等原因，PO实例脱离了Session 的管理
Hibernate全面解决方案架构解释
事务(Transaction) 代表一次原子操作，它具有数据库事务的概念但它通过抽象，将应用程序从底层的具体的JDBC、JTA和CORBA 事务中隔离开。一个Session 之内可能包含多个Transaction对象。所有的持久化操作都应该在事务管理下进行，即使是只读操作。
管态，对该对象操作无须锁定数据库，不会造成性能的下降。
持久化对象的状态迁移
持久化实体： 1、Serializable save(object obj) 将对象变为持久化状态 2、void persist(object obj) 将对象转化为持久化状态 3、Serializable save(object obj,object pk) 将obj对象转化为持久化状态，该对象保存到数据库，指定主键值 4、void persist(object obj,object pk) 也加了一个设定主键
Hibernate工作原理
Configuration cfg = new Configuration().configure();
开始
启动hibernate
构建Configuration 实例，初始化该实例中的所有变量

hbm原理

hbm原理Hibernate映射文件（HBM）原理解析HBM（Hibernate映射文件）是Hibernate框架中重要的组成部分，用于映射Java类与数据库表之间的关系。

它提供了一种将对象模型与关系模型进行转换的机制，使得开发人员可以使用面向对象的方式操作数据库。

本文将对HBM原理进行详细解析，帮助读者更好地理解和应用Hibernate框架。

一、HBM文件的基本结构HBM文件通常以.hbm.xml作为文件后缀，采用XML格式描述。

它包含了数据库表和Java类之间的映射关系及其属性信息。

一个典型的HBM文件由根元素<hibernate-mapping>包裹，内部包含了<class>、<id>、<property>等元素来定义映射关系。

1. <class>元素：用于描述Java类与数据库表之间的映射关系。

它的name属性指定了Java类的全限定名，table属性指定了对应的数据库表名。

2. <id>元素：用于定义主键映射关系。

它的name属性指定了Java 类中对应的主键属性名，column属性指定了对应的数据库列名，type属性指定了主键属性的数据类型。

3. <property>元素：用于描述普通属性的映射关系。

它的name属性指定了Java类中对应的属性名，column属性指定了对应的数据库列名，type属性指定了属性的数据类型。

二、HBM文件中的映射关系HBM文件中的映射关系有三种类型：一对一、一对多和多对多。

下面将分别进行详细介绍。

1. 一对一关系：指的是一个Java类的对象与另一个Java类的对象之间的关系。

在HBM文件中，一对一关系可以通过<one-to-one>元素来定义。

它的name属性指定了Java类中对应的属性名，class 属性指定了关联的Java类名。

2. 一对多关系：指的是一个Java类的对象与多个另一个Java类的对象之间的关系。

hibernate多表查询

.多表查询：三个以上的表之间的关联；2.配置：分别配置两表之间的关联映射；3.查询：from a join b join c ...join zhibernate.cfg.xml:view sourceprint?01.<?xml version='1.0'encoding='UTF-8'?>02.<!DOCTYPE hibernate-configuration PUBLIC03. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"04. "/hibernate-configuration -3.0.dtd">05.06.07.<hibernate-configuration>08.09.<session-factory>10. <property name="ername">scott</property>11. <property name="connection.url">12. jdbc:oracle:thin:@127.0.0.1:1521:MGC13. </property>14. <property name="dialect">15. org.hibernate.dialect.Oracle9Dialect16. </property>17. <property name="myeclipse.connection.profile">MGC</property>18. <property name="connection.password">tiger</property>19. <property name="connection.driver_class">20. oracle.jdbc.driver.OracleDriver21. </property>22.23. <property name="show_sql">true</property>24. <mapping resource="cn/edu/ahau/mgc/hibernate/pojo/Join.hbm.xml" />25.26.</session-factory>27.28.</hibernate-configuration>Student.java:view sourceprint?01.package .ahau.mgc.hibernate.pojo;02.03.public class Student {04.05. private long id;06. private String name;07. private Classes classes;08.09. public Classes getClasses() {10. return classes;11. }12.13. public void setClasses(Classes classes) {14. this.classes = classes;15. }16.17. public long getId() {18. return id;19. }20.21. public void setId(long id) {22. this.id = id;23. }24.25. public String getName() {26. return name;27. }28.29. public void setName(String name) {30. = name;31. }32.}Classes.java:view sourceprint?01.package .ahau.mgc.hibernate.pojo;02.03.import java.util.Set;04.05.public class Classes {06.07. private long id;08. private String name;09. private Set<Student> students;10.11. public long getId() {12. return id;13. }14.15. public void setId(long id) {16. this.id = id;17. }18.19. public String getName() {20. return name;21. }22.23. public void setName(String name) {24. = name;25. }26.27. public Set<Student> getStudents() {28. return students;29. }30.31. public void setStudents(Set<Student> students) {32. this.students = students;33. }34.}Course.java:view sourceprint?01.package .ahau.mgc.hibernate.pojo;02.03.public class Course {04.05. private long id;06. private String name;07.08. public long getId() {09. return id;10. }11.12. public void setId(long id) {13. this.id = id;14. }15.16. public String getName() {17. return name;18. }19.20. public void setName(String name) {21. = name;22. }23.}Grade.java:view sourceprint?01.package .ahau.mgc.hibernate.pojo;02.03.public class Grade {04.05. private long id;06. private Student student;07. private Course course;08. private int grade;09.10. public long getId() {11. return id;12. }13.14. public void setId(long id) {15. this.id = id;16. }17.18. public Student getStudent() {19. return student;20. }21.22. public void setStudent(Student student) {23. this.student = student;24. }25.26. public Course getCourse() {27. return course;28. }29.30. public void setCourse(Course course) {31. this.course = course;32. }33.34. public int getGrade() {35. return grade;36. }37.38. public void setGrade(int grade) {39. this.grade = grade;41.}Join.hbm.xml:view sourceprint?01.<?xml version="1.0"encoding="utf-8"?>02.<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"03."/hibernate-mapping-3.0.dtd">04.07.<hibernate-mapping>08. <class name=".ahau.mgc.hibernate.pojo.Student"table="MAN Y_STUDENT"schema="SCOTT">09. <id name="id"type="ng.Long">10. <column name="ID"precision="22"scale="0"/>11. <generator class="native"/>12. </id>13. <property name="name"type="ng.String">14. <column name="NAME"length="20"not-null="true"/>15. </property>16. <many-to-one name="classes"column="CLASSID"/>17. </class>19. <class name=".ahau.mgc.hibernate.pojo.Classes"table="MAN Y_CLASSES">20. <id name="id"type="ng.Long">21. <column name="ID"precision="22"scale="0"/>22. <generator class="native"/>23. </id>24. <property name="name"type="ng.String">25. <column name="NAME"length="20"not-null="true"/>26. </property>27. <set name="students">28. <key column="CLASSID"></key>29. <one-to-many class=".ahau.mgc.hibernate.pojo.Stud ent"/>30. </set>31. </class>32.33. <class name=".ahau.mgc.hibernate.pojo.Course"table="MANY _COURSE">34. <id name="id"type="ng.Long">35. <column name="ID"precision="22"scale="0"/>36. <generator class="native"/>37. </id>38. <property name="name"type="ng.String">39. <column name="NAME"length="20"not-null="true"/>40. </property>41. </class>42.43. <class name=".ahau.mgc.hibernate.pojo.Grade"table="MANY_ GRADE">44. <id name="id"type="ng.Long">45. <column name="ID"precision="22"scale="0"/>46. <generator class="native"/>47. </id>48. <property name="grade"type="ng.Integer">49. <column name="GRADE"precision="5"scale="0"/>50. </property>51. <many-to-one name="student"column="SID"/>52. <many-to-one name="course"column="CID"/>53. </class>54.55.</hibernate-mapping>HibernateSessionFactory.java:view sourceprint?001.package .ahau.mgc.hibernate.many2one.factory;002.003.import org.hibernate.HibernateException;004.import org.hibernate.Session;005.import org.hibernate.cfg.Configuration;006.007./**008. * Configures and provides access to Hibernate sessions, tied to t he009. * current thread of execution. Follows the Thread Local Session 010. * pattern, see {@link /42.html ;}.011. */012.public class HibernateSessionFactory {013.014. /**015. * Location of hibernate.cfg.xml file.016. * Location should be on the classpath as Hibernate uses 017. * #resourceAsStream style lookup for its configuration file. 018. * The default classpath location of the hibernate config file is019. * in the default package. Use #setConfigFile() to update 020. * the location of the configuration file for the current sess ion.021. */022. private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.x ml";023. private static final ThreadLocal<Session> threadLocal = new Thr eadLocal<Session>();024. private static Configuration configuration = new Configuration ();025. private static org.hibernate.SessionFactory sessionFactory; 026. private static String configFile = CONFIG_FILE_LOCATION;027.028. static{029. try{030. configuration.configure(configFile);031. sessionFactory = configuration.buildSessionFactory(); 032. } catch(Exception e) {033. System.err034. .println("%%%% Error Creating SessionFactory % %%%");035. e.printStackTrace();036. }037. }038. private HibernateSessionFactory() {039. }040.041. /**042. * Returns the ThreadLocal Session instance. Lazy initialize 043. * the <code>SessionFactory</code> if needed.044. *045. * @return Session046. * @throws HibernateException047. */048. public static Session getSession() throws HibernateException { 049. Session session = (Session) threadLocal.get();050.051. if(session == null|| !session.isOpen()) {052. if(sessionFactory == null) {053. rebuildSessionFactory();054. }055. session = (sessionFactory != null) ? sessionFactory.op enSession()056. : null;057. threadLocal.set(session);058. }059.060. return session;061. }062.063. /**064. * Rebuild hibernate session factory065. *066. */067. public static void rebuildSessionFactory() {068. try{069. configuration.configure(configFile);070. sessionFactory = configuration.buildSessionFactory(); 071. } catch(Exception e) {072. System.err073. .println("%%%% Error Creating SessionFactory % %%%");074. e.printStackTrace();075. }076. }077.078. /**079. * Close the single hibernate session instance.080. *081. * @throws HibernateException082. */083. public static void closeSession() throws HibernateException { 084. Session session = (Session) threadLocal.get();085. threadLocal.set(null);086.087. if(session != null) {088. session.close();089. }090. }091.092. /**093. * return session factory094. *095. */096. public static org.hibernate.SessionFactory getSessionFactory() {097. return sessionFactory;098. }099.100. /**101. * return session factory102. *103. * session factory will be rebuilded in the next call 104. */105. public static void setConfigFile(String configFile) {106. HibernateSessionFactory.configFile = configFile;107. sessionFactory = null;108. }109.110. /**111. * return hibernate configuration112. *113. */114. public static Configuration getConfiguration() {115. return configuration;116. }117.118.}ExportToDBCreate.java:view sourceprint?01.package .ahau.mgc.hibernate.export;02.03.import org.hibernate.cfg.Configuration;04.import org.hibernate.tool.hbm2ddl.SchemaExport;05.06.public class ExportToDBCreate {07.08. public static void main(String[] args) {09. Configuration cfg = new Configuration().configure();10. SchemaExport export = new SchemaExport(cfg);11. export.create(true, true);12. }13.14.}InitData.java:view sourceprint?01.package .ahau.mgc.hibernate.export;02.03.import java.util.ArrayList;04.import java.util.Iterator;05.import java.util.List;06.import java.util.Random;07.08.import org.hibernate.Session;09.10.import .ahau.mgc.hibernate.factory.HibernateSessionFactory;11.import .ahau.mgc.hibernate.pojo.Classes;12.import .ahau.mgc.hibernate.pojo.Course;13.import .ahau.mgc.hibernate.pojo.Grade;14.import .ahau.mgc.hibernate.pojo.Student;15.16.17.public class InitData {18.19.20. public static void main(String[] args) {21. Session session = HibernateSessionFactory.getSession();22. session.beginTransaction();23.24. List<Student> students = new ArrayList<Student>();25. for(int i = 0; i < 3; i++) {26. Classes classes = new Classes();27. classes.setName("Class_"+ i);28. session.save(classes);29.30. for(int j = 0; j < 3; j++) {31. Student student = new Student();32. student.setName("Class_"+ i + "-Student_"+ j);33. student.setClasses(classes);34. session.save(student);35. students.add(student);36. }37. }38.39. List<Course> courses = new ArrayList<Course>();40. for(int i = 0; i < 5; i++) {41. Course course = new Course();42. course.setName("Course_"+ i);43. session.save(course);44. courses.add(course);45. }46.47. for(Iterator<Student> iterator = students.iterator(); iter ator.hasNext();) {48. Student student = iterator.next();49. for(Iterator<Course> iterator2 = courses.iterator(); i terator2.hasNext();) {50. Course course = iterator2.next();51. Random random = new Random();52. Grade grade = new Grade();53. grade.setStudent(student);54. grade.setCourse(course);55. grade.setGrade(random.nextInt(100));56. session.save(grade);57. }58. }59.60. session.getTransaction().commit();61. HibernateSessionFactory.closeSession();62. }63.64.}TestJoin.java:view sourceprint?01.package .ahau.mgc.hibernate.export;02.03.import java.util.Iterator;04.05.import org.hibernate.Session;06.07.import .ahau.mgc.hibernate.factory.HibernateSessionFactory;08.09.public class TestJoin {10.11. public static void main(String[] args) {12. Session session = null;13. try{14. session = HibernateSessionFactory.getSession();15. Iterator<Object[]> students = session.createQuery("sele ct ,,g.grade, from Grade g join g.student s join g. course c join s.classes cl where g.grade=(select max(grade) from Grade )").iterate();16. if(students.hasNext()) {17. Object[] student = students.next();18. System.out.println("Course Name:"+ student[0]);19. System.out.println("Student Name:"+ student[1]);20. System.out.println("Grade:"+ student[2]);21. System.out.println("Class Name:"+ student[3]);22. }23. } catch(Exception e) {24. e.printStackTrace();25. } finally{26. HibernateSessionFactory.closeSession();27. }28. }29.}。

利用日志调试Hibernate架构中的DAO层方法

ｎｋ．ＴｈｉｓｐａｐｅｒｐｕｔｓｆｏｒｗａｒｄａｋｉｎｄｏｆｔｅｃｈｎｏｌｏｇｙｗｈｉｃｈｄｅｂｕｇｍｅｔｈｏｄｓｏｆＤＡＯｌａｙｅｒｉｎＨｉｂｅｒ —
ｄｅｂｕｇ．
Ｋｅｙｗｏｒｄｓ：Ｌｏｇ４ｊ；ｌｏｇｒｅｃｏｒｄ；ｍｅｔｈｏｄｏｆＤＡＯｌａｙｅｒ；ｄｅｂｕｇｇｉｎｇｍｅｔｈｏｄ；Ｔｒａｃｋｉｎｇｃｏｄｅ
ｓｕｐｐｏｒｔｆｏｒｄｅｓｉｇｎｅｒ．Ｔｈｉｓｍｅｃｈａｎｉｓｍｃａｎｇｅｔｒｉｄｏｆａｌｌｋｉｎｄｓｏｆｒｕｎｅｒｒｏｒｓａｎｄｐｒｅｓｅｎｔｓｔａｔｕｓａｎｄｃｏｎｖｅｒ —
第２４卷第３期
２０１３年５月
陇东学院学报
ＪｏｕｒｎａｌｏｆＬ０ｎｇｄｏｎｇＵｎｉｖｅｒｓｉｔｙ
Ｖｏ１．２４Ｎｏ．３
Ｍａｖ２０１３
文章编号：１６７４ — １７３０（２０１２）０３－００１６－０４
ｓｉｏｎｐｒｏｃｅｓｓｏｆＤＡＯｏｂｊｅｃｔｉｎｌｉｆｅｃｙｃｌｅ，ｗｈｉｃｈｈａｓｇｏｏｄａｓｓｉｓｔａｎｔｆｕｎｃｔｉｏｎｉｎｓｙｓｔｅｍｄｅｓｉｇｎａｎｄｓｙｓｔｅｍ

Hibernate_映射配置文件详解

–hibernate.properties –hibernate.cfg.xml
Prepared by TongGang
hibernate.cfg.xml的常用属性
• • • • • • • • • connection.url：数据库URL ername：数据库用户名 connection.password：数据库用户密码 connection.driver_class：数据库JDBC驱动 show_sql：是否将运行期生成的SQL输出到日志以供调试。取 show_sql 值 true | false dialect：配置数据库的方言，根据底层的数据库不同产生不 dialect 同的sql语句，Hibernate 会针对数据库的特性在访问时进行优化。 hbm2ddl.auto：在启动和停止时自动地创建，更新或删除数据 hbm2ddl.auto 库模式。取值 create | update | create-drop resource：映射文件配置，配置文件名必须包含其相 mapping resource 对于根的全路径 connection.datasource ：JNDI数据源的名称
• Class：定义一个持久化类 Class： • name (可选): 持久化类（或者接 (可选): 持久化类（可选口）的类名 • table (可选 - 默认是类的非全限 (可选定名): 定名): 对应的数据库表名 • discriminator-value (可选 - 默 discriminator(可选认和类名一样): 认和类名一样): 一个用于区分不同的子类的值，在多态行为时使用。同的子类的值，在多态行为时使用。它可以接受的值包括 null 和 not null。 null。
Prepared by TongGang

Dao层介绍

DAO 层，文档说明。

一为什么要选择Hibernate?⏹直接使用JDBC操作数据库的步骤很繁琐.⏹JDBC是关系型数据库.⏹我们用Java开发程序，则使用的是面向对象对象的思想.⏹Hibernate正是使用了这两种不同的模型之间建立关联，Hibernate给我们提供了利用面向对象的思想来操作关系型数据的接口。

二Hibernate能做什么? O/R映射。

⏹第一，将对象数据保存到数据库中.⏹第二，将数据库对象读入对象中.三Hibernate与O/R之间的关系?四Hibernate的核心接口。

Hibernate的核心接口一共有5个，分别为:Session、SessionFactory、Transaction、Query 和Configuration。

这5个核心接口在任何开发中都会用到。

通过这些接口，不仅可以对持久化对象进行存取，还能够进行事务控制。

下面对这五的核心接口分别加以介绍。

Session接口:Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句。

)。

但需要注意的是Session对象是非线程安全的。

SessionFactory接口:SessionFactroy接口负责初始化Hibernate。

它充当数据存储源的代理，并负责创建Session对象。

这里用到了工厂模式。

需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。

Configuration接口:Configuration接口负责配置并启动Hibernate，创建SessionFactory 对象。

在Hibernate的启动的过程中，Configuration类的实例首先定位映射文档位置、读取配置，然后创建SessionFactory对象。

hibernate 自动生成表结构底层原理

Hibernate是一个开源的Java持久化框架，它的底层原理是基于ORM（对象关系映射）的思想。

ORM是一种将对象模型和关系数据库模型进行映射的技术，使得开发人员可以使用面向对象的思维来操作数据库，而不需要直接编写SQL语句。

在Hibernate中，自动生成表结构的底层原理主要包括以下几个步骤：1. 实体类和映射文件：开发人员需要定义实体类，即对应数据库中的表。

同时，需要创建映射文件，将实体类和数据库表进行映射关联。

映射文件通常使用XML或注解的方式进行定义。

2. 元数据解析：Hibernate通过解析实体类和映射文件中的元数据信息，获取实体类的结构、属性和关系等信息。

3. 数据库连接和元数据读取：Hibernate会使用数据库连接来获取数据库的元数据信息，包括表、列、索引等信息，以及数据库的类型和约束等。

4. DDL生成：Hibernate根据实体类的元数据信息和数据库的元数据信息进行比较和分析，判断数据库中是否存在对应的表结构。

如果不存在，则使用元数据信息生成相应的SQL 语句，即DDL（数据定义语言）语句，用于创建表、字段、索引等。

5. 执行DDL：Hibernate会使用数据库连接执行生成的DDL 语句，将表结构创建到数据库中。

需要注意的是，Hibernate支持多种生成DDL的方式，包括自动创建、更新、验证等。

开发人员可以根据需要进行相应的配置，指定生成DDL的方式。

总的来说，Hibernate使用实体类和映射文件作为基础元数据，通过解析和比较元数据信息，生成相应的DDL语句，并通过数据库连接执行DDL语句，从而自动生成表结构。

这样，开发人员可以更专注于领域模型的设计和开发，而无需关心具体的数据库细节和SQL语句的编写。

Java工具类_表结构自动生成对应的实体类、Mapper.xml文件、Dao类

Java⼯具类_表结构⾃动⽣成对应的实体类、Mapper.xml⽂件、Dao类import java.io.File;import java.io.FileWriter;import java.io.IOException;import java.io.PrintWriter;import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.ResultSetMetaData;import java.sql.SQLException;import java.sql.Statement;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;/*** 根据表⽣成Entity⽂件** 修改test_Table()⽅法中的参数值，即可执⾏main⽅法获得想要的结果** ⽣成⽂件后导⼊需要的包* 依赖包：mysql数据库驱动包* ⽣成其他数据库类型的表需要更换驱动类并略做数据类型转换的修改即可** 注意：数据库数据类型只包括了常⽤的⼏种，其他数据类型还需要在完善，请添加‘ftype’该数组变量的值**/public class TableToEntity {public static void main(String args[]) {test_Table();}/*** 设置参数--需要修改*/public static void test_Table() {String tableName = "tableName";//需要转换的表String host = "127.0.0.1";//数据库hostString port = "3306";//数据库端⼝String database = "databaseName";//数据库名String username = "root";//数据库⽤户名String password = "root";//数据库⽤密码String path = "F:/file/";//⽣成⽂件存放⽬录，不包括⽂件名，⽂件名⾃动命名为 '表名.java,表名Mapper.xml,表名Dao.java' ⾸字母⼤写String dao_package = "com.test.dao.";//dao的包路径String entity_package = "com.test.entity.";//entity的包路径//⽣成entity⽂件getTableToEntityFile(tableName, host, port, database, username, password, entity_package,path);//⽣成ResultMap⽂件getTableToResultMap(tableName, host, port, database, username, password, dao_package,entity_package, path);//⽣成Dao⽂件getResultMapToDao(tableName, dao_package, entity_package, path);}/*** 根据表⽣成Entity⽂件*/public static void getTableToEntityFile(String tableName, String host, String port,String database, String username, String password,String entity_package, String path) {String strforname = "com.mysql.jdbc.Driver";String strurl = "jdbc:mysql://" + host + ":" + port + "/" + database+ "?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull";//需要替换的数据类型，待完善String ftype[][] = new String[][] { { "tinyint unsigned", "Integer" },{ "tinyint", "Integer" }, { "int unsigned", "Integer" }, { "int", "Integer" },{ "smallint unsigned", "Integer" }, { "smallint", "Integer" },{ "varchar", "String" }, { "char", "String" }, { "longtext", "String" },{ "text", "String" }, { "decimal unsigned", "BigDecimal" },{ "decimal", "BigDecimal" }, { "datetime", "String" }, { "date", "String" },{ "timestamp", "String" }, { "unsigned", "" } };//如果包路径是以“.”结尾的要去掉entity_package = entity_package == null ? "" : entity_package;entity_package = entity_package.length() > 0 && entity_package.endsWith(".") ? entity_package.substring(0, entity_package.length() - 1) : entity_package;System.out.println("==============================");System.out.println("正在⽣成。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

它支持Eclispe插件方式和Ant方式。这里主要将采用Ant方式。这样可以脱离
Eclipse :)

1 准备好Hiberbate.properteis. 主要是告诉工具取哪的数据库和表格
hibernate.dialect org.hibernate.dialect.MySQLDialect
#hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect
#hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect
hibernate.connection.driver_class com.mysql.jdbc.Driver
hibernate.connection.url jdbc:mysql://localhost/uniform_user
hibernate.connection.username sso
hibernate.connection.password sso

2 编写Ant脚本。这一步是要定义ant任务，以及生成POJO和HBM.XML配
置文件

《?xml version="1.0"?》
《project name="UniformUser Hibernate" default="all" basedir="."》

《property name="name" value="yidong"/》
《property
name="web.dir" value="F:/winson/project/sso/develop/UniformUser"/》
《property name="ant.lib.dir" value="D:/apache-ant-1.7.0/lib"/》
《property name="hibernatetools.lib.dir" value="H:/Open
Source/Hibernate/HibernateTools-3.2.0.beta9a/plugins/org.hibernate.eclipse_
3.2.0.beta9a/lib/tools"/》

《path id="lib.class.path"》
《fileset dir="${web.dir}/WebRoot/WEB-INF/lib"》
《include name="*.jar"/》
《/fileset》
《fileset dir="${ant.lib.dir}"》
《include name="*.jar"/》
《/fileset》
《fileset dir="${hibernatetools.lib.dir}"》
《include name="*.jar"/》
《/fileset》
《/path》

《taskdef name="hibernatetool"
classname="org.hibernate.tool.ant.HibernateToolTask"
classpathref="lib.class.path" /》
《target name="all"》
《hibernatetool destdir="${web.dir}/src"》

《jdbcconfiguration propertyfile="${basedir}/hibernate.properties"
packagename="${name}.sso.entity" /》
《hbm2java jdk5="true" /》
《hbm2hbmxml /》
《hbm2cfgxml /》
《hbm2dao /》
《/hibernatetool》
《/target》
《/project》

任务all 用于生成POJO和DAO和映射文件及hibernate.cfg.xml
其中lib.class.path必须包括ant的lib目录以及hibernate、hibernate-tools的lib
目录。