Hibernate学习-7-关联映射(一对多，多对一)

最新推荐文章于 2020-05-13 23:16:11 发布
最新推荐文章于 2020-05-13 23:16:11 发布
阅读量288 收藏
点赞数
分类专栏： 过去的酱油文章
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010281209/article/details/53522281
版权
关联映射

需求分析

 

eg 1-

  部门与员工的例子

        一个部门有多个员工[一对多]

        多个员工，属于一个部门[多对一]

eg 2-

       一个项目多个开发人员

       一个开发人员参与多个项目 [多对多]

 

一对多与多对一映射

一.需求分析

二.数据库

t_dept

字段：deptId  deptName 

t_employee

字段：empId empName salary dept_id

三.javabean

设计关键：通过一方维护到另一方

class Dept{
   
    private int deptId;
    
    private String deptName;

    //部门对应多个员工
    private Set<Employee> emps;

}

class Employee{
    
   private int empId;
   
   private String empName;

   private double salary;
 
   //多个员工对应一个部门
   private Dept dept;
}

四.映射

Dept映射关键点

1.映射的集合属性:"emps"

2.指定集合属性对应的集合表:"t_employee"

3.指定集合表的外键字段

4.指定集合元素的类型

 Employee映射的关键点

1.映射的部门属性: dept

2.映射的部门对象，对应的外键字段:dept_id

3.部门的类型

实例-保存数据-查询数据

总配置文件

<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
         <!--1.数据库连接配置-->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///learnHibernate</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">33269456.cx</property>
        <!--
          数据库方言配置，hibernate会根据不同的方言生成符合当前数据库语法的sql
        -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <!--2.其他相关配置-->
        <!--2.1显示运行时的sql语句-->
        <property name="hibernate.show_sql">true</property>


        <!--2.2格式化sql-->


        <property name="hibernate.format_sql">true</property>


        <!--2.3自动建表,写好映射就可以-->

        <property name="hibernate.hbm2ddl.auto">update</property>

        <!--3.加载所有映射-->

    </session-factory>

</hibernate-configuration>

Dept.java

package com.cx.entity;

import java.util.HashSet;
import java.util.Set;

/**
 * Created by cxspace on 16-8-2.
 */
public class Dept {


    private int deptId;

    private String deptName;

    //一对多(一个部门对应多个员工)
    private Set<Employee> employees = new HashSet<>();

    public int getDeptId() {
        return deptId;
    }

    public void setDeptId(int deptId) {
        this.deptId = deptId;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    public Set<Employee> getEmployees() {
        return employees;
    }

    public void setEmployees(Set<Employee> employees) {
        this.employees = employees;
    }
}

相关映射配置

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">


<hibernate-mapping package="com.cx.entity">


    <class name="Dept" table="t_dept">

        <id name="deptId">
            <generator class="native"></generator>
        </id>

        <property name="deptName" length="20"></property>

        <!--
            1.映射的集合属性:"emps"

            2.指定集合属性对应的集合表:"t_employee"

            3.指定集合表的外键字段

            4.指定集合元素的类型
        -->

        <!--table="t_employee",可以省略-->

        <set name="employees" table="t_employee">
            <key column="dept_id"></key>
            <one-to-many class="Employee"></one-to-many>
        </set>


    </class>

</hibernate-mapping>

Employee.java

package com.cx.entity;

/**
 * Created by cxspace on 16-8-2.
 */
public class Employee {

    private int empId;

    private String empName;

    private double salary;

    private Dept dept;

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public int getEmpId() {
        return empId;
    }

    public void setEmpId(int empId) {
        this.empId = empId;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

相关映射配置

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">


<hibernate-mapping package="com.cx.entity">

    <class name="Employee" table="t_employee">
        <id name="empId">
            <generator class="native"></generator>
        </id>

        <property name="empName" length="20"></property>

        <property name="salary" type="double"></property>

        <!--
        多对一映射配置
        Employee 映射关键点：
        1.  映射的部门属性  ：  dept
        2.  映射的部门属性，对应的外键字段: dept_id
        3.  部门的类型
        -->

        <many-to-one name="dept" column="dept_id" class="Dept"></many-to-one>

    </class>

</hibernate-mapping>

测试类

package com.cx.test;

import com.cx.entity.Dept;
import com.cx.entity.Employee;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

/**
 * Created by cxspace on 16-8-2.
 */
public class Save {

    private static SessionFactory sf;
    static {
        sf = new Configuration()
                .configure()
                .addClass(Dept.class)
                .addClass(Employee.class)   // 测试时候使用
                .buildSessionFactory();
    }


    //保存,部门方 一对一方法操作

    public void save(){

        Session session = sf.openSession();
        session.beginTransaction();

        //部门对象
        Dept dept = new Dept();
        dept.setDeptName("应用开发部");

        //员工对象
        Employee emp_zs = new Employee();

        emp_zs.setEmpName("张三");

        Employee emp_ls = new Employee();

        emp_ls.setEmpName("李四");

        //关系
        dept.getEmployees().add(emp_zs);
        dept.getEmployees().add(emp_ls);

        //保存

        session.save(emp_zs);
        session.save(emp_ls);

        session.save(dept);

        session.getTransaction().commit();
        session.close();

        /*
        *

                Hibernate:
                    insert
                    into
                        t_employee
                        (empName, salary, dept_id)
                    values
                        (?, ?, ?)
                Hibernate:
                    insert
                    into
                        t_employee
                        (empName, salary, dept_id)
                    values
                        (?, ?, ?)
                Hibernate:
                    insert
                    into
                        t_dept
                        (deptName)
                    values
                        (?)
                Hibernate:
                    update
                        t_employee
                    set
                        dept_id=?
                    where
                        empId=?
                Hibernate:
                    update
                        t_employee
                    set
                        dept_id=?
                    where
                        empId=?

        * */

    }


    //保存,员工方[多对一保存],效率更高
    @Test

    public void save2(){

        Session session = sf.openSession();
        session.beginTransaction();

        Dept dept = new Dept();
        dept.setDeptName("综合部");

        Employee emp_zs = new Employee();
        emp_zs.setEmpName("张三");

        Employee emp_ls = new Employee();
        emp_ls.setEmpName("李四");

        emp_zs.setDept(dept);
        emp_ls.setDept(dept);

        session.save(dept);
        session.save(emp_ls);
        session.save(emp_zs);

        session.getTransaction().commit();
        session.close();

        /*
        *
        * 结果
        *
        *   Hibernate:
                insert
                into
                    t_dept
                    (deptName)
                values
                    (?)
            Hibernate:
                insert
                into
                    t_employee
                    (empName, salary, dept_id)
                values
                    (?, ?, ?)
            Hibernate:
                insert
                into
                    t_employee
                    (empName, salary, dept_id)
                values
                    (?, ?, ?)
        *
        *
        * */

    }

}

结果

package com.cx.test;

import com.cx.entity.Dept;
import com.cx.entity.Employee;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

/**
 * Created by cxspace on 16-8-2.
 */
public class Get {


    private static SessionFactory sf;
    static {
        sf = new Configuration()
                .configure()
                .addClass(Dept.class)
                .addClass(Employee.class)   // 测试时候使用
                .buildSessionFactory();
    }

    @Test
    public void get(){

        Session session = sf.openSession();
        session.beginTransaction();

        //通过部门方获取另一方
//        Dept dept = (Dept) session.get(Dept.class , 1);
//        System.out.println(dept.getDeptName());
//        System.out.println(dept.getEmployees());


结果

Hibernate:
select
dept0_.deptId as deptId0_0_,
dept0_.deptName as deptName0_0_
from
t_dept dept0_
where
dept0_.deptId=?
应用开发部
Hibernate:
select
employees0_.dept_id as dept4_0_1_,
employees0_.empId as empId1_,
employees0_.empId as empId1_0_,
employees0_.empName as empName1_0_,
employees0_.salary as salary1_0_,
employees0_.dept_id as dept4_1_0_
from
t_employee employees0_
where
employees0_.dept_id=?
[com.cx.entity.Employee@d35dea7, com.cx.entity.Employee@24313fcc]




        //通过员工获取部门
        Employee emp = (Employee)session.get(Employee.class,1);
        System.out.println(emp.getEmpName());
        System.out.println(emp.getDept().getDeptName());

        session.getTransaction().commit();
        session.close();

结果

Hibernate:
select
employee0_.empId as empId1_0_,
employee0_.empName as empName1_0_,
employee0_.salary as salary1_0_,
employee0_.dept_id as dept4_1_0_
from
t_employee employee0_
where
employee0_.empId=?
张三
Hibernate:
select
dept0_.deptId as deptId0_0_,
dept0_.deptName as deptName0_0_
from
t_dept dept0_
where
dept0_.deptId=?
应用开发部



    }

}

 

Inverse属性

在维护关联关系的时候起作用。表示控制权是否转移。（在一的一方起作用）

inverse 控制反转

inverse = false不反转          有控制权    

            = true 控制反转        没有控制权 （不能主动维护另一方）

 

维护关联关系

1.保存数据

     设计关联

     如果设置控制反转，然后通过部门方维护关联关系。在保存部门的时候，同时保存员工，数据会保存，但关联关系不会维护，外键字段为NULL。

2.获取数据

     无影响

3.解除关联关系

     有影响

     没有控制权无法接触关联关系，无法生成update语句,也不会报错

4.删除数据对关联关系的影响

  有控制权，可以删除，先清空外键引用，再删除。

  没控制权报错，无法删除。

测试代码

package com.cx.test;

import com.cx.entity.Dept;
import com.cx.entity.Employee;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

/**
 * Created by cxspace on 16-8-2.
 */
public class Inverse {

    private static SessionFactory sf;
    static {
        sf = new Configuration()
                .configure()
                .addClass(Dept.class)
                .addClass(Employee.class)   // 测试时候使用
                .buildSessionFactory();
    }


    //inverse对保存数据的影响
    public void save(){

        Session session = sf.openSession();
        session.beginTransaction();

        //部门对象
        Dept dept = new Dept();
        dept.setDeptName("运维部");

        //员工对象
        Employee emp_zs = new Employee();

        emp_zs.setEmpName("张三");

        Employee emp_ls = new Employee();

        emp_ls.setEmpName("李四");

        //关系
        dept.getEmployees().add(emp_zs);
        dept.getEmployees().add(emp_ls);

        //inverse = true ,不会设置关联,此时的关联应该通过员工方来维护

        //保存

        session.save(emp_zs);
        session.save(emp_ls);

        session.save(dept);

        session.getTransaction().commit();
        session.close();


        /*
        *
        *
        *
        Hibernate:
            insert
            into
                t_employee
                (empName, salary, dept_id)
            values
                (?, ?, ?)
        Hibernate:
            insert
            into
                t_employee
                (empName, salary, dept_id)
            values
                (?, ?, ?)
        Hibernate:
            insert
            into
                t_dept
                (deptName)
            values
                (?)
                *
                *
                * */

            }

    //inverse属性,对获取数据的影响---无影响


    public void get(){
        Session session = sf.openSession();
        session.beginTransaction();

        Dept dept = (Dept) session.get(Dept.class,2);

        System.out.println(dept.getDeptName());
        System.out.println(dept.getEmployees());

        session.getTransaction().commit();
        session.close();

        /*
        *
        *
        *
        * Hibernate:
    select
        dept0_.deptId as deptId0_0_,
        dept0_.deptName as deptName0_0_
    from
        t_dept dept0_
    where
        dept0_.deptId=?
综合部
Hibernate:
    select
        employees0_.dept_id as dept4_0_1_,
        employees0_.empId as empId1_,
        employees0_.empId as empId1_0_,
        employees0_.empName as empName1_0_,
        employees0_.salary as salary1_0_,
        employees0_.dept_id as dept4_1_0_
    from
        t_employee employees0_
    where
        employees0_.dept_id=?
[com.cx.entity.Employee@d35dea7, com.cx.entity.Employee@24313fcc]
        *
        *
        *
        *
        *
        *
        *
        * */

    }


    public void removeRelation(){

        Session session = sf.openSession();
        session.beginTransaction();

        Dept dept = (Dept)session.get(Dept.class,2);

        dept.getEmployees().clear();

        session.getTransaction().commit();
        session.close();

        /*
        * inverse=true 没有控制权
        *
        *
   Hibernate:
    select
        dept0_.deptId as deptId0_0_,
        dept0_.deptName as deptName0_0_
    from
        t_dept dept0_
    where
        dept0_.deptId=?
        *
        *
        *
        inverse = false

     Hibernate:
    select
        dept0_.deptId as deptId0_0_,
        dept0_.deptName as deptName0_0_
    from
        t_dept dept0_
    where
        dept0_.deptId=?
Hibernate:
    select
        employees0_.dept_id as dept4_0_1_,
        employees0_.empId as empId1_,
        employees0_.empId as empId1_0_,
        employees0_.empName as empName1_0_,
        employees0_.salary as salary1_0_,
        employees0_.dept_id as dept4_1_0_
    from
        t_employee employees0_
    where
        employees0_.dept_id=?
Hibernate:
    update
        t_employee
    set
        dept_id=null
    where
        dept_id=?


        *
        * */

    }

    @Test
    public void deleteData(){
        Session session = sf.openSession();
        session.beginTransaction();


        Dept dept = (Dept) session.get(Dept.class,1);
        session.delete(dept);

        session.getTransaction().commit();
        session.close();

        /*
        inverse = true
        Hibernate:

            select
                dept0_.deptId as deptId0_0_,
                dept0_.deptName as deptName0_0_
            from
                t_dept dept0_
            where
                dept0_.deptId=?
        Hibernate:
            delete
            from
                t_dept
            where
                deptId=?

                报错
            org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update

    at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:96)
    at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:66)
    at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:275)
    at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:268)
    at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:189)
    at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:321)
    at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:51)
    at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:1216)
    at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:383)
    at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:133)
    at com.cx.test.Inverse.deleteData(Inverse.java:217)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.junit.internal.runners.TestMethodRunner.executeMethodBody(TestMethodRunner.java:99)
    at org.junit.internal.runners.TestMethodRunner.runUnprotected(TestMethodRunner.java:81)
    at org.junit.internal.runners.BeforeAndAfterRunner.runProtected(BeforeAndAfterRunner.java:34)
    at org.junit.internal.runners.TestMethodRunner.runMethod(TestMethodRunner.java:75)
    at org.junit.internal.runners.TestMethodRunner.run(TestMethodRunner.java:45)
    at org.junit.internal.runners.TestClassMethodsRunner.invokeTestMethod(TestClassMethodsRunner.java:66)
    at org.junit.internal.runners.TestClassMethodsRunner.run(TestClassMethodsRunner.java:35)
    at org.junit.internal.runners.TestClassRunner$1.runUnprotected(TestClassRunner.java:42)
    at org.junit.internal.runners.BeforeAndAfterRunner.runProtected(BeforeAndAfterRunner.java:34)
    at org.junit.internal.runners.TestClassRunner.run(TestClassRunner.java:52)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:130)
    at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:119)
    at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:42)
    at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:234)
    at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:74)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)
Caused by: java.sql.BatchUpdateException: Cannot delete or update a parent row: a foreign key constraint fails (`learnHibernate`.`t_employee`, CONSTRAINT `FKFDCF5A195CFBCEF9` FOREIGN KEY (`dept_id`) REFERENCES `t_dept` (`deptId`))
    at com.mysql.jdbc.PreparedStatement.executeBatchSerially(PreparedStatement.java:2054)
    at com.mysql.jdbc.PreparedStatement.executeBatch(PreparedStatement.java:1467)
    at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:70)
    at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:268)
    ... 32 more


                inverse = false

                正常删除
                
            Hibernate: 
                select
                    dept0_.deptId as deptId0_0_,
                    dept0_.deptName as deptName0_0_ 
                from
                    t_dept dept0_ 
                where
                    dept0_.deptId=?
            Hibernate: 
                update
                    t_employee 
                set
                    dept_id=null 
                where
                    dept_id=?
            Hibernate: 
                delete 
                from
                    t_dept 
                where
                    deptId=?    
                            

         */

    }

}

 

cascade属性

表示级联操作

none不级联操作 ，默认值

save-update级联保存或者更新

delete级联删除

save-update,delete 级联保存、更新、删除

all    同上

实例

package com.cx.test;

import com.cx.entity.Dept;
import com.cx.entity.Employee;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

/**
 * Created by cxspace on 16-8-2.
 */
public class Cascade {

    private static SessionFactory sf;
    static {
        sf = new Configuration()
                .configure()
                .addClass(Dept.class)
                .addClass(Employee.class)   // 测试时候使用
                .buildSessionFactory();
    }

    //级联保存


    @Test
    public void save(){

        Session session = sf.openSession();
        session.beginTransaction();

        Dept dept = new Dept();
        dept.setDeptName("人事部");

        Employee emp_zs = new Employee();
        emp_zs.setEmpName("张三");
        Employee emp_ls = new Employee();
        emp_ls.setEmpName("李四");
        // 关系
        dept.getEmployees().add(emp_zs);
        dept.getEmployees().add(emp_ls);

        //设置了级联只要保存部门
        session.save(dept);

        session.getTransaction().commit();
        session.close();

        /*
        *
        * Hibernate:
    insert
    into
        t_dept
        (deptName)
    values
        (?)
Hibernate:
    insert
    into
        t_employee
        (empName, salary, dept_id)
    values
        (?, ?, ?)
Hibernate:
    insert
    into
        t_employee
        (empName, salary, dept_id)
    values
        (?, ?, ?)
Hibernate:
    update
        t_employee
    set
        dept_id=?
    where
        empId=?
Hibernate:
    update
        t_employee
    set
        dept_id=?
    where
        empId=?
        * */


    }

    public void delete(){
        Session session = sf.openSession();
        session.beginTransaction();

        Dept dept = (Dept) session.get(Dept.class,5);

        session.delete(dept);

        session.getTransaction().commit();
        session.close();

        /*
        *
        * Hibernate:
    select
        dept0_.deptId as deptId0_0_,
        dept0_.deptName as deptName0_0_
    from
        t_dept dept0_
    where
        dept0_.deptId=?
Hibernate:
    select
        employees0_.dept_id as dept4_0_1_,
        employees0_.empId as empId1_,
        employees0_.empId as empId1_0_,
        employees0_.empName as empName1_0_,
        employees0_.salary as salary1_0_,
        employees0_.dept_id as dept4_1_0_
    from
        t_employee employees0_
    where
        employees0_.dept_id=?
Hibernate:
    update
        t_employee
    set
        dept_id=null
    where
        dept_id=?
Hibernate:
    delete
    from
        t_employee
    where
        empId=?
Hibernate:
    delete
    from
        t_employee
    where
        empId=?
Hibernate:
    delete
    from
        t_dept
    where
        deptId=?
        *
        * */

    }

}

 

无问_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Hibernate】一对多关联映射
颗粒归仓
01-10 421
前两篇博客介绍了多对一和一对一关联映射，这篇博客介绍一对多关联映射，它的原理和多对一关联映射的原理是一样的，都是在多的一端加入一个外键，指向一的一端。下面详细介绍相关内容： 一、单向一对多     一对多的关系我们用学生和班级来说，一个班级有多个学生，多个学生可能属于一个班级，他们的对象模型和关系模型如下：     在进行关系映射时需要在一的一端添加标签，另外还需要在一的一端
Hibernate入门第十讲——Hibernate的一对多关联映射
热门推荐
李阿昀的博客
04-13 1万+
Hibernate关联映射——一对多（多对一）我们以客户(Customer)与订单(Order)为例来讲解Hibernate关联映射中的一对多关联关系。 首先肯定是搭建好Hibernate的开发环境，我在此也不过多赘述，读者自行实践。接着在src目录下创建一个cn.itheima.oneToMany包，并在该包下创建两个实体类，如下： 客户类// 客户 ---- 一的一方 public class
Hibernate 集合映射 一对多多对一 inverse属性 + cascade级联属性 多对多 一对一 关系映射...
weixin_30275415的博客
05-15 58
1 . 集合映射 　　需求：购物商城，用户有多个地址。 // javabean设计 // javabean设计 public class User { private int userId; private String userName; // 一个用户，对应的多个地址 private Set<String> address; ...
MyBatis的关联映射之 一对多 和 多对多
共勉
04-17 2331
MyBatis的关联映射之 一对一（嵌套查询/嵌套结果）单击前往 一对多的关系 在一个用户拥有多个订单的案例当中将会使用到一对多的关系映射：在MyBatis当中的resultMap元素的子元素collection就是用于一对多关系映射的。该元素的属性基本与association的属性一致：其中ofType对应的是javaType：它是用于指定实体对象中集合类属性所包含的元素类型。 因此，需要建立一...
一对多关联关系映射和设置级联属性
超胆孤侠
12-20 1266
在领域模型中, 类与类之间最普遍的关系就是关联关系. 在 UML 中, 关联是有方向的. 以 Customer 和 Order 为例： 一个用户能发出多个订单, 而一个订单只能属于一个客户. 从 Order 到 Customer 的关联是多对一关联; 而从 Customer 到 Order 是一对多关联 单向关联 双向关联 单向 n-1 单向 n-1 关联只需从 n 的一端可以访问 1 的一端
映射文件中的集合属性和组成关系映射
02-25 1336
一.映射文件中的集合属性有：List、Set、Array、Bag、Map、idbag      1. Set：无序、不可重复         Set集合元素：key、element             元素来映射持久化类的set类型的属性                    name：设定待映射持久化类的属性名                    cascade：设定级联
六、映射 -- 关联映射【一对多、多对一】（一）
weixin_45602227的博客
05-13 2326
一、集合映射的局限性 +++外键表和主键表的关系: 外键表的外键受主键表的主键所约束。 +++ 如何描述主键表与外键表的映射关系 集合映射 一对多、多对一映射 多对多映射 +++ 集合映射的局限性 集合映射只能映射主键表的两个或三个简单字段。 对于复杂的主键表，集合映射则无法处理映射关系。 所以这时引入了一对多、多对一、多对多等映射。 一、一对多、多对一的映射数据库设计 需求1： 部门与员工 一个部门
hibernate一对多关联映射学习小结
08-29
Hibernate一对多关联映射学习小结 Hibernate是一种流行的Java持久层框架，它提供了强大的对象关系映射（ORM）功能，能够将Java对象与关系数据库中表之间建立映射关系。Hibernate的关联映射是其核心功能之一，可以将...
hibernate 全面学习->hibernate 关联映射学习
03-06
总的来说，这个压缩包提供了丰富的Hibernate关联映射的学习资源，涵盖了从基础到进阶的各种关联类型。通过学习这些示例，你将能够熟练掌握如何在Java项目中使用Hibernate进行数据持久化，并灵活地处理各种数据库关系...
Hibernate ORM - 一对多双向关联关系
03-28
标题“Hibernate ORM - 一对多双向关联关系”指的是在数据库建模中，Hibernate ORM（对象关系映射）框架如何处理一个实体类（如User）与多个实体类（如Article）之间的关系。在这种关系中，一个用户可以拥有多个文章...
Hibernate实现many-to-many的映射关系
08-26
因此，在实际开发中，有时会选择将多对多关系转换为两个一对多关系，通过引入一个关联实体（如这里的`StuCourse`）来提高效率和简化操作。 总结一下，Hibernate实现多对多映射关系的关键步骤包括： 1. 定义两个实体...
MyBatis的关系映射——一对多
zhangdy12307的博客
03-31 1664
MyBatis的关系映射——一对多 一对多的关系 定义：一个A类类型对应多个B类类型，需要在A类中以集合的方式引入B类类型对象，在B类中定义A类类型的属性a。 1、创建数据库 案例中所需要的数据库如下 create table tb_user( id int(32) primary key auto_increment, username varchar(32), address varchar(...
mybatis入门(一)-mybatis介绍和获取SqlSession
浮夸的程序员
11-27 5969
首先什么是MyBatis呢？要找到这个问题的答案，当然最准确的说法肯定在开发出它的人那，谁是开发它的人呢。然后...        我们就要用到学软件必不可少的神器了 https://github.com/ , 如果不知道github的话，赶快去百度谷歌搜索，知道了之后就注册一个github账户，并学会GitHub的使用,由于这篇文章重点不再这里，所以不会专门讲这些操作。        我们在
画图理解软件工程-进行详细的需求分析（二）
浮夸的程序员
11-27 3554
首先,我们看下从用户那里获取到整理成SRS文档的过程 我们怎么从用户那里获取详细需求呢可以从下面这一些列的问号入手 系统将要做什么？ 系统什么时候做？ 有多种操作模式吗？ 必须执行什么种类的计算和数据转换？ 对可能刺激合适的反应是什么？ 输入、输出系统的格式是什么？ 在任何时间都必须保留任何数据吗？ 设备安放在哪？ 在一个地还是多个地方？ 是否有任何环境限制？ 是否对系统的设计规模有限制？ 是
画图理解软件工程-UML统一建模语言-用例图（三）
浮夸的程序员
11-27 3311
UML定义 Unified Modeling Language (UML)又称统一建模语言或标准建模语言，是始于1997年一个OMG标准，它是一个支持模型化和软件系统开发的图形化语言，为软件开发的所有阶段提供模型化和可视化支持，包括由需求分析到规格，到构造和配置。 面向对象的分析与设计(OOA&D，OOAD)方法的发展在80年代末至90年代中出现了一个高潮，UML是这个高潮的产物。它不仅统一了Boo
画图理解软件工程-UML统一建模语言-类图和时序图(四)
浮夸的程序员
11-30 2134
首先我们再整理一下合理软件开发的流程 一、需求分析阶段 需求是产品优劣的关键 二、系统设计阶段 三、开发阶段 四、测试阶段 五、维护阶段        发布系统，维护系统(备份系统数据)，数据软件系统运行是出问题，与开发人员合作修复问题。 ======================================================
myBatis入门（二）-mybatis工作流程
浮夸的程序员
11-27 1083
myBatis工作流程我们通过一个向数据库中插入一条数据记录的例子来了解一些myBatis的工作流程 下面这个demo看下src下文件目录结构数据库表的描述如下，创建脚本很简单，这里就不写了 下面开始写代码第一步：写数据表对应的实体类Student.java package com.cxspace.bean;public class Student { private int id;
mysql-(三)-数据库设计三大范式
浮夸的程序员
12-08 508
一.数据库设计在业务流程的位置 需求分析时要将原始的需求抽象成业务模型 写成需求说明书        概要设计             抽取实体  :  业务模型  ->   实体模型 (java类)             数据库设计  :                       业务模型/实体模型  ->  数据模型        详细设计          ...  
Javascript学习总结-基本语法-(一)
浮夸的程序员
12-08 418
1.1.javascript简介(引用百度百科解释)     JavaScript一种直译式脚本语言，是一种动态类型、弱类型、基于原型的语言，内置支持类型。它的解释器被称为JavaScript引擎，为浏览器的一部分，广泛用于客户端的脚本语言，最早是在HTML（标准通用标记语言下的一个应用）网页上使用，用来给HTML网页增加动态功能。 在1995年时，由Netscape公司的Brendan Ei
Hibernate一对一到多关联映射详解与实例
本文档是对Hibernate一对多关联映射进行深入学习的小结，主要适用于希望通过理解这种关系模式来提升对ORM框架Hibernate的运用能力。一对多关联映射是数据库设计中常见的关系类型，它描述了一个类有多于一个实例与另...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值