`

034_CoreAPI_SchemaExport_and_总结

 
阅读更多

生成建表的语句

可以在配置文件进行配置,自动生成建表语句

/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生成数据表

    总结起来,使用Hibernate的`SchemaExport`工具进行数据库表的生成,是ORM理念在实际开发中的体现,它帮助我们更好地遵循面向对象的设计原则,简化了开发流程。通过定义对象和它们的映射关系,我们可以让Hibernate...

    中山大学软件工厂hibernate课件

    8. **工具支持**(14_工具.ppt):介绍Hibernate提供的工具,如SchemaExport工具用于生成数据库表结构,Hibernate Console工具辅助开发等。 这些课件内容旨在帮助学习者全面理解Hibernate的工作原理,掌握其基本...

    HibernateAPI中文版.chm

    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工作中应用的总结.doc

    【Hibernate工作应用总结】 在IT行业中,Hibernate是一个广泛使用的对象关系映射(ORM)框架,它简化了Java应用程序与数据库之间的交互。以下是对Hibernate在实际工作应用中的总结,旨在帮助开发者更好地理解和使用...

    最新hibernate版本5.2.11final

    最新hibernate 版本5.2.11.final--最新hibe--最新hibernate 版本5.2.11.finalrnate 版本5.2.11.final--最新hibernate 版本5.2.11.final

    hibernate的一份知识点总结

    ### Hibernate知识点总结 #### 一、Hibernate概述及入门 **1. HelloWorld** - **目的**:通过一个简单的示例,让初学者快速上手Hibernate,理解其基本工作流程。 - **步骤**: 1. 创建Java项目,命名为`...

    hibernate总结

    以下是对 Hibernate 的详细总结: 1. **项目创建与依赖管理**: - 创建一个普通的 Java 项目,并引入 Hibernate 相关的库。这通常包括 Hibernate 的核心库和其他必要的依赖,如 MySQL 的 JDBC 驱动。在 Eclipse 中...

    hibernate3.5.0_final 所有参考文档 reference pdf

    4. **工具和API**:介绍了Hibernate提供的各种工具,如SchemaExport用于生成数据库表结构,以及各种API的使用方法。 5. **扩展与插件**:讲解了如何扩展Hibernate,如自定义拦截器、事件监听器等,以及第三方插件的...

    Hibernate_3.2.0_符合Java习惯的关系数据库持久化

    1.5. 总结 2. 体系结构(Architecture) 2.1. 概况(Overview) 2.2. 实例状态 2.3. JMX整合 2.4. 对JCA的支持 2.5. 上下文相关的(Contextual)Session 3. 配置 3.1. 可编程的配置方式 3.2. 获得...

    NHiberante Demo

    例如,我们可以使用`Session.QueryOver()`来开始构建查询,并通过`Where()`、`And()`等方法添加条件。 2. Criteria:另一种查询方式是Criteria API,它提供了一种面向对象的方式来表达SQL查询。通过`Session....

    nhibernate 由类文件,映射文件自动生成表的 源代码

    8. **Fluent NHibernate**:除了XML映射,NHibernate也支持使用Fluent API进行映射,这是一种更直观且更易读的映射方式,通过C#代码直接定义映射规则。 9. **自动化脚本生成**:对于大型项目,可能需要自动化这个...

    根据hibernate配置文件生成数据库.zip

    总结来说,这个压缩包提供了关于如何使用Hibernate和其hbm2ddl工具创建数据库表结构的完整教程。开发者可以通过阅读和实践这些文档,了解如何配置Hibernate,使其根据Java对象模型自动创建数据库,以及如何处理对象...

    hibernate根据字段生成数据库表

    #### 五、总结 利用 Hibernate 自动生成数据库表不仅可以大大提高开发效率,还可以减少由于手动创建表带来的潜在错误。此外,这种方式还便于管理和维护,尤其是在需要支持多种数据库的情况下。希望本文能够帮助...

    hibernate动态生成表结构

    总结,Hibernate的动态生成表结构功能极大地方便了开发过程,减少了手动创建和维护数据库表的工作量。通过正确配置实体类和映射关系,我们可以轻松地管理和操作复杂的数据库结构。在实际项目中,根据需求选择合适的...

    配置hibernate

    "Hibernate配置和基本连接测试... SchemaExport sExport = new SchemaExport(cfg); // todo: 添加测试逻辑 } } ``` 这只是Hibernate的基础学习和基本连接测试,后续还可以学习和实践Hibernate的其他特性和高级功能。

    hibernate反向生成数据库程序

    在这段代码中,`new SchemaExport(config)`创建了一个`SchemaExport`对象,`config`参数传递了数据库配置信息。`schemaExport.create(true, true)`方法会根据配置文件中的映射信息,创建数据库表。`true, true`参数...

    boac:伯克利在线咨询(BOA)

    -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_oracle.rar

    在描述中提到的“提供建表语句”,可以通过FluentNHibernate的SchemaExport类来实现。在运行时,我们可以导出映射的实体到数据库,生成相应的DDL语句,执行后即可创建对应的表结构。 至于关系映射,Fluent...

Global site tag (gtag.js) - Google Analytics