生成建表的语句
可以在配置文件进行配置，自动生成建表语句
/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