Hibernate级联保存与删除

最新推荐文章于 2021-01-13 23:02:01 发布
最新推荐文章于 2021-01-13 23:02:01 发布
阅读量7.4k 收藏
点赞数
分类专栏： JAVA EE java 文章标签： hibernate 级联保存 级联删除 JPA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lishengbo/article/details/50932107
版权 
   Hibernate为程序员提供一种级联操作，在编写程序时，通过Hibernate的级联功能可以很方便的操作数据库的主从表的数据，我们最常用的级联是级联保存和级联删除，下面分别来看一下级联保存和级联删除。

       我准备了MenuPanel和Menu两个对象，先来看一下两个对象的关系

       从上图可以看出，MenuPanel和Menu是一对多的关系，Menu表同时存在多个子节点，用parentId代表该节点的父节点。

 

    在JPA中，配置级联操作我们可以用cascade=CascadeType.ALL，意思是支持所有的级联操作，网上有很多文章说级联保存用CascadeType.PERSIST，这也是可以的，我们分别在代码中使用以上两个类型。在MenuPane的getChildren()方法中标上下面的注解：

       

@OneToMany(cascade=CascadeType.PERSIST,fetch=FetchType.LAZY,mappedBy="menu")
	public List<Menu> getChildren() {
		return children;
	}


       在Menu的getChildren()的方法中标上下面的注解

@OneToMany(cascade=CascadeType.PERSIST,fetch=FetchType.LAZY,mappedBy="menu")
	public List<Menu> getChildren() {
		return children;
}


 

       以上代码实现级联保存的配置，我们需要在业务逻辑中为对象设置关系，这样Hibernate才能自动实现级联保存，如果只是配置了级联操作，而没有在对象中设置对象之前的关系，Hibernate是无法实现级联保存的功能的。

       首先实例化MenuPanel

MenuPanel panel1 = new MenuPanel("基础设置");


      再实例化几个Menu

Menu menuCard=new Menu("会员卡设置","");
menuCard.setLeaf(false);
Menu menu1 = new Menu("卡类型设置", "basicOperation/queryCardType");
Menu menu2 = new Menu("站点设定", "basicOperation/querySite");
Menu menu3 = new Menu("操作员授权", "basicOperation/queryOperatorSet");
Menu menu4 = new Menu("密码修改", "test.do");
Menu menu5 = new Menu("消费项目管理", "test1.do");

    我们要把menuCard作为menu1的父节点，故作如下设置

List<Menu> cardChildMenus=new ArrayList<Menu>();
cardChildMenus.add(menu1);
menuCard.setChildren(cardChildMenus);//把卡类型设置作为会员卡设置的子菜单


    设置对象之间的关系，这一步很关键，直接影响保存结果

menu1.setMenu(menuCard);//为会员卡设置设置卡类型设置，以支持级联保存
menuCard.setMenuPanel(panel1);
//设置Menu属于MenuPanel
menu2.setMenuPanel(panel1);
menu3.setMenuPanel(panel1);
menu4.setMenuPanel(panel1);
menu5.setMenuPanel(panel1);

//将Menu添加到MenuPanel
panel1.getMenus().add(menuCard);
panel1.getMenus().add(menu2);
panel1.getMenus().add(menu3);
panel1.getMenus().add(menu4);
panel1.getMenus().add(menu5);


具体代码:

@Override
	public boolean testAdd() {
		List<MenuPanel> menuPanels=new ArrayList<MenuPanel>();
		
		MenuPanel panel1 = new MenuPanel("基础设置");
		Menu menuCard=new Menu("会员卡设置","");
		menuCard.setLeaf(false);
		
		
		Menu menu1 = new Menu("卡类型设置", "basicOperation/queryCardType");
		Menu menu2 = new Menu("站点设定", "basicOperation/querySite");
		Menu menu3 = new Menu("操作员授权", "basicOperation/queryOperatorSet");
		Menu menu4 = new Menu("密码修改", "test.do");
		Menu menu5 = new Menu("消费项目管理", "test1.do");
		
		menu1.setMenu(menuCard);//为会员卡设置设置卡类型设置，以支持级联保存
		menuCard.setMenuPanel(panel1);
		
		menu2.setMenuPanel(panel1);
		menu3.setMenuPanel(panel1);
		menu4.setMenuPanel(panel1);
		menu5.setMenuPanel(panel1);
		
		List<Menu> cardChildMenus=new ArrayList<Menu>();
		cardChildMenus.add(menu1);
		menuCard.setChildren(cardChildMenus);//把卡类型设置作为会员卡设置的子菜单
		
		panel1.getMenus().add(menuCard);
		panel1.getMenus().add(menu2);
		panel1.getMenus().add(menu3);
		panel1.getMenus().add(menu4);
		panel1.getMenus().add(menu5);
		
		
		MenuPanel panel2 = new MenuPanel("日常操作");
		Menu menu10 = new Menu("发行新卡", "operate/cardList?type=add");
		Menu menu11 = new Menu("存款入卡", "operate/cardList?type=depositMoney");
		Menu menu12 = new Menu("卡中取款", "operate/cardList?type=drawMoney");
		Menu menu13 = new Menu("奖品管理", "operate/cardList?type=prize");
		Menu menu14 = new Menu("卡挂失", "operate/cardList?type=reportLoss");
		Menu menu15 = new Menu("卡解挂", "operate/cardList?type=cancelLoss");
		Menu menu16 = new Menu("并卡", "operate/cardList?type=mergeCard");
		Menu menu17 = new Menu("补办新卡", "operate/cardList?type=mendCard");
		Menu menu18 = new Menu("回收旧卡", "operate/cardList?type=recycleCard");
		Menu menu19 = new Menu("维护", "operate/cardList?type=maintain");
		
		menu10.setMenuPanel(panel2);
		menu11.setMenuPanel(panel2);
		menu12.setMenuPanel(panel2);
		menu13.setMenuPanel(panel2);
		menu14.setMenuPanel(panel2);
		menu15.setMenuPanel(panel2);
		menu16.setMenuPanel(panel2);
		menu17.setMenuPanel(panel2);
		menu18.setMenuPanel(panel2);
		menu19.setMenuPanel(panel2);
		
		panel2.getMenus().add(menu10);
		panel2.getMenus().add(menu11);
		panel2.getMenus().add(menu12);
		panel2.getMenus().add(menu13);
		panel2.getMenus().add(menu14);
		panel2.getMenus().add(menu15);
		panel2.getMenus().add(menu16);
		panel2.getMenus().add(menu17);
		panel2.getMenus().add(menu18);
		panel2.getMenus().add(menu19);
		
		menuPanels=new ArrayList<MenuPanel>();
		menuPanels.add(panel1);
		menuPanels.add(panel2);
		
		return menuPanelDao.add(menuPanels);
	}


       执行一下单元测试，看一下效果

	@Test
	public void test()
	{
//		menuPanelService.delete();
		menuPanelService.testAdd();
	}

Hibernate: insert into MENUPANEL (text, id) values (?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENUPANEL (text, id) values (?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into MENU (leaf, parentId, menuPanelId, text, url, id) values (?, ?, ?, ?, ?, ?)

       大家可以看到数据全部保存到数据库中了，有图有真像。

       图一：MenuPanel表

      

 

图二：Menu表

 

 

         再来看一下级联删除，级联删除可以用CascadeType.REMOVE，先在Menu中的getMenuPanel()方法中加上如下配置，由于我们已经在MenuPanel中配置了cascade=CascadeType.ALL，所以，下面的配置是可以忽略的，之所以这么做，是为了当从Menu中删除对象时能级联删除MenuPanel。

@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.REMOVE}, targetEntity=MenuPanel.class)

      在getMenu()方法中也加上如下配置

@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.MERGE}, targetEntity=Menu.class)


     同在要把对象之间的关系解除

menus.get(j).setMenuPanel(null);


     具体的代码

@Override
	public boolean delete() {
		// TODO Auto-generated method stub
		Session session = null;
		try {
			session =getSession();
			Query query = session.createQuery("from MenuPanel");
			List<MenuPanel> list = query.list();
			for (int i = 0; i < list.size(); i++) {
				MenuPanel mp = list.get(i);
				List<Menu> menus = mp.getMenus();

				for (int j = 0; j < menus.size(); j++) {
					menus.get(j).setMenuPanel(null);
					clareChild(menus.get(j).getChildren());
				}
				super.delete(mp);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		} finally {
//			session.close();
		}
	}


 

       执行结果

Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENUPANEL where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENU where id=?
Hibernate: delete from MENUPANEL where id=?


 

        POJO类的详细代码如下：

package com.mcs.user.pojo;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import com.mcs.pojo.base.GenericObject;

/**
 * 这个是MenuPanel对应的是accordion菜单
 * @author lishengbo
 *
 */
@Entity
@Table(name = "MENUPANEL")
public class MenuPanel extends GenericObject {
	private String text;
	private List<Menu> menus=new ArrayList<Menu>();

	public MenuPanel() {
	}

	public MenuPanel(String text) {
		this.text = text;
	}
	public MenuPanel(long id,String text) {
		this.text = text;
		super.setId(id+"");
	}

	public String getText() {
		return text;
	}

	public void setText(String text) {
		this.text = text;
	}

	/**
	 * 一对多关联Menu菜单，作为Tree中的根节点，这里使用立即加载和MenuPanel一起加载到客户端，注意，一定要使用立即加载
	 * @return
	 */
	@OneToMany(cascade = {CascadeType.ALL}, fetch = FetchType.EAGER,mappedBy="menuPanel")
	public List<Menu> getMenus() {
		return menus;
	}

	public void setMenus(List<Menu> menus) {
		this.menus = menus;
	}

}


package com.mcs.user.pojo;

import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import com.mcs.pojo.base.GenericObject;


@Entity
@Table(name="MENU")
public class Menu extends GenericObject{
	private String text;
	private String url;
	private boolean leaf=true;//默认是叶子节点
	private MenuPanel menuPanel;
	private List<Menu> children;
	private Menu menu;
	
	
	public Menu() {
	}

	public Menu(String text, String url) {
		super();
		this.text = text;
		this.url = url;
	}
	public Menu(long id,String text, String url,MenuPanel menuPanel) {
		super();
		super.setId(id+"");
		this.text = text;
		this.url = url;
		this.menuPanel=menuPanel;
	}
	public String getText() {
		return text;
	}

	public void setText(String text) {
		this.text = text;
	}

	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.REMOVE}, targetEntity=MenuPanel.class)
	@JoinColumn(name="menuPanelId",referencedColumnName="id",insertable=true,updatable=true)
	public MenuPanel getMenuPanel() {
		return menuPanel;
	}

	public void setMenuPanel(MenuPanel menuPanel) {
		this.menuPanel = menuPanel;
	}

	@Column(length=1000)
	public boolean isLeaf() {
		return leaf;
	}

	public void setLeaf(boolean leaf) {
		this.leaf = leaf;
	}

	@OneToMany(cascade=CascadeType.PERSIST,fetch=FetchType.LAZY,mappedBy="menu")
	public List<Menu> getChildren() {
		return children;
	}

	public void setChildren(List<Menu> children) {
		this.children = children;
	}

	@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.MERGE}, targetEntity=Menu.class)
	@JoinColumn(name="parentId",referencedColumnName="id",insertable=true,updatable=true)
	public Menu getMenu() {
		return menu;
	}

	public void setMenu(Menu menu) {
		this.menu = menu;
	}
	
	
}


 

lishengbo
关注
专栏目录
Hibernate级联保存
lixinyao5281的专栏
04-21 438
Hibernate级联保存;主子表同时保存;
Hibernate 级联保存
wa2661391317的博客
09-06 424
一对多的保存方法： 代码： @ManyToOne @JoinColumn(name = "REQ_ID") private Request request; @OneToMany(cascade = CascadeType.ALL, mappedBy = "request") @JsonIgnore private List<FundRequest> fundRequests; 保存方法： FundRequest fundRequest = new FundRequest(); Reques
hibernate 一对一（one to one）级联保存
crazycat03的专栏
05-07 491
前段时间用到了一对一级联保存的情况，在网上查了好多资料，现在主要总结如下：   一  ： 一般说一对一都有两种情况，一种是两张表使用同一主键，我现在说的是第二种外键关联的情况；   两个表Student, card  Student的主键是是card 的唯一外键，不多说了，配置如下： 1   Student 主表映射文件中： &lt;one-to-one name="card" cla...
级联保存
weixin_30733003的博客
04-12 99
可以主表级联多表，也可以多表级联主表，原理是一样的，主要的就是xml的配置上面： cascade="save-update"要加上 主表的xml： 1 <?xml version="1.0" encoding="UTF-8"?> 2 <!DOCTYPE hibernate-mapping PUBLIC 3 "-//Hibernate/Hiber...
hibernate onetoone 级联保存
dingxingmei的专栏
09-07 4792
一个汽车和引擎的对象，一对一关联测试，测试结果如下：  cascade 属性设置为all的时候级联保存 成功，设置为refresh的时候 ，没有级联保存。  org.hibernate.exception.GenericJDBCException: could not execute statement at org.hibernate.excep
Hibernate实现one-to-one级联保存
黑鹰
06-16 1033
在具体的项目应用中,我们很少会用到一对一的级联操作,且很多时候一对一的操作可以通过多对一实现,但是一对一有自己的好处,就是在任何时候都能保证主外键数据的一致性,但是多对一的情况下未必能做到. 我在项目中具体用到了一对一的级联操作,从网上拿了 一个例子来做,但是没有成功,于是只好自己研究,现在把修改后的代码帖出来. 本例子使用hibernate3.jar+oracle数据库 库表: CARD
0.1、级联保存CascadeType.PERSIST
weixin_33714884的博客
06-16 188
2019独角兽企业重金招聘Python工程师标准>>> ...
采坑系列之JPA级联保存
一个爱分享的人
06-08 1万+
springboot-jpa 踩过jpa多对多查询的坑之后，紧接着有跳进了级联保存的坑，真的很无语，继续爬。。。。 本来以为保存就是一件简单的事，给对象添加内容，一键save就OK，现实却是关联数据丢三落四，只好深入的学习了。 首先最最重要的就是@ManyToMany中的级联属性设置，如果你皮一下，没有写，那你就等着被自己蠢哭吧，比如我。。。实体类代码如下： //维护端 pu...
hibernate---级联保存、级联删除
weixin_34378767的博客
09-22 104
直接上菜： dept.hbm.xml：关键点标蓝色这部分，inverse表示放弃维护外键关系，cascade就不用说了 <hibernate-mapping package="com.cissst.it.dept.entity"> <class name="Dept" table="DEPT1"> <id name="deptno"...
Hibernate级联操作（级联保存、级联删除）
weixin_40222311的博客
10-17 211
级联保存操作，保存客户级联保存联系人 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> &l
hibernate many-to-many级联保存，级联更新，级联删除
05-13
hibernate many-to-many级联保存，级联更新，级联删除
hibernate级联保存
Dzq_Boyka的博客
12-02 277
今天写级联保存，就是保存不了关联对象，注解也没问题，后来搜索到了解决办法（也正如我想的换注解试试）
hibernate 注解 级联保存
风满楼的博客
07-30 2078
//bean public class Person {private String id; private City city; public Person() { }@Id @GeneratedValue(generator = "generator") @GenericGenerator(name = "generator", strategy = "uuid") @
求解HIBERNATE大家试过级联保存
zhouxinhong的专栏
03-15 567
求解HIBERNATE大家试过级联保存 public class Father { private Long id; private Set children; //getId() //setId() //getName() //setName() /** *@hibernate.set inverse="false" cascade="all" *@hibernate
hibernate多对多级联保存、级联删除
BlackEn ▪ Lee
12-26 2053
hibernate多对多级联操作
hibernate级联保存更新、删除
赶路人儿
09-22 2576
1、级联保存和更新 当Hibernate持久化一个临时对象时，在默认情下，他不会自动持久化所关联的其他临时对象，如果希望当持久化对象时把他所关联的所有临时对象进行持久化的话；可以把的cascade属性设置为： "save-update" ,cascade的默认属性值为none。 cascade:设置操作对象时的级联操作，即层级之间的连锁操作 值 save-update ：表示当保存和更
Hibernate 数据的保存，更新和删除
热门推荐
javacoffe的专栏
07-13 2万+
  数据的保存，更新和删除：   1、Session.save()方法：Session.save()方法用于实体对象的持久化保存，也就是说当执行session.save()方法时会生成对应的insert SQL语句，完成数据的保存。如下面的代码：User user=new User();user.setName(“zx”);Transaction tx=session.be
jpa级联添加_JPA+Hibernate：@OneToOne级联保存无效
weixin_30861557的博客
01-13 424
创建HUSBAND表CREATE TABLE HUSBAND (ID INTEGER,NAME VARCHAR2(10));创建WIFE表CREATE TABLE WIFE (ID INTEGER,NAME VARCHAR2(10));HUABAND实体及Repository@Entity@Table(name = "HUSBAND", schema = "SYSTEM")public class...
Hibernate级联操作详解与实战
在Java的持久化框架Hibernate中，`cascade`属性是一个非常重要的概念，它涉及到对象关系映射（Object-Relational Mapping，ORM）中的级联操作。级联操作允许开发者在处理一个对象时，自动地对与其相关联的对象执行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lishengbo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值