hibernate 单向关联一对多级连删除无效

Hello World 007 2015-07-27 01:49:00

hibernate 单向关联一对多级连删除无效只是把对应的外键置为null

客户表中对应的推荐信息


<set name="recommends" lazy="true" cascade="delete">
<key column="cliendId"></key>
<one-to-many class="com.lwp.domain.Recommend" />
</set>

...全文

99 1 打赏收藏转发到动态举报

写回复

1 条回复

切换为时间正序

请发表友善的回复…

发表回复

多木多多木 2015-07-27

打赏
举报

回复

楼主，你把延迟加载去掉试试，就是去掉这部分代码，lazy="true"

Hibernate Annotation几种关联映射一对一(One-To-One) 使用@OneToOne注解建立实体Bean之间的一对一关联。一对一关联有三种情况：(1).关联的实体都共享同样的主键，(2).其中一个实体通过外键关联到另一个实体的主键(注意要模拟一对一关联必须在外键列上添加唯一约束)，(3).通过关联表来保存两个实体之间的连接关系(要模拟一对一关联必须在每一个外键上添加唯一约束)。 1.共享主键的一对一关联映射： @Entity @Table(name="Test_Body") public class Body { private Integer id; private Heart heart; @Id public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } @OneToOne @PrimaryKeyJoinColumn public Heart getHeart() { return heart; } public void setHeart(Heart heart) { this.heart = heart; } } @Entity @Table(name="Test_Heart") public class Heart { private Integer id; @Id public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } } 通过@PrimaryKeyJoinColumn批注定义了一对一关联 2.使用外键进行实体一对一关联： @Entity @Table(name="Test_Trousers") public class Trousers { @Id public Integer id; @OneToOne @JoinColumn(name = "zip_id") public TrousersZip zip; } @Entity @Table(name="Test_TrousersZip") public class TrousersZip { @Id public Integer id; @OneToOne(mappedBy = "zip") public Trousers trousers; } 上面的例子是指Trousers通过Trousers的外键列zip_id和TrousersZip关联，@JoinColumn批注定义了联接列，该批注和@Column批注有点类似，但是多了一个名为referencedColumnName的参数。该参数定义了所关联目标实体中的联接列，注意，当referencedColumnName关联到非主键列的时候，关联的目标类必须实现Serializable，还要注意的是所映像的属性对应单个列（否则映射无效）一对一关联可能是双向的，在双向关联中，有且仅有一端作为主体（owner）端存在：主体端负责维护联接列（即更新），对于不需要维护这种关系的从表则通过mappedNy属性进行声明。mappedBy的值指向主体的关联属性。例子中，mappedBy的值为zip。最后，不必也不能再在被关联端（ownedside）定义联接列了，因为已经在主体端声明了。如果在主体没有声明@JoinColumn，系统自动进行处理：在主表（owner table）中将创建联接列，列名为：主体的关联属性名+下划线+被关联端的主键列名。上面的例子中是zip_id,因为Trousers中的关联属性名为zip，TrousersZip的主键是id。 3.通过关联表定义一对一关联 @Entity @Table(name="Test_People") public class People { @Id public Integer id; @OneToOne @JoinTable(name ="TestPeoplePassports", joinColumns =@JoinColumn(name="people_fk"), inverseJoinColumns =@JoinColumn(name="passport_fk") ) public Passport passport; } @Entity @Table(name="Test_Passport") public class Passport { @Id public Integer id; @OneToOne(mappedBy = "passport") public People people; } People通过名为TestPeoplePassports的关联表和Passport关联。该关联表拥有名为passport_fk的外键列，该外键指向Passport表，该信息定义为inverseJoinColoumns的属性值，而people_fk外键列指向People表，该信息定义为joinColumns的属性值。这种关联可能是双向的，在双向关联中，有且仅有一端作为主体（owner）端存在：主体端负责维护联接列（即更新），对于不需要维护这种关系的从表则通过mappedNy属性进行声明。mappedBy的值指向主体的关联属性。例子中，mappedBy的值为passport。最后，不必也不能再在被关联端（ownedside）定义联接列了，因为已经在主体端声明了。以上是一对一关联的三种形式，下面介绍多对一关联。多对一(Many-to-One) 使用@ManyToOne批注来实现多对一关联。 @ManyToOne批注有一个名为targetEntity的参数，该参数定义了目标实体名，通常不需要定义该参数，因为在大部分情况下默认值(表示关联关系的属性类型)就可以很好的满足需求了。不过下面这种情况下这个参数就显得有意义了：使用接口作为返回值而不是常见的实体。 @ManyToOne(targetEntity=CompanyImpl.class) @JoinColoumn(name=”COPM_ID”) Public Company getCompany(){ return company; } 多对一的配置方式有两种：(1)通过@JoinColoumn映像(2)通过关联表的方式来映像 (1) 通过@JoinColoumn映射 SRD Framework中Company,Category例子： Company： @ManyToOne @JoinColumn(name = "CATEGORY_OPTION_ID") private Category category = null; Category： @DiscriminatorValue("Category") public class Category extends Option { } (2) 通过关联表映射通过@JoinTable批注定义关联表，该关联表包含了指回实体表的外键(通过@JoinTable.joinColoumns)以及指向目标实体表的外键(通过@JoinTable.inverseJoinColoumns) @Entity @Table(name="Test_TreeType") public class TreeType { private Integer id; private String name; private ForestType forestType; @ManyToOne(fetch = FetchType.LAZY) @JoinTable(name="Test_Tree_Forest", joinColumns = @JoinColumn(name="tree_id"), inverseJoinColumns = @JoinColumn(name="forest_id") ) public ForestType getForestType() {// forestType的getter，setter方法必须在这里，否则会出错 return forestType; } public void setForestType(ForestType forestType) { this.forestType = forestType; } @Id @GeneratedValue public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } @Entity @Table(name="Test_ForestType") public class ForestType { private Integer id; private String name; private Set trees; @OneToMany(mappedBy="forestType") public Set getTrees() {// trees的getter，setter方法必须在这里，否则会出错 return trees; } public void setTrees(Set trees) { this.trees = trees; } @Id @GeneratedValue public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } 一对多(One-to-Many) 使用@OneToMany批注可定义一对多关联，一对多关联可以是双向关联。在EJB3规范中多对一这端几乎总是双向关联中的主体(owner)端，而一对多这端关联批注为@OneToMany(mappedBy...) @Entity Public class Troop{ @OneToMany(mappedBy=”troop”) Public Set getSoldiers(){ ...... } @Entity Public class Soldier{ @ManyToOne @JoinColumn(name=”troop_fk”) Public Troop getTroop(){ ...... } Troop通过troop属性和Soldier建立一对多的双向关联，在mappedBy端不必也不能再定义任何物理映射。对于一对多的双向映射，如果要一对多这一端维护关联关系，你需要删除mappedBy元素并将多对一这端的@JoinColoumn的insertable和updatabel设置为false。这种方案不会得到什么明显的优化，而且还会增加一些附加的UPDATE语句。单向：通过在被拥有的实体端(owned entity)增加一个外键列来实现一对多单向关联是很少见的，也是不推荐的，建议通过一个联接表来实现这种关联(下面会讲到)。 @JoinColoumn批注来描述这种单向关联关系 @Entity Public class Customer{ @OneToMany @JoinColoumn(name=”CUST_ID”) Public Set getTickets() { ...... } @Entity Public class Ticket{ ... } Customer通过CUST_ID列和Ticket建立了单向关联关系通过关联表处理单向关联：通过联接表处理单向一对多关联是首选方式，这种关联通过@JoinTable批注进行描述 @Entity Public class Trainer{ @OneToMany @JoinTable( name = "TrainedMonkeys", jonColumns = {@JoinColumn(name = "trainer_id")}, inverseJoinColumns = @JoinColumn(name = "monkey_id") ) public Set getTrainedMonkeys() { return trainedMonkeys; } ...... } @Entity public class Monkey { ...//no bidir } 上面这个例子中，Trainer通过TrainedMonkeys表和Monkey建立了单向关联，其中外键trainer_id关联到Trainer(joinColoumn),而外键monkey_id关联到Monkey(inversejionColoumns) 默认处理机制：通过联接表来建立单向一对多关联不需要描述任何物理映像，表名由以下三个部分组成：主表(ownertable)表名+从表(the other side table)表名，指向主表的外键名：主表表名+下划线+主表主键列名，指向从表的外键名：主表所对应实体的属性名+下划线+从表主键列名，指向从表的外键定义为唯一约束，用来表示一对多的关联关系。 @Entity public class Trainer{ @OneToMany Public Set getTrainedTigers(){ ... ... } @Entity public class Tiger{ .. ..//no bidir } 上面这个例子中，Trainer和Tiger通过联接表Trainer_Tiger建立单向关联关系，其中外键trainer_id关联到Trainer,而外键trainedTigers_id关联到Tiger 多对多(Many-to-Many) 使用@ManyToMany批注可定义多对多关联，同时，你也许要通过批注@JoinTable描述关联表和关联条件。如果是双向关联，其中一段必须定义为Owner，另一端必须定义为inverse(在对关联表进行更新操作时这一端将被忽略) @Entity() public class Employer implements Serializable { private Integer id; private Collection employees; @ManyToMany( targetEntity = org.hibernate.test.annotations.manytomany.Employee.class, cascade = {CascadeType.PERSIST, CascadeType.MERGE} ) @JoinTable( name = "EMPLOYER_EMPLOYEE", joinColumns = {@JoinColumn(name = "EMPER_ID")}, inverseJoinColumns = {@JoinColumn(name = "EMPEE_ID")} ) public Collection getEmployees() { return employees; } ... } @Entity() public class Employee implements Serializable { @ManyToMany( cascade = {CascadeType.PERSIST, CascadeType.MERGE}, mappedBy = "employees" targetEntity = Employer.class ) public Collection getEmployers() { return employers; } .. .. } @JoinTable批注定义了联接表的表名，联接列数组，以及invers联接列数组，后者是关联表中关联到Employee主键的列(the “other side”)。被关联端不必也不能描述物理映射：只需要一个简单的mappedBy参数，该参数包含了主体端的属性名，这样就绑定了双方的关系。默认值：和其它许多批注一样，在多对多关联中很多值是自动生成，党双向多对多关联中没有定义任何物理映射时，Hibernate根据以下规则生成相应的值，关联表名：主表表名+下划线+从表表名，关联到主表的外键名：主表名+下划线+主表中的主键列名，关联到从表的外键名：主表中用于关联的属性名+下划线+从表的主键列名，以上规则对于双向一对多关联同样一样。以上是整理的一点简单的几种映射，可参考EJB3.pdf中P111——P131，hibernate_annotation.pdf 第二章在这里没有具体的例子，有很多内容还需要仔细查看文档。

低清版51M 大型门户网站是这样炼成的！(Struts 2+Spring 2+Hibernate 3).pdf（完整版）网上有高清版350M的。可以去下 http://115.com/file/be5gwid8 请于下载后 24H 内及时删除！请抱着学习的态度下载此资料。总共900多页！！！！！！！第1篇技术篇第1章大型门户网站架构分析 3 1.1 大型门户网站与小型企业网站的区别 3 1.2 高性能、高负载门户网站架构剖析 9 1.2.1 服务器操作系统的选择 10 1.2.2 dns服务器bind 16 1.2.3 cache服务器squid 18 1.2.4 带负载均衡的http服务器apache 19 1.2.5 支持集群功能的web服务器tomcat 21 1.2.6 开源数据库服务器之骄子mysql 23 1.2.7 功能强大的flv流媒体服务器red5 24 1.3 门户网站开发指导思想 26 1.4 ssh 2组合框架—门户网站开发之首选 28 1.4.1 mvc混血宠儿struts 2 28 1.4.2 幕后的财政部长spring 2.5 30 1.4.3 orm中间件香馍馍hibernate 3.2 31 1.5 小结 32 第2章 mvc混血宠儿struts 2 33 2.1 初识mvc新秀struts 2 33 2.1.1 mvc概述 33 .2.1.2 struts 2的mvc实现 35 2.1.3 struts 2的基本组成 36 2.1.4 struts 2的常用类介绍 38 2.1.5 struts 2的业务控制器action实现 39 2.1.6 struts 2的处理结果result 45 2.1.7 功能强大的表达式语言ognl 47 2.1.8 struts 2的运行流程分析—helloworld 48 2.1.9 struts 2的异常处理 52 2.2 struts 2配置精要 54 2.2.1 web.xml中struts 2的配置实现 54 2.2.2 struts 2属性配置文件struts.properties详解 55 2.2.3 struts 2核心配置文件struts.xml详解 57 2.3 struts 2应用开发实务 61 2.3.1 struts 2应用开发环境的搭建 62 2.3.2 struts 2应用基本开发步骤—搭建eportal应用 69 2.3.3 struts 2中集成fckeditor 80 2.3.4 struts 2中集成displaytag 83 2.4 struts 2国际化实现 85 2.4.1 web应用的中文本地化 85 2.4.2 struts 2应用的国际化 87 2.4.3 struts 2国际化语言的动态切换 89 2.5 struts 2的校验框架 90 2.5.1 在action中实现手动校验 90 2.5.2 调用校验框架进行自动校验 91 2.5.3 自定义国际化struts 2校验错误消息 92 2.5.4 struts 2的自带校验器 92 2.6 struts 2的拦截器 94 2.6.1 struts 2内建拦截器介绍 95 2.6.2 定义和使用拦截器栈 97 2.6.3 使用自定义拦截器 98 2.7 小结 100 第3章 struts 2标签库详解与ajax技术应用 103 3.1 struts 2主题与模板 103 3.2 struts 2控制标签详解 105 3.2.1 if/elseif/else标签详解 105 3.2.2 iterator标签详解 106 3.2.3 append标签详解 108 3.2.4 generator标签详解 110 3.2.5 merge标签详解 112 3.2.6 subset标签详解 113 3.2.7 sort标签详解 115 3.3 struts 2数据标签详解 116 3.3.1 action标签详解 116 3.3.2 bean标签详解 118 3.3.3 date标签详解 120 3.3.4 debug标签详解 121 3.3.5 i18n标签详解 122 3.3.6 include标签详解 123 3.3.7 param标签详解 126 3.3.8 push标签详解 127 3.3.9 set标签详解 128 3.3.10 text标签详解 129 3.3.11 url标签详解 130 3.3.12 property标签详解 132 3.4 struts 2表单标签详解 134

spring 的优点？ 1.降低了组件之间的耦合性，实现了软件各层之间的解耦 2.可以使用容易提供的众多服务，如事务管理，消息服务等 3.容器提供单例模式支持 4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能 5.容器提供了众多的辅助类，能加快应用的开发 6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等 7.spring属于低侵入式设计，代码的污染极低 8.独立于各种应用服务器 9.spring的DI机制降低了业务对象替换的复杂性 10.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring的部分或全部什么是DI机制？依赖注入（Dependecy Injection）和控制反转（Inversion of Control）是同一个概念，具体的讲：当某个角色需要另外一个角色协助的时候，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在spring中创建被调用者的工作不再由调用者来完成，因此称为控制反转。创建被调用者的工作由spring来完成，然后注入调用者因此也称为依赖注入。 spring以动态灵活的方式来管理对象，注入的两种方式，设置注入和构造注入。设置注入的优点：直观，自然构造注入的优点：可以在构造器中决定依赖关系的顺序。什么是AOP？面向切面编程（AOP）完善spring的依赖注入（DI），面向切面编程在spring中主要表现为两个方面 1.面向切面编程提供声明式事务管理 2.spring支持用户自定义的切面面向切面编程（aop）是对面向对象编程（oop）的补充，面向对象编程将程序分解成各个层次的对象，面向切面编程将程序运行过程分解成各个切面。 AOP从程序运行角度考虑程序的结构，提取业务处理过程的切面，oop是静态的抽象，aop是动态的抽象，是对应用执行过程中的步骤进行抽象，，从而获得步骤之间的逻辑划分。 aop框架具有的两个特征： 1.各个步骤之间的良好隔离性 2.源代码无关性 Hibernate工作原理及为什么要用？原理： 1.读取并解析配置文件 2.读取并解析映射信息，创建SessionFactory 3.打开Sesssion 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用： 1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。 4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。 2． Hibernate是如何延迟加载? 1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection） 2. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。 3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系) 类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、 4．说下Hibernate的缓存机制 1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存 2. 二级缓存： a) 应用及缓存 b) 分布式缓存条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据 c) 第三方缓存的实现 5． Hibernate的查询方式 Sql、Criteria,object comptosition Hql： 1、属性查询 2、参数查询、命名参数查询 3、关联查询 4、分页查询 5、统计函数 6．如何优化Hibernate？ 1.使用双向一对多关联，不使用单向一对多 2.灵活使用单向一对多关联 3.不用一对一，用多对一取代 4.配置对象缓存，不使用集合缓存 5.一对多集合使用Bag,多对多集合使用Set 6. 继承类使用显式多态 7. 表字段要少，表关联不要

单向关联和双向关联单双向的通俗理解： 1）单向关联：是指在实体的一端进行关联关系的维护（通常是多端），具有关联关系的实体对象间的加载与访问关系是单向的，即只有一个实体对象可以加载和访问对方，但对方是看不到另一方的。对被动方的操作不会影响到主动方，而主动方的操作会影响到被动方。 2）双向关联：只是在多方和一方同时维护关系，双向关联是指具有关联关系的实体对象间的加载与访问关系是双向的。即，任何一方均...

hibernate映射-单向多对多关联关系n-n关联必须是用连接表与1-n映射类似，必须set集合元素添加key子元素，指定CATEGORIES_ITMS表中参照CATEGORIES表的外键为CATEGORIES_ID.与1-n关联映射不同的是,建立n-n关联时，集合中的元素使用many-to-many。many-to-many子元素的class属性指定items集合中存放的是Item对象，col

62,615

社区成员

307,307

社区内容

发帖

与我相关

我的任务

社区管理员

加入社区

近7日
近30日
至今

加载中

查看更多榜单

社区公告

暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章