生成建表的语句
可以在配置文件进行配置,自动生成建表语句
/hibernate_0600_Status/src/hibernate.cfg.xml
<!-- Drop and re-create the database schema on startup -->
<property name="hbm2ddl.auto">update</property>
也可以手动进行生成
用程序来建表
@Test
public void TestSchemaExport(){
new SchemaExport(new AnnotationConfiguration().configure()).create(false, true);
}
去找hibernate.cfg.xml配置文件的
<mapping resource="com/zhuhw/hibernate/model/Student.hbm.xml"/>
<mapping class="com.zhuhw.hibernate.model.Teacher"/>
文件,进行生成相应的表。
create(boolean1,boolean2),第1个boolean类型是说是否覆盖原有的表,第2个boolean是说,是否新建表
运行结果:
create table Student (
id integer not null,
name varchar(255) not null,
age integer,
primary key (id, name)
)
22:47:06,947 DEBUG SchemaExport:377 -
create table Teacher (
id integer not null auto_increment,
birthdate date,
_name varchar(255),
title varchar(255),
yourWifeName varchar(255),
zhicheng integer,
primary key (id)
)
本章代码:
package com.zhuhw.hibernate.model; import java.util.Date; import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.AnnotationConfiguration; import org.hibernate.tool.hbm2ddl.SchemaExport; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; public class HibernateIDTest { public static SessionFactory sf = null; @BeforeClass public static void beforeClass(){ sf = new AnnotationConfiguration().configure().buildSessionFactory(); } @Test public void TestStudentID(){ Student s = new Student(); /*配置文件中使用generator * s.setId(9); * */ StudentPK spk = new StudentPK(); spk.setId(4); spk.setName("waxun4"); s.setAge(24); s.setSpk(spk); /*Session session = SessionFactory.getCurrentSession(); session.connection()*/ /*Session session = sf.openSession(); * */ Session session = sf.openSession(); session.beginTransaction(); session.save(s); session.getTransaction().commit(); session.close(); } @Test public void TestTeacherID(){ Teacher t = new Teacher(); /* TeacherPK tpk = new TeacherPK(); tpk.setId(1); tpk.setName("waxun");*/ /*t.setName("yuzhou1");*/ /*t.setTpk(tpk);*/ t.setId(1); t.setName("waxun2"); t.setTitle("ccc"); t.setBirthdate(new Date()); t.setYourWifeName("yourWifeName1"); t.setZhicheng(ZhiCheng.A); Session session = sf.getCurrentSession(); //在hibernate中执行操作要在一个事务里面 session.beginTransaction(); System.out.println(t.getId()); session.getTransaction().commit(); } @Test public void TestDelete(){ Teacher t = new Teacher(); //因为id设置的自动生成,所有设置不设置是一样的 //t在这个时候是Transient状态 t.setName("t1"); t.setTitle("ccc"); t.setBirthdate(new Date()); t.setYourWifeName("yourWifeName1"); t.setZhicheng(ZhiCheng.A); Session session = sf.getCurrentSession(); //在hibernate中执行操作要在一个事务里面 session.beginTransaction(); session.save(t); //t这个时候是Persistent状态 System.out.println("----Persistent-------"); System.out.println(t.getId()); session.getTransaction().commit(); //t这个时候是Detached System.out.println("---Detached--------"); System.out.println(t.getId()); //进行commit后,再进行delete()。实验一下 Session session2 = sf.getCurrentSession(); session2.beginTransaction(); session2.delete(t); session2.getTransaction().commit(); } @Test public void TestDelete2(){ Teacher t = new Teacher(); t.setId(2); Session session = sf.getCurrentSession(); session.beginTransaction(); session.delete(t); session.getTransaction().commit(); } @Test public void TestSave3Status(){ Teacher t = new Teacher(); //因为id设置的自动生成,所有设置不设置是一样的 //t在这个时候是Transient状态 t.setName("t3"); t.setTitle("ccc"); t.setBirthdate(new Date()); t.setYourWifeName("yourWifeName1"); t.setZhicheng(ZhiCheng.A); Session session = sf.getCurrentSession(); //在hibernate中执行操作要在一个事务里面 session.beginTransaction(); session.save(t); //t这个时候是Persistent状态 System.out.println("----Persistent-------"); System.out.println(t.getId()); session.getTransaction().commit(); //t这个时候是Detached System.out.println("---Detached--------"); System.out.println(t.getId()); } @Test public void TestLoad(){ //从数据库中取出一条数据到缓存中 Session session = sf.getCurrentSession(); session.beginTransaction(); //参数是第一个是转换成哪种类型,第二个参数是实现序列化的-->在这里是id,已经实现的Integer已经实现了序列化 Teacher t = (Teacher)session.load(Teacher.class, 2); System.out.println("------------------"); System.out.println(t.getClass()); session.getTransaction().commit(); /*System.out.println("------------------"); System.out.println(t.getName());*/ } @Test public void TestGet(){ //从数据库中取出一条数据到缓存中 Session session = sf.getCurrentSession(); session.beginTransaction(); //参数是第一个是转换成哪种类型,第二个参数是实现序列化的-->在这里是id,已经实现的Integer已经实现了序列化 Teacher t = (Teacher)session.get(Teacher.class, 2); //在get的时候已经进行发出sql语句了 /*System.out.println("------------------"); System.out.println(t.getName()); System.out.println(t.getYourWifeName());*/ System.out.println("------------------"); System.out.println(t.getClass()); session.getTransaction().commit(); } @Test public void TestUpdate1(){ //用来更新detached对象,更新完成后转为persist状态 Session session = sf.getCurrentSession(); session.beginTransaction(); Teacher t = (Teacher)session.get(Teacher.class, 2); session.getTransaction().commit(); System.out.println("-----detached---------"); t.setName("zhuhw1111"); Session session2 = sf.getCurrentSession(); session2.beginTransaction(); session2.update(t); System.out.println("-----persistence---------"); session2.getTransaction().commit(); } public void TestUpdate2(){ //更新transient对象会报错,因为找不到id。 Teacher t = new Teacher(); t.setName("zhuhw1111"); Session session2 = sf.getCurrentSession(); session2.beginTransaction(); session2.update(t); System.out.println("-----persistence---------"); session2.getTransaction().commit(); } @Test public void TestUpdate3(){ /*3.更新自己手动设定id的transient对象可以(前提是数据库里有这条记录)*/ Teacher t = new Teacher(); t.setId(1); t.setName("yuzhoua111"); Session session2 = sf.getCurrentSession(); session2.beginTransaction(); session2.update(t); System.out.println("-----persistence---------"); session2.getTransaction().commit(); } @Test public void TestUpdate4(){ Session session = sf.getCurrentSession(); session.beginTransaction(); Teacher t = (Teacher)session.get(Teacher.class, 2); //4.persistence状态的对象只要设定不同字段就会发生更新 t.setName("dooder"); session.getTransaction().commit(); } @Test public void TestUpdate5(){ Session session = sf.getCurrentSession(); session.beginTransaction(); Teacher t = (Teacher)session.get(Teacher.class, 2); //在Teacher类中加入不更新的注解 t.setName("dooder_zhuhw"); session.getTransaction().commit(); } public void TestUpdate5_1(){ //使用xml中dynamic-update Session session = sf.getCurrentSession(); session.beginTransaction(); Student t = (Student)session.get(Student.class,1); t.setAge(27); session.getTransaction().commit(); } public void TestUpdate7(){ //使用xml中dynamic-update Session session = sf.getCurrentSession(); session.beginTransaction(); //面向对象的sql Query q =session.createQuery("update Teacher t set t.setId=8 where id=1"); q.executeUpdate(); session.getTransaction().commit(); } public void TestsaveORUpdate(){ Teacher t = new Teacher(); t.setName("zhuhw7"); t.setYourWifeName("yourWifeName"); Session session = sf.getCurrentSession(); session.beginTransaction(); session.saveOrUpdate(t); session.getTransaction().commit(); t.setName("zhuhw8"); Session session2 = sf.getCurrentSession(); session2.beginTransaction(); session2.saveOrUpdate(t); session2.getTransaction().commit(); } @Test public void TestClear(){ //从数据库中取出一条数据到缓存中 Session session = sf.getCurrentSession(); session.beginTransaction(); //参数是第一个是转换成哪种类型,第二个参数是实现序列化的-->在这里是id,已经实现的Integer已经实现了序列化 Teacher t = (Teacher)session.load(Teacher.class, 2); System.out.println(t.getName()); //只执行一次sql,因为第一次执行后,将teache从缓存中取,不需要再次进行执行sql //clear()是清除缓存,所以这时候会中2此sql session.clear(); Teacher t2 = (Teacher)session.load(Teacher.class,2); System.out.println(t.getName()); session.getTransaction().commit(); } @Test public void TestFlush(){ //从数据库中取出一条数据到缓存中 Session session = sf.getCurrentSession(); session.beginTransaction(); //参数是第一个是转换成哪种类型,第二个参数是实现序列化的-->在这里是id,已经实现的Integer已经实现了序列化 Teacher t = (Teacher)session.load(Teacher.class, 2); //只有在进行提交了,才进行执行update语句 /* t.setName("ttt"); t.setName("ttttt");*/ //flush()强制将缓存中的数据与数据库中的数据作同步,这时会执行两天update语句 t.setName("ttt"); session.flush(); t.setName("ttttt"); session.getTransaction().commit(); } /*也可以手动进行生成 * @Test public void TestSchemaExport(){ new SchemaExport(new AnnotationConfiguration().configure()).create(false, true); }*/ @AfterClass public static void afterClass(){ sf.close(); } }
<?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> <!-- Database connection settings --> <property name="connection.driver_class">com.mysql.jdbc.Driver</property> <property name="connection.url">jdbc:mysql://localhost/hibernate</property> <property name="connection.username">root</property> <property name="connection.password">root</property> <!-- <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property> <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property> <property name="connection.username">scoot</property> <property name="connection.password">tiger</property>--> <!-- JDBC connection pool (use the built-in) --> <!--<property name="connection.pool_size">1</property>--> <!-- SQL dialect --> <property name="dialect">org.hibernate.dialect.MySQLDialect</property> <!-- Enable Hibernate's automatic session context management --> <property name="current_session_context_class">thread</property> <!-- Disable the second-level cache --> <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property> <!-- Echo all executed SQL to stdout --> <property name="show_sql">true</property> <property name="format_sql">true</property> <!-- Drop and re-create the database schema on startup --> <property name="hbm2ddl.auto">update</property> <mapping resource="com/zhuhw/hibernate/model/Student.hbm.xml"/> <mapping class="com.zhuhw.hibernate.model.Teacher"/> </session-factory> </hibernate-configuration>
package com.zhuhw.hibernate.model; import java.util.Date; import javax.persistence.Basic; import javax.persistence.Column; import javax.persistence.Embeddable; import javax.persistence.EmbeddedId; import javax.persistence.Entity; import javax.persistence.EnumType; import javax.persistence.Enumerated; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.IdClass; import javax.persistence.Table; import javax.persistence.Temporal; import javax.persistence.TemporalType; import javax.persistence.Transient; /*1.实体类(使用annotation进行实现,告诉hibernate是实体类, * 不需要再建立Teacher.hbm.xml文件进行映射) * 2.hibernate.cfg.xml进行配置即可 * 3.建立一个TeacherTest */ @Entity //表名和类名不同,对表名进行配置 //@Table(name = "_teacher") //@IdClass(value=TeacherPK.class)//两个联合起来正好是一个TeacherPK.class public class Teacher { private int id; private String name; /* 3.将类注解为@IdClass,并将该实体中所有属于主键的属性都注解为@Id 将TeacherPK不用了,直接在Teacher中进行setID getID... 加注解@IdClass指明就可以,更符合编程的习惯。*/ /*private TeacherPK tpk;*/ /*@Id// 1.将组件类注解为@Embeddable,并将组件的属性注解为@Id */ @EmbeddedId//2.将组件的属性注解为@EmbeddedId /*public TeacherPK getTpk() { return tpk; } public void setTpk(TeacherPK tpk) { this.tpk = tpk; }*/ private String title; private Date birthdate; //ZhiCheng enum private ZhiCheng zhicheng; /*@Enumerated(EnumType.STRING) * 数据库存储String `zhicheng` varchar(255) DEFAULT NULL, */ /*@Enumerated(EnumType.ORDINAL) * 数据库存储下标值 `zhicheng` varchar(255) DEFAULT NULL,*/ @Enumerated(EnumType.ORDINAL) public ZhiCheng getZhicheng() { return zhicheng; } public void setZhicheng(ZhiCheng zhicheng) { this.zhicheng = zhicheng; } //映射日期与时间类型,指定时间精度 //通过@Temporal可以指定时间的精度 @Temporal(value=TemporalType.DATE) public Date getBirthdate() { return birthdate; } public void setBirthdate(Date birthdate) { this.birthdate = birthdate; } private String yourWifeName; //不要存到数据库中 /*@Transient*/ public String getYourWifeName() { return yourWifeName; } public void setYourWifeName(String yourWifeName) { this.yourWifeName = yourWifeName; } //主键 @Id //ID自动生成 @GeneratedValue public int getId() { return id; } @Basic//对数据库中,字段名和属性相同 public void setId(int id) { this.id = id; } //字段名属性不同a)Annotation:@Column @Column(name = "_name") //@Id public String getName() { return name; } public void setName(String name) { this.name = name; } /*@Column(updatable=false)*/ public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } }
package com.zhuhw.hibernate.model; import javax.persistence.Embeddable; /*@Embeddable// 1.将组件类注解为@Embeddable,并将组件的属性注解为@Id */public class TeacherPK implements java.io.Serializable{ @Override public boolean equals(Object o) { if(o instanceof TeacherPK) { TeacherPK spk = (TeacherPK)o; if(this.id == spk.getId()&& this.name == spk.getName()){ return true; } }return false; } @Override public int hashCode() { // TODO Auto-generated method stub return this.name.hashCode(); } private int id; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } private String name; }
package com.zhuhw.hibernate.model; import javax.persistence.Id; public class Student { StudentPK spk; @Id public StudentPK getSpk() { return spk; } public void setSpk(StudentPK spk) { this.spk = spk; } /* private int id; public int getId() { return id; } public void setId(int id) { this.id = id; }*/ /*private String id; public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; }*/ private int age; public int getAge() { return age; } public void setAge(int age) { this.age = age; } /* private String name;*/ }
package com.zhuhw.hibernate.model; public class StudentPK implements java.io.Serializable{ @Override public boolean equals(Object o) { if(o instanceof StudentPK) { StudentPK spk = (StudentPK)o; if(this.id == spk.getId()&& this.name == spk.getName()){ return true; } }return false; } @Override public int hashCode() { // TODO Auto-generated method stub return this.name.hashCode(); } private int id; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } private String name; }
package com.zhuhw.hibernate.model; public enum ZhiCheng { A,B,C; }
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- 找不到entity,是因为这个类没有改包名 --> <hibernate-mapping package="com.zhuhw.hibernate.model"> <class name="Student" dynamic-update="true"> <!-- id主键;name=id对应的是Student中的getid() --> <!--<id name="id" > <generator class="uuid"></generator> <generator class="native"></generator> </id> --> <!-- 联合组件配置 --> <composite-id name = "spk" class="com.zhuhw.hibernate.model.StudentPK"> <key-property name="id"></key-property> <key-property name="name"></key-property> </composite-id> <property name="age" /> <!-- hibernater知道了怎么将class与表中的字段对应到一起了 --> </class> </hibernate-mapping>
### direct log messages to stdout ### log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.Target=System.out log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n ### direct messages to file hibernate.log ### #log4j.appender.file=org.apache.log4j.FileAppender #log4j.appender.file.File=hibernate.log #log4j.appender.file.layout=org.apache.log4j.PatternLayout #log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n ### set log levels - for more verbose logging change 'info' to 'debug' ### log4j.rootLogger=warn, stdout #log4j.logger.org.hibernate=info log4j.logger.org.hibernate=debug ### log HQL query parser activity #log4j.logger.org.hibernate.hql.ast.AST=debug ### log just the SQL #log4j.logger.org.hibernate.SQL=debug ### log JDBC bind parameters ### log4j.logger.org.hibernate.type=info #log4j.logger.org.hibernate.type=debug ### log schema export/update ### log4j.logger.org.hibernate.tool.hbm2ddl=debug ### log HQL parse trees #log4j.logger.org.hibernate.hql=debug ### log cache activity ### #log4j.logger.org.hibernate.cache=debug ### log transaction activity #log4j.logger.org.hibernate.transaction=debug ### log JDBC resource acquisition #log4j.logger.org.hibernate.jdbc=debug ### enable the following line if you want to track down connection ### ### leakages when using DriverManagerConnectionProvider ### #log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace
相关推荐
总结起来,使用Hibernate的`SchemaExport`工具进行数据库表的生成,是ORM理念在实际开发中的体现,它帮助我们更好地遵循面向对象的设计原则,简化了开发流程。通过定义对象和它们的映射关系,我们可以让Hibernate...
- **项目:hibernate_0500_CoreAPI** - `Configuration`类:配置Hibernate - `SessionFactory`类:创建`Session`实例 - `Session`类:执行CRUD操作 - `SchemaExport`类:自动化创建数据库表结构 - `Query`接口...
- **项目**:`hibernate_0500_CoreAPI` - **接口**: - `Configuration`:用于读取Hibernate配置信息,构建`SessionFactory`实例。 - `SessionFactory`:用于创建`Session`实例。 - `Session`:提供持久化操作的...
8. **工具支持**(14_工具.ppt):介绍Hibernate提供的工具,如SchemaExport工具用于生成数据库表结构,Hibernate Console工具辅助开发等。 这些课件内容旨在帮助学习者全面理解Hibernate的工作原理,掌握其基本...
1.5. 总结 2. 体系结构(Architecture) 2.1. 概况(Overview) 2.2. 实例状态 2.3. JMX整合 2.4. 对JCA的支持 2.5. 上下文相关的(Contextual)Session 3. 配置 3.1. 可编程的配置方式 3.2. 获得...
【Hibernate工作应用总结】 在IT行业中,Hibernate是一个广泛使用的对象关系映射(ORM)框架,它简化了Java应用程序与数据库之间的交互。以下是对Hibernate在实际工作应用中的总结,旨在帮助开发者更好地理解和使用...
最新hibernate 版本5.2.11.final--最新hibe--最新hibernate 版本5.2.11.finalrnate 版本5.2.11.final--最新hibernate 版本5.2.11.final
### Hibernate知识点总结 #### 一、Hibernate概述及入门 **1. HelloWorld** - **目的**:通过一个简单的示例,让初学者快速上手Hibernate,理解其基本工作流程。 - **步骤**: 1. 创建Java项目,命名为`...
以下是对 Hibernate 的详细总结: 1. **项目创建与依赖管理**: - 创建一个普通的 Java 项目,并引入 Hibernate 相关的库。这通常包括 Hibernate 的核心库和其他必要的依赖,如 MySQL 的 JDBC 驱动。在 Eclipse 中...
4. **工具和API**:介绍了Hibernate提供的各种工具,如SchemaExport用于生成数据库表结构,以及各种API的使用方法。 5. **扩展与插件**:讲解了如何扩展Hibernate,如自定义拦截器、事件监听器等,以及第三方插件的...
1.5. 总结 2. 体系结构(Architecture) 2.1. 概况(Overview) 2.2. 实例状态 2.3. JMX整合 2.4. 对JCA的支持 2.5. 上下文相关的(Contextual)Session 3. 配置 3.1. 可编程的配置方式 3.2. 获得...
例如,我们可以使用`Session.QueryOver()`来开始构建查询,并通过`Where()`、`And()`等方法添加条件。 2. Criteria:另一种查询方式是Criteria API,它提供了一种面向对象的方式来表达SQL查询。通过`Session....
8. **Fluent NHibernate**:除了XML映射,NHibernate也支持使用Fluent API进行映射,这是一种更直观且更易读的映射方式,通过C#代码直接定义映射规则。 9. **自动化脚本生成**:对于大型项目,可能需要自动化这个...
总结来说,这个压缩包提供了关于如何使用Hibernate和其hbm2ddl工具创建数据库表结构的完整教程。开发者可以通过阅读和实践这些文档,了解如何配置Hibernate,使其根据Java对象模型自动创建数据库,以及如何处理对象...
#### 五、总结 利用 Hibernate 自动生成数据库表不仅可以大大提高开发效率,还可以减少由于手动创建表带来的潜在错误。此外,这种方式还便于管理和维护,尤其是在需要支持多种数据库的情况下。希望本文能够帮助...
总结,Hibernate的动态生成表结构功能极大地方便了开发过程,减少了手动创建和维护数据库表的工作量。通过正确配置实体类和映射关系,我们可以轻松地管理和操作复杂的数据库结构。在实际项目中,根据需求选择合适的...
"Hibernate配置和基本连接测试... SchemaExport sExport = new SchemaExport(cfg); // todo: 添加测试逻辑 } } ``` 这只是Hibernate的基础学习和基本连接测试,后续还可以学习和实践Hibernate的其他特性和高级功能。
在这段代码中,`new SchemaExport(config)`创建了一个`SchemaExport`对象,`config`参数传递了数据库配置信息。`schemaExport.create(true, true)`方法会根据配置文件中的映射信息,创建数据库表。`true, true`参数...
-no-createdb --no-superuser --no-createrole --pwpromptcreatedb boac --owner=boaccreatedb boac_test --owner=boaccreatedb boac_loch_test --owner=boac# Load schemaexport FLASK_APP=run.pyflask initdb创建...
在描述中提到的“提供建表语句”,可以通过FluentNHibernate的SchemaExport类来实现。在运行时,我们可以导出映射的实体到数据库,生成相应的DDL语句,执行后即可创建对应的表结构。 至于关系映射,Fluent...