hibernate cascade和inverse的用法

设置 inverse=”false” cascade=”save-update” ,删除父表记录时,子表对应外键置空。

设置 inverse=”false” cascade=”all”,删除父表记录时,子表级联删除。

1. Hibernate 级联关系说明 - 关于cascade和inverse的用法 http://www.diybl.com/course/3_program/java/javashl/2008326/107345.html

在hibernate中一对多关联时会经常用到inverse和cascade属性 ,

inverse 有两个值 true ,false  ;如果设置为true 则表示当前对象不负责讲级联对象的状态变化同步到数据库 ;设置false则相反,其默认值为false;

cascade 有五个选项 分别是: all ,delete ,none,save-update,delete-orphan ;
all : 所有情况下均进行关联操作。
none:所有情况下均不进行关联操作。这是默认值。
save-update:在执行save/update/saveOrUpdate时进行关联操作。
delete:在执行delete时进行关联操作。
delete-orphan: 当save/update/saveOrUpdate时,相当于save-update ;当删除操作时,相当于delete ;

all的意思是save-update + delete
all-delete-orphan 的意思是当对象图中产生孤儿节点时,在数据库中删除该节点
all比较好理解,举个例子说一下all-delete-orphan:
Category与Item是一对多的关系,也就是说Category类中有个Set类型的变量items.
举个例子,现items中存两个Item, item1,item2,如果定义关系为all-delete-orphan
当items中删除掉一个item(比如用remove()方法删除item1),那么被删除的Item类实例
将变成孤儿节点,当执行category.update(),或session.flush()时
hibernate同步缓存和数据库,会把数据库中item1对应的记录删掉

测试Hibernate中的三个属性:lazy,inverse,cascade

【测试环境】
一对多关系的两张表:boy、girl(一个男孩可以多个女朋友)

boy表结构
Field   Type
——  ———–
name    varchar(50)  pk
age     varchar(50)

girl表结构
Field   Type
——  ———–
name    varchar(50)  pk
bf      varchar(50)  fk 

【保存时:Inverse与cascade】

创建三个girl对象和一个boy对象,让这是三个girl都是boy的女朋友

———创建对象的代码片段———–
Boy boy = new Boy(“tom”,”23″, null);

Set girls = new HashSet();

Girl g[] = new Girl[]{
new Girl(“Alice1″, boy),
new Girl(“Alice2″, boy),
new Girl(“Alice3″, boy)};
girls.add(g[0]);
girls.add(g[1]);
girls.add(g[2]);

boy.setGirls(girls);

在Boy.hbm.xml中设置,然后对boy对象进行保存。

1.Inverse = true,不指定cascade
cascade的默认值为none, 当对boy进行保存操作时,girl什么都不做. 所以只保存了boy对象, 没有保存girl对象

2.Inverse = true,cascade=all
boy与girl对象,包扩外键都成功保存。
(生成3条SELECT语句和4条INSERT语句,一下简称SELECT 3, INSERT 4)

3.Inverse = false,不指定cascade
报错。因为boy为主控方,负责维护关系,所以在插入boy对象后,会尝试修改并不存在的girl对象。

4.Inverse = false,cascade=all
boy与girl对象,包扩外键都成功保存。
(SELECT 4, INSERT 4, UPDATE 3)

分析:除了4条INSERT语句之外,其他的6条语句是我们为了图方便付出的代价:3条SELECT语句用来判断girl对象是否在数据表中已经存在,3条UPDATE语句是为了维护外键关系

高效率的做法:在Boy.hbm.xml中设置Inverse=true,在Girl.hbm.xml中设置Inverse=false, cascade=all,然后保存三个girl对象
(SELECT 1, INSERT 4)

高效率的代价就是保存的时候比较麻烦

【删除时:Inverse与cascade】

希望通过删除boy,也将3个girl对象删除。程序中先查出boy对象,然后进行删除
—————————————–
Boy boy = (Boy) s.get(Boy.class, “tom”);
s.delete(boy);
—————————————–
同样在Boy.hbm.xml中进行设置

1.Inverse = true
可以猜到结果是出错。原因:外键约束错误

2.Inverse = false
boy删除,girl表中外键变为null,没有删除记录 ;
(UPDATE 1, DELETE 1)

3.Inverse = false, cascade = all
全部删除  ;在删除有外键的从表时,先把从表外键置为null,然后删除主表记录,最后根据从表主键删除所有相关从表记录

(UPDATE 1, DELETE 4)

4.Inverse = true, cascade = all
全部删除
(DELETE 4)

Inverse是hibernate双向关系中的基本概念,当然对于多数实体,我们并 不需要双向关联,更多的可能会选择单向关联,况且我们大多数人一般采用一对多关系,而一对多双向关联的另一端:多对一的inverse属性是不存在,其实 它默认就是inverse=false.从而防止了在一对多端胡乱设置inverse也不至于出错。但是inverse设置不当确实会带来很大的性能影 响,这点是我们必须关注的。

这篇文章已经详细分析了inverse设置不当带来的影响:

http://www.hibernate.org/155.html

看了这篇文章,还是很有必要再写下一些总结的:

1)inverse中提及的side其实是指一个类或者表的概念,双向关联其实是指双方都可以取得对方的应用。

2)维护关系这个名词还是稍显模糊或者晦涩。我们一般说A类或者A表(这里的表的是指多对多的连接表)有责任维护关系,其实这里的意思是说,我在应 用在更新,创建,删除(读就不用说了,双向引用正是为了方便读而出现)A类或者A表时,此时创建的SQL语句必须有责任保证关系的正确修改。

3)inverse=false的side(side其实是指inverse=false所位于的class元素)端有责任维护关系,而inverse=true端无须维护这些关系。

4)我们说inverse设立不当会导致性能低下,其实是说inverse设立不当,会产生多余重复的SQL语句甚至致使JDBC exception的throw。这是我们在建立实体类关系时必须需要关注的地方。一般来说,inverse=true是推荐使用,双向关联中双方都设置 inverse=false的话,必会导致双方都重复更新同一个关系。但是如果双方都设立inverse=true的话,双方都不维护关系的更新,这也是 不行的,好在一对多中的一端:many-to-one默认是inverse=false,避免了这种错误的产生。但是对多对就没有这个默认设置了,所以很 多人经常在多对多的两端都使用inverse=true,结果导致连接表的数据根本没有记录,就是因为他们双分都没有责任维护关系。所以说,双向关联中最 好的设置是一端为inverse=true,一端为inverse=false。一般inverse=false会放在多的一端,那么有人提问了, many-to-many两边都是多的,inverse到底放在哪儿?其实hibernate建立多对多关系也是将他们分离成两个一对多关系,中间连接一个连接表。所以通用存在一对多的关系,也可以这样说:一对多是多对多的基本组成部分。

看下面的多对多的定义大家更会清楚”多对多“与“一对多”的关系:其中我们注意<many-to-many />标签的特点就知道,它是定义了一个多对多关系,而不是<one-to-many/>。

<?xml version=”1.0″?>
<!DOCTYPE hibernate-mapping PUBLIC
“-//Hibernate/Hibernate Mapping DTD 2.0//EN”
http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd“>
<hibernate-mapping  package=”org.hibernate.auction”>
<class name=”TestA” table=”TestA”
dynamic-update=”true” dynamic-insert=”true” >

<id name=”id” column=”id” type=”int” unsaved-value=”any” >
<generator>
</generator>
</id>

<property name=”name” type=”java.lang.String”
update=”true” insert=”true” column=”name” />

<set name=”testBs” table=”TestA_TestB” inverse=”false” cascade=”all”>
<key column=”testA”/>
<many-to-many column=”testB” />
</set>
</class>
<class name=”TestB” table=”TestB”
dynamic-update=”true” dynamic-insert=”true” >

<id name=”id” column=”id” type=”int” unsaved-value=”any” >
<generator>
</generator>
</id>

<property name=”name” type=”java.lang.String” update=”true”
insert=”true” column=”name” />

<set name=”testAs” table=”TestA_TestB” inverse=”true” cascade=”all”>
<key column=”testB”/>
<many-to-many column=”testA” />
</set>
</class>
</hibernate-mapping>

在对多对中,因为一端维护关系另一端不维护关系的原因,我们必须注意避免在应用中用不维护关系的类建立关系,因为这样建立的关系是不会在数据库中存储的。基于上面的映射文件代码给出一个例子:

package org.hibernate.auction;
import java.util.*;

/**
* @author Administrator
*
* To change the template for this generated type comment go to
* Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
*/
public class TestA {
int id;
String name;
Set testBs=new HashSet();
public TestA(){

}
public TestA(int id){
setId(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;
}
public Set getTestBs(){
return testBs;
}
public void setTestBs(Set s){
testBs=s;
}
public void addTestB(TestB tb){
testBs.add(tb);
}

public static void main(String[] args) {
}
}

public class TestB {
int id;
String name;
Set testAs=new HashSet();
public TestB(){

}
public TestB(int id){
setId(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;
}
public Set getTestAs(){
return testAs;
}
public void setTestAs(Set s){
testAs=s;
}
public void addTestA(TestA ta){
testAs.add(ta);
}
public static void main(String[] args) {
}
}

测试代码:

public void doTest() throws Exception{
TestA a1=new TestA(1);
TestA a2=new TestA(2);
TestA a3=new TestA(3);
TestB b1=new TestB(1);
TestB b2=new TestB(2);
TestB b3=new TestB(3);
a1.addTestB(b1);
a1.addTestB(b2);
a1.addTestB(b3);
b2.addTestA(a1);
b2.addTestA(a2);

Session s = factory.openSession();

s = factory.openSession();

Session session = factory.openSession();
session.save(a1);
session.flush();
session.close();

}

测试后连接表的数据为:

testa              testb

1                  1

1                  2

1                  3

根据inverse规则,对这些代码:b2.addTestA(a1);  b2.addTestA(a2); 建立的关系,数据库并没有存储下来,因为TestB没有责任维护这些关系,所以产生的sql语句自然不会有针对Testa_testB表的操作了。假设应 用中真的需要这些方法,那么我们可以修改TestB的方法,让他们注意在维护端类中执行相应的操作以使得关系能够在数据库中保存下来,更改TestB如 下:

/*
* Created on 2004-7-25
*
* To change the template for this generated file go to
* Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
*/
package org.hibernate.auction;
import java.util.*;

/**
* @author Administrator
*
* To change the template for this generated type comment go to
* Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
*/
public class TestB {
int id;
String name;
Set testAs=new HashSet();
public TestB(){

}
public TestB(int id){
setId(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;
}
public Set getTestAs(){
return testAs;
}
public void setTestAs(Set s){
testAs=s;
}
public void addTestA(TestA ta){
testAs.add(ta);
ta.addTestB(this);
}
public static void main(String[] args) {
}
}
那么测试执行后连接表的数据为:

testa          testb

1               2

1               3

1                1

2                 2

测试通过。

附 hibernate cascade备忘 :
当关联双方存在父子关系,就可以在 set 处设定 cascade 为 all-delete-orphan

所谓父子关系,即指由父方控制子方的持久化圣明周期,子方对象必须和一个父方对象关联。如果删除父方对象,应该级联删除所有关联的子方对象;如果一个子方对象不再和一个父方对象关联,应该把这个子方对象删除。

all-deleteorphan 的能力:

1. 当保存或更新父方对象时,级联保存或更新所有关联的子方对象,相当于 cascade 为 save-update

2. 当删除父方对象时,级联删除所有关联的子方对象,相当于 cascade 为 delete

3. 删除不再和父方对象关联的所有子方对象

解除父子关系的 java 语句例如:

customer.getOrders().remove(order);
order.setCustomer(null);

tx.commit();

如果 cascade 属性取默认值 null,当解除父子关系时,会执行如下 sql:

update ORDER set CUSTOMER_ID=null where ID=2

inverse 设定的原则:

1. 在映射一对多双向关联关系时,应该设定 many 方的 inverse 为 true,以提高性能

2. 在建立两个对象的双向关联时,应同时修改关联两端的对象的相应属性:

1)customer.getOrders().add(order);
2)order.setCustomer(customer);

如果不执行 1)而仅执行 2),由于 set 元素的 inverse 为 true,因此 hibernate 不会按照 CUSTOMER 对象的状态变化来同步数据库。

inverse 解决性能问题的例子:

1. 建立 Order 到 Customer 的多对一关联关系

order.setCustomer(customer);

相应执行的 SQL 为:

update ORDERS set ORDER_NUMBER=”Jack_Order001”, CUSTOMER_ID=2 where ID=2;

2. 建立 Customer 到 Order 的一对多关系

customer ORDERS set CUSTOMER_ID=2 where ID=2;

相应 SQL 为:

update ORDERS set CUSTOMER_ID=2 where ID=2;

显然 1 和 2 的 SQL 功能重复了,反复执行这样的 SQL 语句会引起性能下降,因此:

inverse 设定为 true 时,声明 Customer 端的关联只是 Order 端关联的镜像。当两者状态发生变化时,Hibernate 仅按照 Order 对象状态变化来同步数据库。即仅会执行以下 SQL:

update ORDERS set ORDER_NUMBER=”Jack_Order001”, CUSTOME_ID=2 where ID=2;

Customer.hbm.xml 片段如下:

<set
name=”orders”
cascade=”all-delete-orphan”
inverse=”true”
>
<key column=”CUSTOMER_ID” />
<one-to-many />
</set>

引用:http://huhu0817.javaeye.com/blog/97831

2. (Hibernate)cascade http://blog.csdn.net/daniel_tu/article/details/3932078

利用关联关系操作对象:
数据对象之间的关联关系有一对一,一对多及多对多三种。在数据库操作中,数据对象之间的关联关系使用JDBC处理很困难。例如,当删除一个班级的信息时,还要删除该班级的所有学生的基本信息。如果直接使用JDBC执行这种级联操作,会非常繁锁。Hibernate通过把实体对象之间的关联关系及级联关系在映射文件中声明,比较简单地解决了这类级联操作问题。
一对一关联关系的使用:
一对一关联关系在实际生活中是比较觉的,例如学生与学生证的关系,通过学生证可以找到学生。一对一关联关系在Hibernate中的实现有两种方式,分别是主键关联和外键关联。
主键关联:
主键关联的重点是,关联两个实体共享一个主键值。例如student与card是一对一关系,它们在数据库中对应的表分别是t_student和 t_card。它们共用一个主键值ID,这个主键可由t_student或t_card表生成。问题是如何让另一张表引用已经生成的主键值呢?例如,t_student表未老先衰了ID的值,t_card表如何引用它?这需要在Hibernate的映射文件中使用主键的foreign生成机制!

为了表示Student与Card之间的一对一的关联关系,我们需要在它们各自的映射文件 中都要使用<one-to-one>标记!
一对一关系我在前面已经写过例子程序了,在这里仅给出两个映射文件。如下:
学生PO映射信息: 

<?xml version=”1.0″ encoding=”GBK”?>
<!DOCTYPE hibernate-mapping PUBLIC ”-//Hibernate/Hibernate Mapping DTD 3.0//EN”
“http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd”>

<hibernate-mapping>
    <class name=”hibernate.PO.TStudent” table=”t_student” lazy=”true”><!–把类与表关联起来 –>
        <id name=”id” type=”java.lang.Integer”>
            <column name=”id”/>
            <generator class=”increment” />
        </id>
        <property name=”userName” type=”java.lang.String”>
            <column name=”userName” length=”20″ />
        </property>
        <property name=”cardId” type=”java.lang.String”>
            <column name=”card_id” length=”20″ />
        </property>
        <property name=”sex” type=”java.lang.String”>
            <column name=”sex” length=”2″ />
        </property>
        <property name=”age” type=”java.lang.Integer”>
            <column name=”age” />
        </property>
        <one-to-one name=”card” class=”hibernate.PO.TCard” fetch=”join” cascade=”all” />
    </class>
</hibernate-mapping>
<!–
class元素的lazy属性设定为true,表示延迟加载,如果lazy设为false,则
表示立即加载。以下对这二点进行说明。
    立即加载:表示Hibernate在从数据库中取得数据组装好一个对象(如学生1)后,
            会立即再从数据库取得数据组装此对象所关联的对象(如学生证1)。
    延迟加载:表示Hibernate在从数据库中取得数据组装好一个对象(如学生1)后,
            不会立即再从数据库中取得数据组装此对象所关联的对象(如学生1),
            而是等到需要时,才会从数据库取得数据组装此关联对象。
<one-to-one>元素的cascade属性表明操作是否从父对象级联到被关联的对象,    它
的取得可以是以下几种:
    none:在保存,删除或修改当前对象时,不对其附属对象(关联对象)进行级联
          操作。它是默认值。
    save-update:在保存,更新当前对象时,级联保存,更新附属对象(临时对象,
          游离对象)。
    delete:在删除当前对象时,级联删除附属对象。
    all:所有情况下均进行级联操作,即包含save-update和delete操作。
    delete-orphan:删除和当前对象解除关系的附属对象。
<one-to-one>元素的fetch属性的可选值是join和select,默认是select。
当fetch属性设定为join时,表示连接抓取(Join fetching):Hibernate通过
在Select语句中使用outer join(外连接)来获得对象的关联实例或者关联集合。
当fetch属性设定为select时,表示查询抓取(Select fetching):需要另外发
送一条Select语句抓取当前对象的关联实体或集合。–>

学生证PO映射信息:

<?xml version=”1.0″ encoding=”GBK”?>
<!DOCTYPE hibernate-mapping PUBLIC ”-//Hibernate/Hibernate Mapping DTD 3.0//EN”
“http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd”>

<hibernate-mapping>
    <class name=”hibernate.PO.TCard” table=”t_card” lazy=”true”>
        <id name=”id” type=”java.lang.Integer”>
            <column name=”id”/>
            <generator class=”foreign”>
                <param name=”property”>student</param>
            </generator>
        </id>
        <!– id使用外键(foreign)生成机制,引用代号为student的对象
             的主键作为T_card表的主键和外键。同时student在下面的
             <one-to-one>中进行了定义 –>
        <property name=”name” type=”java.lang.String”>
            <column name=”name” length=”20″ />
        </property>


          <one-to-one name=”student” class=”hibernate.PO.TStudent” constrained=”true” />
          <!– constrained=”true”表示Card引用了student的主键作为外键。 –>
    </class>
</hibernate-mapping>

外键关联:
外键关联的要点是:两个实体各自有不同的主键,但其中一个实体有一个外键引用另一个实体的主键。例如,假设,Student和Card是外键关联的一对一关系们在数据库中相应的表分别如下:t_student表有一个主键ID,t_card表有一个主键ID和一个外键student_id,此外键对应 t_student表的主键ID,那么student的映射信息如上面一样不做改动,而Card的映射文件要做相应的改动。如下:

<hibernate-mapping>
    <class name=”hibernate.PO.TCard” table=”t_card” lazy=”true”>
        <id name=”id” type=”java.lang.Integer”>
            <column name=”id”/>
            <generator class=”increment”/><!– 不再是foreign了 –>
        </id>

        <property name=”name” type=”java.lang.String”>
            <column name=”name” length=”20″ />
        </property>

       <many-to-one name=”student” column=”student_id” class=”hibernate.PO.TStudent” unique=”true”/>
       <!– 惟一的多对一,实际上变成一对一关系了 –>
         <!– unique设为true表示使用DDL为外键字段生成一个惟一约束。
                 以外键关联对象的一对一关系,其本质上已经变成了一对多的双向关联,
                 应直接按照一对多和多对一的要求编写它们的映射文件。当unique为
                 true时实际上变成了一对一的关系。 –>

    </class>
</hibernate-mapping>

一对多关联关系的使用
一对多关系很觉,例如班级与学生的关系就是典型的一对多的关系。在实际编写程序时,一对多关系有两种实现方式:单向关联和双向关联。单向的一对多关系只需要在一方进行映射配置,而双向的一对多需要在关联的双方进行映射配置。下面以Group(班级)和Student(学生)为例讲解如何配置一对多的关系。
单向关联:
单向的一对多关系只需要在一方进行映射配置,所以我们只配置Group的映射文件:

<hibernate-mapping>
    <class name=”hibernate.PO.Group” table=”t_group” lazy=”true”>
        <id name=”id” type=”java.lang.Integer”>
            <column name=”id”/>
            <generator class=”increment”/>
        </id>
        <!– insert属性表示被映射的字段是否出现在SQL的INSERT语句中 –>
        <property name=”name” type=”java.lang.String” update=”true” insert=”true”>
            <column name=”name” length=”20″ />
        </property>

        <!– set元素描述的字段对应的类型为java.util.Set类型。
            inverse用于表示双向关联中的被动一端。inverse的值
            为false的一方负责维护关联关系。
            sort排序关系,其可选值为:unsorted(不排序)。
                                  natural(自然排序)。
                                  comparatorClass(由某个实现了java.util.comparator接口的类型指定排序算法。)
            <key>子元素的column属性指定关联表(t_student表)的外键。
       –>
        <set name=”students”
             table=”t_student”
             lazy=”true”
             inverse=”false”
             cascade=”all”
             sort=”unsorted”>
        <key column=”ID”/>
        <one-to-many class=”hibernate.PO.TStudent”/>
        </set>
    </class>
</hibernate-mapping>

双向关联:
如果要设置一对多双向关联关系,那么还需要在“多”方的映射文件中使用<many-to-one>标记。例如,在Group与Student一对多的双向关联中,除了Group的映射文件外还需要在Student的映射文件中加入如下代码:

 <many-to-one name=”group”
                     class=”Group”
                     cascade=”none”
                     outer-join=”auto”
                     update=”true”
                     insert=”true”
                     column=”ID” />

inert和update设定是否对column属性指定的关联字段进行insert和update操作。
此外将Group.hbm.xml中<set>元素的inverse设置为true.多对多关联关系的使用
Student(学生)和Course(课程)的关系就是多对多关系。在映射多对多关系时需要另外使用一个连接表(如Student_Course)。 Student_Course表包含二个字段:courseID和studentID。此处它们的映射文件中使用<many-to- many>标记,在Student的映射文件中加入以下描述信息:

  <set name=”courses”
               table=”student_course”
               lazy=”false”
               inverse=”false”
               cascade=”save-update”>
               <key column=”studentID” />
           <many-to-many class=”Course” column=”CourseID”/>
           </set>

相应的Course的映射文件中加入以下:

 <set name=”students”
               table=”student_course”
               lazy=”false”
               inverse=”true”
               cascade=”save-update”>
               <key column=”CourseID” />
           <many-to-many class=”Student” column=”StudentID”/>
           </set>

添加关联关系:
首先编写一个程序来看看一个名为Bill的学生选择了什么课程:

//获取代表Bill的Student对象
        Student stu = (Student)session.createQuery(“from Student s where s.name=’Bill’”).uniqueResult();
        List list = new ArrayList(stu.getCourses());
        for(int i = 0 ; i < list.size(); i++)
        {
            Course course = (Course)list.get(i);//取得Course对象
            System.out.println(course.getName());//打印出Bill所选课程的清单
        }

现在Bill还想chemistry课程,这对于程序员来说只是为Bill添加一个到chemistry的关联,也就是说在student_course表中新增加一条记录,而T_student和T_Course表都不用变更。

//获取代表Bill的Student对象
        Student stu = (Student)session.createQuery(“from Student s where s.name=’Bill’”).uniqueResult();
        Course course = (Course)session.createQuery(“from Course c where c.name=’chemistry’”).uniqueResult();
        //设置stu与course的关联关系
        stu.getCourses().add(course);
        course.getStudents().add(stu);

删除关联关系:
删除关联关系比较简单,直接调用对象集合的remove()方法删除不要的对象就可。例如:要从学生Bill的选课清单中删除politics和chemistry两门课,程序代码如下:

        //获取代表Bill的Student对象
        Student stu = (Student)session.createQuery(“from Student s where s.name=’Bill’”).uniqueResult();
        Course course1 = (Course)session.createQuery(“from Course c where c.name=’politics’”).uniqueResult();
        Course course2 = (Course)session.createQuery(“from Course c where c.name=’chemistry’”).uniqueResult();
        stu.getCourse().remove(course1);//删除politics课程
        stu.getCourse().remove(course2);//删除chemistry课程

运行以上程序将从student_course表中删除这两条记录,但T_student和T_course表没有任何变化

This entry was posted in Computer, Java. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s