Hibernate 一对多关联映射对象级联增删改查示例

我就是我 2022-06-07 07:49 194阅读 0赞

**一.这里先讲讲inverse和cascade这两个属性的作用:**

**1、inverse的权限在cascade之上，意思就是cascade是否有用，还得看inverse这个属性**

**2、inverse的作用：在映射关系中，让其中一方去维护关系，好处就是能提高性能，不用重复维护。维护两种关系，看下:**

**2.1 控制级联关系是否有效**

**cascade是否有效，就得看inserve的值，如果是自己方来维护关系，那么cascade就有效，反之无效**

**2.2 控制外键关系**

**这个就得通过让自己拥有对方的实例引用(可能是set，也可能就是单个存储对象的变量)，这样才具备控制外键关系的能力，然后看inserve的值**

**　 3、inverse只能在一的一方设置，并且默认值是true，也就是说，不设置inverse时，默认是让多的一方去维护关系，这种一般是在双向、外键关系中才设置inverse的值，如果是单向的，就只有一方有维护关系的权利。**

**4、在以后的代码中，先要搞清楚关系，才能写出性能最好的代码。通过学习这两个属性，在测试代码中，就不必那么麻烦了，只需要考虑维护关系的一方，另一方就会自动保存了。**

**二.inverse属性**

这个是我比较难理解的一个点，一开始，因为很多人度没把他说清楚。

inverse的值是boolean值，也就是能设置为true或false。 如果一方的映射文件中设置为true，说明在映射关系(一对多，多对多等)中让对方来维护关系。如果为false，就自己来维护关系。默认值是true。 并且这属性只能在一端设置。比如一对多，这个一端。也就是在有set集合的这方设置。

维护关系：维护什么关系呢？包括两个方面

1.也就是维护外键的关系了，通俗点讲，就是哪一方去设置这个被外键约束的字段的值。就拿下面这个例子来说，employee和dept两张表不管进行什么操作，只要关系到了另一张表，就不可避免的要通过操作外键字段，比如，**employee**查询自己所属的部门，就得通过被外键约束的字段值到dept中的主键中查找，如果dept想查询自己部门中有哪些员工，就拿着自己的主键值跟**employee**中的外键字段做比较，找到相同的值则是属于自己部门的员工。 这个是查询操作， 现在如果是添加操作呢，**employee**表中添加一条记录，并且部门属于dept表中的其中一个，**employee**中有被外键约束修饰的字段，那是通过**employee**的insert语句就对这个外键字段赋值，还是让dept对象使用update语句对其赋值呢，两个都能对这个外键字段的值进行操作，谁去操作呢？如果不做设置，两个都会操作，虽然不会出现问题，但是会影响性能，因为**employee**操作的话，在使用insert语句就能设置外键字段的值了，但是dept也会进行对其进行操作，又使用update语句，这样一来，这个update就显的很多余。

2.维护级联的关系，也就是说如果如果让对方维护关系，则自己方的级联将会失效，对方设置的级联有用，如果自己维护关系，则自己方的级联会有用，但是对方设置的级联就会失效。

3.下面的代码示例中将Dept表的映射类中inverse属性设置为false,表明让dept来设置外键值，employee可以不用管了.dept可以级联添加修改employee表

代码示例:

\#数据模型类

Dept.java

package com.sunline.entity;
    
    import java.util.HashSet;
    import java.util.Set;
    
    
    /**
     * Dept entity. @author MyEclipse Persistence Tools
     */
    
    public class Dept  implements java.io.Serializable {
    
        // Fields    
         private Integer deptId;
         private Set<Employee> Employees = new HashSet<Employee>();
         private String deptName;
    
    
        // Constructors
    
        /** default constructor */
        public Dept() {
        }
    
    	/** minimal constructor */
        public Dept(String deptName) {
            this.deptName = deptName;
        }
        
        /** full constructor */
        public Dept(Set Employees, String deptName) {
            this.Employees = Employees;
            this.deptName = deptName;
        }
    
       
        // Property accessors
    
        public Integer getDeptId() {
            return this.deptId;
        }
        
        public void setDeptId(Integer deptId) {
            this.deptId = deptId;
        }
    
        public Set getEmployees() {
            return this.Employees;
        }
        
        public void setEmployees(Set Employees) {
            this.Employees = Employees;
        }
    
        public String getDeptName() {
            return this.deptName;
        }
        
        public void setDeptName(String deptName) {
            this.deptName = deptName;
        }
    
    }

Dept.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.sunline.entity.Dept" table="dept" catalog="association">
            <id name="deptId" column="dept_id" type="java.lang.Integer">
                <generator class="increment"></generator>
            </id>
            
            <set name="Employees" table="employee" inverse="false" cascade="all" lazy="false">
               <key column="dept_id"></key>
               <one-to-many class="com.sunline.entity.Employee"/>
            </set>
            <property name="deptName" type="java.lang.String">
                <column name="dept_name" length="200" not-null="true" />
            </property>
        </class>
    </hibernate-mapping>

Employee.java

package com.sunline.entity;
    
    
    
    /**
     * Employee entity. @author MyEclipse Persistence Tools
     */
    
    public class Employee  implements java.io.Serializable {
    
    
        // Fields    
    
         private Integer empId;
         private Integer deptId;
         private Dept Depts;
         private String empName;
         private Double empSalary;
    
    
        // Constructors
    
        /** default constructor */
        public Employee() {
        }
    
    	/** minimal constructor */
        public Employee(String empName, Double empSalary) {
            this.empName = empName;
            this.empSalary = empSalary;
        }
        
        /** full constructor */
        public Employee(Integer deptId, Dept Depts, String empName, Double empSalary) {
            this.deptId = deptId;
            this.Depts = Depts;
            this.empName = empName;
            this.empSalary = empSalary;
        }
    
       
        // Property accessors
    
        public Integer getEmpId() {
            return this.empId;
        }
        
        public void setEmpId(Integer empId) {
            this.empId = empId;
        }
    
        public Integer getDeptId() {
            return this.deptId;
        }
        
        public void setDeptId(Integer deptId) {
            this.deptId = deptId;
        }
    
        public Dept getDepts() {
            return this.Depts;
        }
        
        public void setDepts(Dept Depts) {
            this.Depts = Depts;
        }
    
        public String getEmpName() {
            return this.empName;
        }
        
        public void setEmpName(String empName) {
            this.empName = empName;
        }
    
        public Double getEmpSalary() {
            return this.empSalary;
        }
        
        public void setEmpSalary(Double empSalary) {
            this.empSalary = empSalary;
        }
    }

Employee.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.sunline.entity.Employee" table="employee" catalog="association">
            <id name="empId" column="emp_id" type="java.lang.Integer">
                <generator class="increment"></generator>
            </id>
            <property name="deptId" type="java.lang.Integer">
                <column name="dept_id" length="10"/>
            </property>
            <many-to-one name="Depts" class="com.sunline.entity.Dept" column="dept_id" insert="false" update="false" />
            <property name="empName" type="java.lang.String">
                <column name="emp_name" length="200" not-null="true" />
            </property>
            <property name="empSalary" type="java.lang.Double">
                <column name="emp_salary" precision="10" not-null="true" />
            </property>
        </class>
    </hibernate-mapping>

\#配置文件:

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
    <beans
    	xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:p="http://www.springframework.org/schema/p"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:aop="http://www.springframework.org/schema/aop"
    	xmlns:tx="http://www.springframework.org/schema/tx"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	                    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                            http://www.springframework.org/schema/context 
                            http://www.springframework.org/schema/context/spring-context-3.0.xsd
                            http://www.springframework.org/schema/tx
                            http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
                            http://www.springframework.org/schema/aop
                            http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
                            
        
        <context:property-placeholder location="classpath:db.properties"/>
        
        
        
        <context:component-scan base-package="com.sunline">
        </context:component-scan>
    	<bean id="dataSource"
    		class="org.apache.commons.dbcp.BasicDataSource">
    		<property name="driverClassName"
    			value="${driverClassName}">
    		</property>
    		<property name="url"
    			value="${url}">
    		</property>
    		<property name="username" value="${username}"></property>
    		<property name="password" value="${password}"></property>
    	</bean>
    	<bean id="sessionFactory"
    		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    		<property name="dataSource">
    			<ref bean="dataSource" />
    		</property>
    		<property name="hibernateProperties">
    			<props>
    				<prop key="hibernate.dialect">
    					org.hibernate.dialect.MySQLDialect
    				</prop>
    				<prop key="dialect">
    				    org.hibernate.dialect.MySQLDialect
    				</prop>
                    <prop key="hibernate.hbm2ddl.auto">true</prop>
                    <prop key="hibernate.show_sql">true</prop> 
    			</props>
    		</property>
    		<property name="mappingResources">
    			<list>
    				<value>com/sunline/entity/Dept.hbm.xml</value>
    				<value>com/sunline/entity/Employee.hbm.xml</value>
                </list>
    		</property>
       </bean>
       
       	
    	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
            <property name="sessionFactory" ref="sessionFactory" />
        </bean>
       
        
    	<tx:annotation-driven transaction-manager="transactionManager"/>
    </beans>

\#数据访问类

DeptDao.java

package com.sunline.dao;
    
    import javax.annotation.Resource;
    import org.hibernate.SessionFactory;
    import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
    import org.springframework.stereotype.Repository;
    
    import com.sunline.entity.Dept;
    @Repository(value="MyDept")
    public class DeptDao extends HibernateDaoSupport {
    	/*
    	 * 使用注解必须添加以下方式
    	 */
        @Resource  
        public void setSessionFacotry(SessionFactory sessionFacotry) {  
            super.setSessionFactory(sessionFacotry);  
        }  
        
    	/*
    	 * 添加部门
    	 */
        public void AddDept(Dept dept){
    	    System.out.println("成功添加部门");
    		this.getHibernateTemplate().save(dept);
        }
        
    	/*
    	 * 根据deptId查询部门某个ID的所有信息
    	 */
    	public Dept findById(int deptId) {
    		Dept dept=(Dept)this.getHibernateTemplate().get(Dept.class,deptId);
    		return dept;
    	}
        
    	/*
    	 * 修改部门名称
    	 */
    	public void UpdateDeptName(String deptName, int deptId){
    		this.getHibernateTemplate().bulkUpdate("update Dept set deptName = ? where deptId = ?",new Object[]{deptName,deptId}) ;
    	}
    	
    	/*
    	 * 根据deptId级联删除部门信息
    	 */
    	public void DeleteDept(int deptId){
    		System.out.println("成功删除数据!");
    		this.getHibernateTemplate().delete(findById(deptId));
    	}
    }

\#业务逻辑类

DeptBiz.java

package com.sunline.biz;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    import com.sunline.dao.DeptDao;
    import com.sunline.entity.Dept;
    
    @Service(value="MyDepts")
    public class DeptBiz {
    	/*
    	 * 添加部门
    	 */
    	@Autowired
    	@Qualifier("MyDept")            //使用@Qualifier注解来说明使用哪一个实现类
        DeptDao deptDao;
        public void AddDept(Dept dept){
           deptDao.AddDept(dept);
        }
        
    	/*
    	 * 根据deptId查询部门某个ID的所有信息
    	 */
    	public Dept findById(int deptId) {
    		return deptDao.findById(deptId);
    	}
    	
    	/*
    	 * 修改部门名称
    	 */
    	public void UpdateDeptName(String deptName, int deptId){
    		deptDao.UpdateDeptName(deptName, deptId);
    	}
    	
    	/*
    	 * 根据deptId级联删除部门信息
    	 */
    	public void DeleteDept(int deptId){
    		deptDao.DeleteDept(deptId);
    	}
    }

\#测试类

TestOneToMany.java(级联添加部门,员工)

package com.sunline.test;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;
    
    import com.sunline.biz.DeptBiz;
    import com.sunline.entity.Dept;
    import com.sunline.entity.Employee;
    @Transactional(propagation=Propagation.REQUIRED)
    public class TestOneToMany {
    
    	/**
    	 * @param args
    	 */
    	@SuppressWarnings("unchecked")
    	@Transactional(propagation=Propagation.REQUIRED)        //用事务管理做双重保障
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            DeptBiz deptBiz = (DeptBiz) ctx.getBean("MyDepts");
            
            //1:关键点，部门对象的初始化,创建一个部门
            Dept dept = new Dept();
            dept.setDeptName("大数据事业部");
            
            //2:关键点，员工对象的初始化,创建两个员工
            Employee emp1 = new Employee();
            emp1.setEmpName("张三 ");
            emp1.setEmpSalary(2000.0);
            
            Employee emp2 = new Employee();
            emp2.setEmpName("李四");
            emp2.setEmpSalary(5000.0);
            
            //3:关键点，将员工对象放到部门中,级联添加
            dept.getEmployees().add(emp1);
            dept.getEmployees().add(emp2);
            
            //4:最后级联保存员工对象，部门
            deptBiz.AddDept(dept);
    	}
    
    }

DeleteTest.java(级联删除)

UpdateTest.java(改)

QueryTest.java(级联查询某个部门所有员工信息)

package com.sunline.test;
    
    import java.util.Set;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;
    
    import com.sunline.biz.DeptBiz;
    import com.sunline.entity.Dept;
    import com.sunline.entity.Employee;
    
    @Transactional(propagation=Propagation.REQUIRED)
    public class QueryTest {
    
    	/**
    	 * @param args
    	 */
    	@Transactional(propagation=Propagation.REQUIRED)        //用事务管理做双重保障
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            DeptBiz deptBiz = (DeptBiz) ctx.getBean("MyDepts");
            
            Dept dept = deptBiz.findById(3);
            System.out.println(dept.getDeptName()+" "+dept.getEmployees());
            Set<Employee> emp = dept.getEmployees();
            for(Employee employee :emp){
            	System.out.println("该部门的员工信息为: "+employee.getEmpName()+" "+employee.getEmpSalary());  
            }
            
            
    	}
    
    }

**\#总结:这里可能有人会有疑问,为什么这里只有对部门表(Dept)的数据访问,业务逻辑,员工表(employee)怎么没有?确实是不需要,这是级联的增删改查,只需对数据持久层的任一方作设置,就可以进行级联操作,添加部门同时可添加员工,删除某个部门会删除该部门相关的所有员工信息,省时省力.**