第二十一部分_Hibernate级联关系详解
接下来我们开始介绍Hibernate的数据类型，因为我们现在暂时只关注Hibernate这块，因此我们这次只建立一个Java Project，命名为hibernate2。
加入hibernate JAR包：
选择hibernate2项目，点击MyEclipse->Add Hibernate Capabilities, Hibernate Specification与风中页老师的相同，为Hibernate3.2，点击next，继续next，去掉Specify database connection details前面的√接着next，去掉Create SessionFactory class？前面的√点击Finish。
把上一个hibernate项目的hibernate.cfg.xml文件拷贝过来，覆盖掉当前src下面的hibernate.cfg.xml文件，修改mapping信息：
<?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">
<!-- Generated by MyEclipse Hibernate Tools. -->
<hibernate-configuration>
<session-factory>
<property name="show_sql">true</property> <!-- 属性之间没有上下关系，放在哪里都行 -->
<property name="connection.url">jdbc:mysql://localhost:3306/myhibernate2</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<mapping resource="Customers.hbm.xml"/> <!-- 将主配置文件包含对象-关系映射文件，之所以映射是因为hibernate启动时只会加载主配置文件 -->
</session-factory>
</hibernate-configuration>
添加MySql驱动，从hibernate项目拷贝mysql-connector-java-5.1.34-bin.jar到hibernate根目录下。
创建表：（bigint即long类型；bit即boolean类型；timestamp也是一个日期类型的，比date精度更高，可以精确到毫秒；blob即二进制大型物件）
mysql> create table CUSTOMERS(
-> ID bigint not null primary key,
-> NAME varchar(15) not null,
-> EMAIL varchar(128) not null,
-> PASSWORD varchar(8) not null,
-> PHONE int,
-> ADDRESS varchar(255),
-> SEX char(1),
-> IS_MARRIED bit,
-> DESCRIPTION text,
-> IMAGE blob,
-> BIRTHDAY date,
-> REGISTERED_TIME timestamp
-> );
新建com.test.bean包，在该包下面新建一个类Customer.java:
package com.test.bean;
import java.sql.Date;
import java.sql.Timestamp;
public class Customer
{
private Long id;
private String name;
private String email;
private String password;
private int phone; // or Integer
private String address;
private char sex;
private boolean married;
private String description;
private byte[] image;
private Date birthday;
private Timestamp registeredTime;
public Long getId()
{
return id;
}
public void setId(Long id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String getEmail()
{
return email;
}
public void setEmail(String email)
{
this.email = email;
}
public String getPassword()
{
return password;
}
public void setPassword(String password)
{
this.password = password;
}
public int getPhone()
{
return phone;
}
public void setPhone(int phone)
{
this.phone = phone;
}
public String getAddress()
{
return address;
}
public void setAddress(String address)
{
this.address = address;
}
public char getSex()
{
return sex;
}
public void setSex(char sex)
{
this.sex = sex;
}
public boolean isMarried()
{
return married;
}
public void setMarried(boolean married)
{
this.married = married;
}
public String getDescription()
{
return description;
}
public void setDescription(String description)
{
this.description = description;
}
public byte[] getImage()
{
return image;
}
public void setImage(byte[] image)
{
this.image = image;
}
public Date getBirthday()
{
return birthday;
}
public void setBirthday(Date birthday)
{
this.birthday = birthday;
}
public Timestamp getRegisteredTime()
{
return registeredTime;
}
public void setRegisteredTime(Timestamp registeredTime)
{
this.registeredTime = registeredTime;
}
}
在src下面新建一个Customers.hbm.xml：
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.test.bean.Customer" table="customers"> <!-- 将类与表相关联，使得类中的属性和表中的字段关联起来 --> <id name="id" column="id" type="long"> <!-- 类中id属性和映射到表中的id字段，类型为int/integer皆可 --> <generator class="increment"> <!-- 主键id的生成方式为自增 --> </generator> </id> <property name="name" column="name" type="string" not-null="true"></property> <!-- 如果不写字段名，则默认与类中的属性名相同 ;hibernate层和数据库层都可以对非空进行检查--> <property name="email" column="email" type="string" not-null="true"></property> <property name="password" column="password" type="string" not-null="true"></property> <property name="phone" column="phone" type="int"></property> <property name="address" column="address" type="string" ></property> <property name="sex" column="sex" type="character" ></property> <property name="married" column="is_married" type="boolean" ></property> <property name="description" column="description" type="text"></property> <property name="image" column="image" type="binary" ></property> <property name="birthday" column="birthday" type="date" ></property> <property name="registeredTime" column="registered_time" type="timestamp"></property> </class> </hibernate-mapping>
在com.test.bean包下面，创建测试类HibernateTest.java同时放置一个photo.gif文件：
package com.test.bean;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.sql.Date;
import java.util.Iterator;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class HibernateTest
{
public static SessionFactory sessionFactory;
static
{
try
{
Configuration config = new Configuration().configure();
sessionFactory = config.buildSessionFactory();
}
catch (Exception e)
{
e.printStackTrace();
}
}
public void findAllCustomers(PrintStream out) throws Exception
{
// Ask for a session using the JDBC information we've configured
Session session = sessionFactory.openSession();
Transaction tx = null;
try
{
tx = session.beginTransaction();
List customers = session.createQuery("from Customer as c order by c.name asc").list();
for (Iterator it = customers.iterator(); it.hasNext();)
{
printCustomer(out, (Customer) it.next());
}
// We're done; make our changes permanent
tx.commit();
}
catch (Exception e)
{
if (tx != null)
{
// Something went wrong; discard all partial changes
tx.rollback();
}
throw e;
}
finally
{
// No matter what, close the session
session.close();
}
}
public static void saveCustomer(Customer customer) throws Exception
{
// Ask for a session using the JDBC information we've configured
Session session = sessionFactory.openSession();
Transaction tx = null;
try
{
tx = session.beginTransaction();
session.save(customer);
// We're done; make our changes permanent
tx.commit();
}
catch (Exception e)
{
if (tx != null)
{
// Something went wrong; discard all partial changes
tx.rollback();
}
throw e;
}
finally
{
// No matter what, close the session
session.close();
}
}
public void loadAndUpdateCustomer(Long customer_id, String address)
throws Exception
{
// Ask for a session using the JDBC information we've configured
Session session = sessionFactory.openSession();
Transaction tx = null;
try
{
tx = session.beginTransaction();
Customer c = (Customer) session.load(Customer.class, customer_id);
c.setAddress(address);
// We're done; make our changes permanent
tx.commit();
}
catch (Exception e)
{
if (tx != null)
{
// Something went wrong; discard all partial changes
tx.rollback();
}
throw e;
}
finally
{
// No matter what, close the session
session.close();
}
}
public void deleteAllCustomers() throws Exception
{
// Ask for a session using the JDBC information we've configured
Session session = sessionFactory.openSession();
Transaction tx = null;
try
{
tx = session.beginTransaction();
Query query = session.createQuery("from Customer");
List list = query.list();
for (Iterator i = list.iterator(); i.hasNext();)
{
session.delete((Customer) i.next());
}
tx.commit();
}
catch (Exception e)
{
if (tx != null)
{
// Something went wrong; discard all partial changes
tx.rollback();
}
throw e;
}
finally
{
// No matter what, close the session
session.close();
}
}
private void printCustomer(PrintStream out, Customer customer)
throws Exception
{
byte[] buffer = customer.getImage();
OutputStream fout = new FileOutputStream("photo_copy.gif");
fout.write(buffer);
fout.close();
out.println("------以下是" + customer.getName() + "的个人信息------");
out.println("ID: " + customer.getId());
out.println("口令: " + customer.getPassword());
out.println("E-Mail: " + customer.getEmail());
out.println("电话: " + customer.getPhone());
out.println("地址: " + customer.getAddress());
String sex = customer.getSex() == 'M' ? "男" : "女";
out.println("性别: " + sex);
String marriedStatus = customer.isMarried() ? "已婚" : "未婚";
out.println("婚姻状况: " + marriedStatus);
out.println("生日: " + customer.getBirthday());
out.println("注册时间: " + customer.getRegisteredTime());
out.println("自我介绍: " + customer.getDescription());
}
public void test(PrintStream out) throws Exception
{
Customer customer = new Customer();
customer.setName("zhangsan");
customer.setEmail("zhangsan@yahoo.com");
customer.setPassword("1234");
customer.setPhone(1381234);
customer.setAddress("Shanghai");
customer.setSex('M');
customer.setDescription("I am very honest.");
InputStream in = this.getClass().getResourceAsStream("photo.gif");
byte[] buffer = new byte[in.available()];
in.read(buffer);
customer.setImage(buffer);
customer.setBirthday(Date.valueOf("1980-05-06"));
saveCustomer(customer);
findAllCustomers(out);
loadAndUpdateCustomer(customer.getId(), "Tianjin");
findAllCustomers(out);
deleteAllCustomers();
}
public static void main(String args[]) throws Exception
{
new HibernateTest().test(System.out);
sessionFactory.close();
}
}
通过给一下几行代码添加注释的方式进行测试：
saveCustomer(customer); findAllCustomers(out); loadAndUpdateCustomer(customer.getId(), "Tianjin"); findAllCustomers(out); deleteAllCustomers();
运行后在hibernate2根目录下面会生成一个photo_copy.gif图形文件。
上面的例子比较简单，下面我们看一个复杂的：表与表之间存在关联关系，类与类之间存在关联关系：
新建一个名为hibernate3的Java Project，导入相应的hibernate包（操作过程如之前所述）。
配置hibernate.cfg.xml:
<?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">
<!-- Generated by MyEclipse Hibernate Tools. -->
<hibernate-configuration>
<session-factory>
<property name="show_sql">true</property> <!-- 属性之间没有上下关系，放在哪里都行 -->
<property name="connection.url">jdbc:mysql://localhost:3306/myhibernate3</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<mapping resource="Customer.hbm.xml"/> <!-- 将主配置文件包含对象-关系映射文件，之所以映射是因为hibernate启动时只会加载主配置文件 -->
<mapping resource="Order.hbm.xml"/>
</session-factory>
</hibernate-configuration>
接下来创建两个域模型，一个是Customer，一个是Order：
src下面新建包com.test，在该包下面新建类：Customer.java：
package com.test;
import java.util.Set;
public class Customer
{
private Long id;
private String name;
private Set orders; // 一对多，通过该变量可以引用到对应的Order集合对象
public Customer(String name, Set orders)
{
this.name = name;
this.orders = orders;
}
// hibernate一般要求我们提供一个不带参数的构造方法，为了符合hibernate要求，因此：
public Customer()
{
}
public Customer(Set orders)
{
this.orders = orders;
}
public Long getId()
{
return id;
}
public void setId(Long id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public Set getOrders()
{
return orders;
}
public void setOrders(Set orders)
{
this.orders = orders;
}
}
接着新建与Customer成多对一关系的Order.java类：
package com.test;
public class Order
{
private Long id;
private String orderNumber;
private Customer customer; // 多对一，通过该变量可以引用到对应的Customer
public Order(String orderNumber, Customer customer)
{
this.orderNumber = orderNumber;
this.customer = customer;
}
public Order()
{
}
public Long getId()
{
return id;
}
public void setId(Long id)
{
this.id = id;
}
public String getOrderNumber()
{
return orderNumber;
}
public void setOrderNumber(String orderNumber)
{
this.orderNumber = orderNumber;
}
public Customer getCustomer()
{
return customer;
}
public void setCustomer(Customer customer)
{
this.customer = customer;
}
}
下面，在数据模型，写配置文件，在这之前需要建立两张表：
数据库Schema：
create table customers(
ID bigint not null,
NAME varchar(15),
primary key(ID)
);
create table orders(
ID bigint not null,
ORDER_NUMBER varchar(15),
CUSTOMER_ID bigint not null,
primary key(ID)
);
alter table orders add index IDX_CUSTOMER_ID(CUSTOMER_ID),
add constraint FK_CUSTOMER_ID foreign key (CUSTOMER_ID) references customers(ID);
接下来在src下创建Customer.hbm.xml:
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.test.Customer" table="customers"> <!-- 将类与表相关联，使得类中的属性和表中的字段关联起来 --> <id name="id" column="id" type="long"> <!-- 类中id属性和映射到表中的id字段，类型为int/integer皆可 --> <generator class="increment"> <!-- 主键id的生成方式为自增 --> </generator> </id> <property name="name" type="string"> <column name="name" length="15"></column> <!-- 第二种定义column的方式，可以进行精细化配置 --> </property> <set name="orders" cascade="save-update" inverse="true"> <!-- 反转属性为true，表示关联关系由多的一方维持，这是hibernate的一个最佳实践。 --> <key column="customer_id"></key> <!-- key元素设定与所关联的持久化类对应的表的外键 --> <one-to-many class="com.test.Order"/> </set> </class> </hibernate-mapping>
继续在src下创建Order.hbm.xml:
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.test.Order" table="orders"> <id name="id" column="id" type="long"> <generator class="increment"> </generator> </id> <property name="orderNumber" type="string"> <column name="order_number" length="15"></column> </property> <many-to-one name="customer" column="customer_id" class="com.test.Customer"> </many-to-one> </class> </hibernate-mapping>
最后，不要忘记引入mysql的驱动：mysql-connector-java-5.1.34-bin.jar
然后，为了验证我们的配置是否正确且如愿生效，我们编写一个测试类，在com.test包下面新建一个类Test.java:
package com.test;
import java.util.HashSet;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class Test
{
public static SessionFactory sessionFactory;
static
{
try
{
sessionFactory = new Configuration().configure().
buildSessionFactory();
}
catch(Exception ex)
{
System.out.println("exeception occured");
ex.printStackTrace();
}
}
public static void saveCustomerAndOrderWithCascade() throws Exception
{
Session session = sessionFactory.openSession();
Transaction tx = null;
try
{
tx = session.beginTransaction();
Customer customer = new Customer("zhangsan", new HashSet());
Order order = new Order();
order.setOrderNumber("zhangsan_order1");
Order order2 = new Order();
order2.setOrderNumber("zhangsan_order2");
Order order3 = new Order();
order3.setOrderNumber("zhangsan_order3");
order.setCustomer(customer); // 将一的一方关联到多的一方
order2.setCustomer(customer);
order3.setCustomer(customer);
customer.getOrders().add(order); // 将多的一方增加到一的一方
customer.getOrders().add(order2);
customer.getOrders().add(order3);
session.save(customer);
tx.commit();
}
catch(Exception ex)
{
if(null != tx)
tx.rollback();
ex.printStackTrace();
}
finally
{
if(null != session)
session.close();
}
}
public static void main(String[] args) throws Exception
{
saveCustomerAndOrderWithCascade();
}
}
执行结果：Console输出：
Hibernate: select max(id) from customers Hibernate: select max(id) from orders Hibernate: insert into customers (name, id) values (?, ?) Hibernate: insert into orders (order_number, customer_id, id) values (?, ?, ?) Hibernate: insert into orders (order_number, customer_id, id) values (?, ?, ?) Hibernate: insert into orders (order_number, customer_id, id) values (?, ?, ?)
进入数据库中查看，我们发现orders表中的外键已经关联到customers表中的主键上了。
补充图例：
下面，继续进行探索，对于树模型的关系——找到一个节点，能找到它的多个子节点（或者没有）和唯一（或者没有）的父节点，如：
首先建立域模型：在hibernate3项目下的com.test包下建立类：Category.java:
package com.test;
import java.util.Set;
public class Category
{
private Long id;
private String name;
private Category parentCategory;
private Set childCategories;
public Category(String name, Category parentCategory, Set childCategories)
{
this.name = name;
this.parentCategory = parentCategory;
this.childCategories = childCategories;
}
public Category()
{
}
public Category(Set childCategories)
{
this.childCategories = childCategories;
}
public Long getId()
{
return id;
}
public void setId(Long id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public Category getParentCategory()
{
return parentCategory;
}
public void setParentCategory(Category parentCategory)
{
this.parentCategory = parentCategory;
}
public Set getChildCategories()
{
return childCategories;
}
public void setChildCategories(Set childCategories)
{
this.childCategories = childCategories;
}
}
建立表，数据库Schema：
create table categories( ID bigint not null, NAME varchar(15), CATEGORY_ID bigint, primary key(ID) ); alter table categories add index IDX_CATEGORY_ID(CATEGORY_ID), add constraint FK_CATEGORY_ID foreign key(CATEGORY_ID) references categories(ID);
建立Category.hbm.xml文件：
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.test.Category" table="categories"> <!-- 将类与表相关联，使得类中的属性和表中的字段关联起来 --> <id name="id" column="id" type="long"> <!-- 类中id属性和映射到表中的id字段，类型为int/integer皆可 --> <generator class="increment"> <!-- 主键id的生成方式为自增 --> </generator> </id> <property name="name" type="string"> <column name="name" length="15"></column> <!-- 第二种定义column的方式，可以进行精细化配置 --> </property> <!-- 反转属性为true，表示关联关系由多的一方维持，这是hibernate的一个最佳实践。 --> <set name="childCategories" cascade="all" inverse="true"> <!-- cascade="all"表示保存、更新或删除当前对象时级联其他关联的对象 --> <key column="category_id"></key> <!-- key元素设定与所关联的持久化类对应的表的外键 --> <one-to-many class="com.test.Category"/> </set> <many-to-one name="parentCategory" column="category_id" class="com.test.Category"> </many-to-one> </class> </hibernate-mapping>
接下来，在Test.java中增加方法——saveCategoryWithCascade和deleteCategoryWithCascade:
package com.test;
import java.util.HashSet;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class Test
{
public static SessionFactory sessionFactory;
static
{
try
{
sessionFactory = new Configuration().configure().
buildSessionFactory();
}
catch(Exception ex)
{
System.out.println("exeception occured");
ex.printStackTrace();
}
}
public static void saveCustomerAndOrderWithCascade() throws Exception
{
Session session = sessionFactory.openSession();
Transaction tx = null;
try
{
tx = session.beginTransaction();
Customer customer = new Customer("zhangsan", new HashSet());
Order order = new Order();
order.setOrderNumber("zhangsan_order1");
Order order2 = new Order();
order2.setOrderNumber("zhangsan_order2");
Order order3 = new Order();
order3.setOrderNumber("zhangsan_order3");
order.setCustomer(customer); // 将一的一方关联到多的一方
order2.setCustomer(customer);
order3.setCustomer(customer);
customer.getOrders().add(order); // 将多的一方增加到一的一方
customer.getOrders().add(order2);
customer.getOrders().add(order3);
session.save(customer);
tx.commit();
}
catch(Exception ex)
{
if(null != tx)
tx.rollback();
ex.printStackTrace();
}
finally
{
if(null != session)
session.close();
}
}
@SuppressWarnings("unchecked")
public static void saveCategoryWithCascade() throws Exception
{
Session session = sessionFactory.openSession();
Transaction tx = null;
try
{
tx = session.beginTransaction();
// 根据图例，创建食品类别、蔬菜类别、水果类别、西红柿类别、苹果类别、桔子类别。
Category foodCategory = new Category("food", null, new HashSet());
Category fruitCategory = new Category("fruit", null, new HashSet());
Category vegetableCategory = new Category("vegetable", null, new HashSet());
Category appleCategory = new Category("apple", null, new HashSet());
Category orangeCategory = new Category("orange", null, new HashSet());
Category tomatoCategory = new Category("tomato", null, new HashSet());
foodCategory.getChildCategories().add(fruitCategory);
fruitCategory.setParentCategory(foodCategory);
foodCategory.getChildCategories().add(vegetableCategory);
vegetableCategory.setParentCategory(foodCategory);
fruitCategory.getChildCategories().add(appleCategory);
appleCategory.setParentCategory(fruitCategory);
fruitCategory.getChildCategories().add(orangeCategory);
orangeCategory.setParentCategory(fruitCategory);
vegetableCategory.getChildCategories().add(tomatoCategory);
tomatoCategory.setParentCategory(vegetableCategory);
session.save(foodCategory); // 级联保存所有的关联对象
tx.commit();
}
catch(Exception ex)
{
if(null != tx)
tx.rollback();
ex.printStackTrace();
}
finally
{
if(null != session)
session.close();
}
}
public static void deleteCategoryWithCascade() throws Exception
{
Session session = sessionFactory.openSession();
Transaction tx = null;
try
{
tx = session.beginTransaction();
// session.get和session.load方法完成的功能是一样的，接受参数类型也是一样的，它们之间的唯一差别在于根据主键寻找某一个对象
// 如果找不到，get方法返回一个null，而load方法直接抛异常。
Category category = (Category)session.load(Category.class, new Long(1));
session.delete(category); // 级联保存所有的关联对象
tx.commit();
}
catch(Exception ex)
{
if(null != tx)
tx.rollback();
ex.printStackTrace();
}
finally
{
if(null != session)
session.close();
}
}
public static void main(String[] args) throws Exception
{
// saveCustomerAndOrderWithCascade();
// saveCategoryWithCascade();
deleteCategoryWithCascade();
}
}
最后在主配置文件hibernate.cfg.xml中增加对Category.hbm.xml文件的映射：
<?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">
<!-- Generated by MyEclipse Hibernate Tools. -->
<hibernate-configuration>
<session-factory>
<property name="show_sql">true</property> <!-- 属性之间没有上下关系，放在哪里都行 -->
<property name="connection.url">jdbc:mysql://localhost:3306/myhibernate3</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<mapping resource="Customer.hbm.xml"/> <!-- 将主配置文件包含对象-关系映射文件，之所以映射是因为hibernate启动时只会加载主配置文件 -->
<mapping resource="Order.hbm.xml"/>
<mapping resource="Category.hbm.xml" />
</session-factory>
</hibernate-configuration>
运行Test.java程序，可以看到保存和删除都已经实现了级联操作。
下面我们来看如何用hibernate表示一对一和多对多关系：
一对一在实际开发中用的也比较多，比如一个人对应一个身份证。这种一对一的关系可以使用共用主键来表达。首先导入工程hibernate1（风中叶银行企陪day6）
Student 和 Certificate 类及其相关的映射文件
package model;
public class Student
{
private String id; // 标识id
private String cardId; // 学号
private String name; // 学生姓名
private int age; // 岁数
private Certificate cer;// 身分证
private Team team;// 班级
public int getAge()
{
return age;
}
public String getName()
{
return name;
}
public String getCardId()
{
return cardId;
}
private void setId(String id)
{
this.id = id;
}
public void setAge(int age)
{
this.age = age;
}
public void setName(String stuName)
{
this.name = stuName;
}
public void setCardId(String cardId)
{
this.cardId = cardId;
}
public String getId()
{
return id;
}
public Student()
{ // 无参的构造函数
}
public Certificate getCer()
{
return cer;
}
public void setCer(Certificate pass)
{
this.cer = pass;
}
/**
* @return 返回 team。
*/
public Team getTeam()
{
return team;
}
/**
* @param team
* 要设置的 team。
*/
public void setTeam(Team team)
{
this.team = team;
}
}
----------------------------------------------------------------------------
package model;
public class Certificate
{
private String id;
private String describe;
private Student stu;
/**
* @return 返回 stu。
*/
public Student getStu()
{
return stu;
}
/**
* @param stu
* 要设置的 stu。
*/
public void setStu(Student stu)
{
this.stu = stu;
}
/**
* @return 返回 describe。
*/
public String getDescribe()
{
return describe;
}
/**
* @param describe
* 要设置的 describe。
*/
public void setDescribe(String describe)
{
this.describe = describe;
}
/**
* @return 返回 id。
*/
public String getId()
{
return id;
}
/**
* @param id
* 要设置的 id。
*/
private void setId(String id)
{
this.id = id;
}
}
-----------------------------------------------------------------
Student.hbm.xml:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="model.Student" table="student" lazy="true"><!--把类和数表关联起来-->
<id name="id" unsaved-value="null"><!--id的产生方式是uuid.hex-->
<generator class="uuid.hex" /> <!-- 或者写uuid也可以 -->
</id>
<property name="cardId" type="string" /><!--映射号-->
<property name="name" type="string" /><!--映射学生名-->
<property name="age" type="int" /><!--映射学生岁数-->
<one-to-one name="cer" class="model.Certificate" fetch="join" cascade="all" /><!--映射对应的身分证对象-->
</class>
</hibernate-mapping>
----------------------------------------------------------------------------------------------------------
Certificate.hbm.xml:
<?xml version="1.0" encoding="GB2312"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="model.Certificate" table="certificate" lazy="true">
<id name="id">
<generator class="foreign">
<param name="property" >stu</param> <!-- stu是Certificate类的一个成员变量 -->
</generator>
</id>
<!-- describe是数据库中的一个保留字，不能作为字段名，因此需要加上``(键盘1左边的) -->
<property name="describe" column="`describe`" type="string" />
<one-to-one name="stu" class="model.Student" fetch="select"
constrained="true" cascade="none"/> <!-- cascade设置为none说明身份证丢(删除操作)了不能说明人没了：~ -->
</class>
</hibernate-mapping>
schema：
drop database if exists schoolproject;
create database schoolproject;
use schoolproject;
drop table if exists certificate;
CREATE TABLE certificate (
id varchar(100) NOT NULL default '',
`describe` varchar(100) default '',
PRIMARY KEY (id)
) ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;
--
-- Dumping data for table 'certificate'
--
INSERT INTO certificate VALUES ('ff80808105416d3b0105416d3eca0001','tomclus');
INSERT INTO certificate VALUES ('ff808081054175b501054175b9190001','tom');
--
-- Table structure for table 'student'
--
drop table if exists student;
CREATE TABLE student (
id varchar(100) NOT NULL default '',
name varchar(20) default '',
`cardId` varchar(20) NOT NULL default '',
age int(11) default '0',
PRIMARY KEY (id)
) ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;
--
-- Dumping data for table 'student'
--
INSERT INTO student VALUES ('ff80808105416d3b0105416d3eca0001','tomclus','200512345',33);
INSERT INTO student VALUES ('ff808081054175b501054175b9190001','tom','11111111',33);
BM.java(business manager)
package BusinessManager;
import model.Certificate;
import model.Student;
import org.hibernate.HibernateException;
import persistence.StudentDAO;
public class BM
{
public static void main(String[] args) throws HibernateException
{
Student stu = new Student();
stu.setName("spark");
stu.setCardId("200211332");
stu.setAge(33);
Certificate cer = new Certificate();
cer.setDescribe("spark");
//设定学生与身份证之间的关联关系
stu.setCer(cer);
cer.setStu(stu);
StudentDAO.saveObj(stu);
}
}
下面是与之相关的类BaseDAO、StudentDAO、HibernateUtil：
package persistence;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
/**
* @author Administrator
*
* TODO 要更改此生成的类型注释的模板，请转至 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/
public class BaseDAO
{
static Session session = null;
static Transaction tx = null;
/*------------创建新对象-----------------*/
public static void saveObj(Object o)
{
try
{
session = HibernateUtil.currentSession(); // 开启连接
tx = session.beginTransaction(); // 开启事务
session.save(o);
tx.commit();
}
catch (HibernateException e)
{ // 捕捉例外
e.printStackTrace();
tx.rollback();
}
finally
{
if (session != null)
HibernateUtil.closeSession(session);
}
}
/*------------删除对象-----------------*/
public static void delObject(Object o)
{
try
{
session = HibernateUtil.currentSession(); // 开启连接
Transaction tx = session.beginTransaction(); // 开启事务
session.delete(o);
tx.commit();
}
catch (HibernateException e)
{ // 捕捉例外
e.printStackTrace();
tx.rollback();
}
finally
{
HibernateUtil.closeSession(session);
}
}
/*------------修改对象-----------------*/
public static void updateObj(Object o)
{
try
{
session = HibernateUtil.currentSession(); // 开启连接
Transaction tx = session.beginTransaction(); // 开启事务
session.update(o);
tx.commit();
}
catch (HibernateException e)
{ // 捕捉例外
e.printStackTrace();
tx.rollback();
}
finally
{
HibernateUtil.closeSession(session);
}
}
}
/*
* 创建日期 2005-7-2
*
* TODO 要更改此生成的文件的模板，请转至
* 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/
package persistence;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;
import model.Student;
import org.hibernate.FlushMode;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.ScrollableResults;
import org.hibernate.Session;
import org.hibernate.Transaction;
/**
* @author Administrator
*
* TODO 要更改此生成的类型注释的模板，请转至 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/
public class StudentDAO extends BaseDAO
{
static Session session = null;
static Transaction tx = null;
public static void update()
{
Student stu = null;
try
{
session = HibernateUtil.currentSession(); // 开启连接
tx = session.beginTransaction(); // 开启事务
Query query = session.getNamedQuery("queryStudent_byAgeAdnName");
query.setInteger("minAge", 25); // 设置“:”号后的minAge变量值
query.setString("likeName", "%clus%");// 设置“:”号后的likeName变量值
List list = query.list();
for (int i = 0; i < list.size(); i++)
{
stu = (Student) list.get(i);
System.out.println(stu.getName());
}
tx.commit();
}
catch (HibernateException e)
{ // 捕捉例外
e.printStackTrace();
tx.rollback();
}
finally
{
HibernateUtil.closeSession(session);
}
}
}
package persistence;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtil
{
private static final SessionFactory sessionFactory;
static
{
try
{
sessionFactory = new Configuration().configure()
.buildSessionFactory();
}
catch (HibernateException ex)
{
throw new RuntimeException("Exception building SessionFactory: "
+ ex.getMessage(), ex);
}
}
public static Session currentSession()
{
Session s = sessionFactory.openSession();
return s;
}
public static void closeSession(Session s)
{
s.close();
}
}
引入MySql驱动，执行BM.java方法，执行一次保存操作后表中存储的数据有：
mysql> select * from student; +----------------------------------+---------+-----------+-----+ | id | name | cardId | age | +----------------------------------+---------+-----------+-----+ | 40281f815004a9ef015004a9f0860001 | spark | 200211332 | 33 | | ff80808105416d3b0105416d3eca0001 | tomclus | 200512345 | 33 | | ff808081054175b501054175b9190001 | tom | 11111111 | 33 | +----------------------------------+---------+-----------+-----+ 3 rows in set mysql> select * from certificate; +----------------------------------+----------+ | id | describe | +----------------------------------+----------+ | 40281f815004a9ef015004a9f0860001 | spark | | ff80808105416d3b0105416d3eca0001 | tomclus | | ff808081054175b501054175b9190001 | tom | +----------------------------------+----------+ 3 rows in set mysql>
可以看到一对一的主键关联已经成功实现了。
一对一的第二种实现方式：其实还是通过外键来关联的（这种实现方式实际上就是退化了的一对多关联）。重命名当前工作空间下的hibernate2项目，导入风中叶老师的hibernate2（day6），可以看到Student.java、Certificate.java、Student.hbm.xml都没用任何变换，唯一变化的是id的生成方式，和删除了one-to-one标签增加了many-to-one标签。
Certificate.hbm.xml:
<?xml version="1.0" encoding="GB2312"?> <!DOCTYPE hibernate-mapping SYSTEM "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" > <hibernate-mapping> <class name="model.Certificate" table="certificate" lazy="true"> <id name="id"> <generator class="uuid.hex" /> </id> <property name="describe" column="`describe`" type="string" /> <many-to-one name="stu" class="model.Student" unique="true" <!-- 多对一，而多的一方又是唯一的，暗示着多对一已经退化成了一对一了 --> column="stu_id" <!-- 外键 --> /> <!-- 唯一的多对一，实际也就变成一对一关系了 --> </class> </hibernate-mapping>
数据库schema：
drop database if exists schoolproject;
create database schoolproject;
use schoolproject;
--
-- Table structure for table `certificate`
--
DROP TABLE IF EXISTS `certificate`;
CREATE TABLE `certificate` (
`id` varchar(100) NOT NULL default '',
`describe` varchar(100) default '',
`stu_id` varchar(32) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
--
-- Dumping data for table `certificate`
--
/*!40000 ALTER TABLE `certificate` DISABLE KEYS */;
LOCK TABLES `certificate` WRITE;
INSERT INTO `certificate` VALUES ('5abfa70605c5356f0105c53573360002','tomclus','5abfa70605c5356f0105c535730e0001');
INSERT INTO `certificate` VALUES ('5abfa70605c535a60105c535aa370002','tom','5abfa70605c535a60105c535aa040001');
UNLOCK TABLES;
/*!40000 ALTER TABLE `certificate` ENABLE KEYS */;
--
-- Table structure for table `student`
--
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
`id` varchar(100) NOT NULL default '',
`name` varchar(20) default '',
`cardId` varchar(20) NOT NULL default '',
`age` int(11) default '0',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
--
-- Dumping data for table `student`
--
/*!40000 ALTER TABLE `student` DISABLE KEYS */;
LOCK TABLES `student` WRITE;
INSERT INTO `student` VALUES ('5abfa70605c5356f0105c535730e0001','tomclus','200212345',33);
INSERT INTO `student` VALUES ('5abfa70605c535a60105c535aa040001','tom','200254321',33);
UNLOCK TABLES;
执行BM.java，里面的代码跟之前的一模一样。可以看到certificate表的stu_id已经和student表的id关联起来了。
下面我们来看相对来说最复杂的一种：多对多的映射类型
重命名当前项目下的hibernate3，导入风中叶老师的hibernate3（day6），我们看一下学生和课程之间的多对多通过hibernate如何实现。
多对多在程序中如何体现：两个类Student、Course，分别定义两个集合类型的变量：
package model;
import java.util.Set;
public class Student
{
private String id; // 标识id
private String cardId; // 学号
private String name; // 学生姓名
private int age; // 岁数
private Set Courses;// 课程
public int getAge()
{
return age;
}
public String getName()
{
return name;
}
public String getCardId()
{
return cardId;
}
private void setId(String id)
{
this.id = id;
}
public void setAge(int age)
{
this.age = age;
}
public void setName(String stuName)
{
this.name = stuName;
}
public void setCardId(String cardId)
{
this.cardId = cardId;
}
public String getId()
{
return id;
}
public Student()
{ // 无参的构造函数
}
/**
* @return 返回 courses。
*/
public Set getCourses()
{
return Courses;
}
/**
* @param courses
* 要设置的 courses。
*/
public void setCourses(Set courses)
{
Courses = courses;
}
}
package model;
import java.util.HashSet;
import java.util.Set;
public class Course
{
private String id;
private String name;
private Set Students = new HashSet();
/**
* @return 返回 id。
*/
public String getId()
{
return id;
}
/**
* @param id
* 要设置的 id。
*/
public void setId(String id)
{
this.id = id;
}
/**
* @return 返回 name。
*/
public String getName()
{
return name;
}
/**
* @param name
* 要设置的 name。
*/
public void setName(String name)
{
this.name = name;
}
/**
* @return 返回 students。
*/
public Set getStudents()
{
return Students;
}
/**
* @param students
* 要设置的 students。
*/
public void setStudents(Set students)
{
Students = students;
}
}
而在数据库中要想体现多对多的关系，就需要使用连接表，连接表中的内容就是stu_id和course_id。一条这样的记录，就表示一个映射：该学生选择了该课程，该课程被该学生所选。
Student.hbm.xml：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="model.Student" table="student"
select-before-update="true"><!--把类和数表关联起来-->
<id name="id" unsaved-value="null"><!--id的产生方式是uuid.hex-->
<generator class="uuid.hex" />
</id>
<property name="cardId" type="string" /><!--映射号-->
<property name="name" type="string" /><!--映射学生名-->
<property name="age" type="int" /><!--映射学生岁数-->
<!-- 如果不设置inverse为true的话，会抛出约束违规异常，Duplicate entry。因为inverse的默认值为false，表示自己维持级联关系，这样在执行save操作时，student和course都要维持(向表中插入一条记录)就会抛异常 -->
<!-- cascade绝对不能设为all或者delete，因为删除课程不能删除学生，删除了一个学生也不应该把这个学生的课程删除 -->
<set name="courses" table="student_course"
cascade="none" inverse="true">
<key column="stu_id" /> <!-- 字段stu_id代表中间表student_course中的字段 -->
<many-to-many class="model.Course"
column="course_id" /> <!-- 字段course_id代表中间表student_course中的字段 -->
</set>
</class>
</hibernate-mapping>
Course.hbm.xml:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="model.Course" table="course"
select-before-update="true"><!--把类和数表关联起来-->
<id name="id" unsaved-value="null" ><!--id的产生方式是uuid.hex-->
<generator class="uuid.hex" />
</id>
<property name="name" type="string" /><!--映射课程名-->
<set name="students" table="student_course"
cascade="save-update">
<key column="course_id" />
<many-to-many class="model.Student"
column="stu_id" />
</set>
</class>
</hibernate-mapping>
数据库schema：
drop database if exists schoolproject;
create database schoolproject;
use schoolproject;
--
-- Table structure for table `course`
--
DROP TABLE IF EXISTS `course`;
CREATE TABLE `course` (
`id` varchar(32) NOT NULL default '',
`name` varchar(45) default NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
--
-- Dumping data for table `course`
--
/*!40000 ALTER TABLE `course` DISABLE KEYS */;
LOCK TABLES `course` WRITE;
INSERT INTO `course` VALUES ('5abfe4c705ca8ee00105ca8ee45d0002','history');
INSERT INTO `course` VALUES ('5abfe4c705ca8f5e0105ca8f62400002','computer');
INSERT INTO `course` VALUES ('5abfe4c705ca8faf0105ca8fb3750002','music');
INSERT INTO `course` VALUES ('5abfe4c705ca901f0105ca9024290002','ecnomic');
INSERT INTO `course` VALUES ('5abfe4c705ca98420105ca98475a0001','politics');
UNLOCK TABLES;
/*!40000 ALTER TABLE `course` ENABLE KEYS */;
--
-- Table structure for table `student`
--
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
`id` varchar(100) NOT NULL default '',
`name` varchar(20) default '',
`cardId` varchar(20) NOT NULL default '',
`age` int(11) default '0',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
--
-- Dumping data for table `student`
--
/*!40000 ALTER TABLE `student` DISABLE KEYS */;
LOCK TABLES `student` WRITE;
INSERT INTO `student` VALUES ('5abfe4c705ca8ee00105ca8ee42b0001','tomclus','1',25);
INSERT INTO `student` VALUES('5abfe4c705ca8f5e0105ca8f620d0001','tom','2',25);
INSERT INTO `student` VALUES('5abfe4c705ca8faf0105ca8fb3390001','spark','3',25);
INSERT INTO `student` VALUES('5abfe4c705ca901f0105ca9023f70001','jerry','4',25);
UNLOCK TABLES;
/*!40000 ALTER TABLE `student` ENABLE KEYS */;
--
-- Table structure for table `student_course`
--
DROP TABLE IF EXISTS `student_course`;
CREATE TABLE `student_course` (
`stu_id` varchar(32) NOT NULL default '',
`course_id` varchar(32) NOT NULL default '',
PRIMARY KEY (`stu_id`,`course_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
--
-- Dumping data for table `student_course`
--
/*!40000 ALTER TABLE `student_course` DISABLE KEYS */;
LOCK TABLES `student_course` WRITE;
INSERT INTO `student_course` VALUES ('5abfe4c705ca8ee00105ca8ee42b0001','5abfe4c705ca8ee00105ca8ee45d0002');
INSERT INTO `student_course` VALUES ('5abfe4c705ca8ee00105ca8ee42b0001','5abfe4c705ca8f5e0105ca8f62400002');
INSERT INTO `student_course` VALUES ('5abfe4c705ca8ee00105ca8ee42b0001','5abfe4c705ca8faf0105ca8fb3750002');
INSERT INTO `student_course` VALUES ('5abfe4c705ca8f5e0105ca8f620d0001','5abfe4c705ca8f5e0105ca8f62400002');
INSERT INTO `student_course` VALUES ('5abfe4c705ca8f5e0105ca8f620d0001','5abfe4c705ca901f0105ca9024290002');
INSERT INTO `student_course` VALUES ('5abfe4c705ca8faf0105ca8fb3390001','5abfe4c705ca8f5e0105ca8f62400002');
INSERT INTO `student_course` VALUES ('5abfe4c705ca8faf0105ca8fb3390001','5abfe4c705ca8faf0105ca8fb3750002');
UNLOCK TABLES;
相关类BM.java、StudentDAO.java、BaseDAO、HibernateUtil.java：
package BusinessManager;
import org.hibernate.HibernateException;
import persistence.StudentDAO;
public class BM
{
public static void main(String[] args) throws HibernateException
{
StudentDAO.mdfChoice();
}
}
/*
* 创建日期 2005-7-2
*
* TODO 要更改此生成的文件的模板，请转至
* 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/
package persistence;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import model.Course;
import model.Student;
import org.hibernate.FlushMode;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.ScrollableResults;
import org.hibernate.Session;
import org.hibernate.Transaction;
/**
* @author Administrator
*
* TODO 要更改此生成的类型注释的模板，请转至 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/
public class StudentDAO extends BaseDAO
{
static Session session = null;
static Transaction tx = null;
public static void mdfChoice()
{
Set set = new HashSet();
Student stu = null;
Course course = null;
try
{
session = HibernateUtil.currentSession(); // 开启连接
tx = session.beginTransaction(); // 开启事务
stu = (Student) session.createQuery(
"from Student s where s.name ='tomclus'").uniqueResult();
course = (Course) session.createQuery(
"from Course c where c.name='ecnomic'").uniqueResult();
stu.getCourses().add(course);
course.getStudents().add(stu);
tx.commit();
}
catch (HibernateException e)
{ // 捕捉例外
e.printStackTrace();
tx.rollback();
}
finally
{
HibernateUtil.closeSession(session);
}
}
}
/*
* 创建日期 2005-7-2
*
* TODO 要更改此生成的文件的模板，请转至
* 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/
package persistence;
import model.Student;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
/**
* @author Administrator
*
* TODO 要更改此生成的类型注释的模板，请转至 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/
public class BaseDAO
{
static Session session = null;
static Transaction tx = null;
/*------------创建新对象-----------------*/
public static void createObj(Object o)
{
try
{
session = HibernateUtil.currentSession(); // 开启连接
tx = session.beginTransaction(); // 开启事务
session.save(o);
tx.commit();
}
catch (HibernateException e)
{ // 捕捉例外
e.printStackTrace();
tx.rollback();
}
finally
{
if (session != null)
HibernateUtil.closeSession(session);
}
}
/*------------删除对象-----------------*/
public static void delObject(Object o)
{
try
{
session = HibernateUtil.currentSession(); // 开启连接
tx = session.beginTransaction(); // 开启事务
session.delete(o);
tx.commit();
}
catch (HibernateException e)
{ // 捕捉例外
e.printStackTrace();
tx.rollback();
}
finally
{
HibernateUtil.closeSession(session);
}
}
/*------------修改对象-----------------*/
public static void mdfObj(Object o)
{
try
{
session = HibernateUtil.currentSession(); // 开启连接
tx = session.beginTransaction(); // 开启事务
session.update(o);
tx.commit();
}
catch (HibernateException e)
{ // 捕捉例外
e.printStackTrace();
tx.rollback();
}
finally
{
HibernateUtil.closeSession(session);
}
}
}
package persistence;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtil
{
private static final SessionFactory sessionFactory;
static
{
try
{
sessionFactory = new Configuration().configure()
.buildSessionFactory();
}
catch (HibernateException ex)
{
throw new RuntimeException("Exception building SessionFactory: "
+ ex.getMessage(), ex);
}
}
public static Session currentSession()
{
Session s = sessionFactory.openSession();
return s;
}
public static void closeSession(Session s)
{
s.close();
}
}
执行BM.java类，学生表和课程表没有任何变化，唯一变化的是中间表多了一行记录，用于映射新建立的学生和课程之间的关系。
补充知识点：域对象在持久化层的三种状态
