java 关系网设计

转载

jkfox 2024-11-20 14:22:02

文章标签 java 关系网设计 hibernate User 关联关系 文章分类 Java 后端开发

hibernate 程序执行流程

集合映射

User.java

public class User {

private int userId;
private String userName;
// 一个用户，对应的多个地址
private Set<String> address;
private List<String> addressList = new ArrayList<String>(); 
//private String[] addressArray; // 映射方式和list一样     <array name=""></array>
private Map<String,String> addressMap = new HashMap<String, String>();



public Map<String, String> getAddressMap() {
    return addressMap;
}
public void setAddressMap(Map<String, String> addressMap) {
    this.addressMap = addressMap;
}
public List<String> getAddressList() {
    return addressList;
}
public void setAddressList(List<String> addressList) {
    this.addressList = addressList;
}
public int getUserId() {
    return userId;
}
public void setUserId(int userId) {
    this.userId = userId;
}
public String getUserName() {
    return userName;
}
public void setUserName(String userName) {
    this.userName = userName;
}
public Set<String> getAddress() {
    return address;
}
public void setAddress(Set<String> address) {
    this.address = address;
}


}

User.hbm.xml

<?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="cn.itcast.a_collection">

<class name="User" table="t_user">
    <id name="userId" column="id">
        <generator class="native"></generator>
    </id>   
    <property name="userName"></property>

    <!-- 
        set集合属性的映射
            name 指定要映射的set集合的属性
            table 集合属性要映射到的表
            key  指定集合表(t_address)的外键字段
            element 指定集合表的其他字段
                type 元素类型，一定要指定
     -->
     <set name="address" table="t_address">
        <key column="uid"></key>
        <element column="address" type="string"></element>
     </set>

     <!-- 
        list集合映射
            list-index  指定的是排序列的名称 (因为要保证list集合的有序)
      -->
      <list name="addressList" table="t_addressList">
          <key column="uid"></key>
          <list-index column="idx"></list-index>
          <element column="address" type="string"></element>
      </list>

      <!-- 
        map集合的映射
            key  指定外键字段
            map-key 指定map的key 
            element  指定map的value
       -->
      <map name="addressMap" table="t_addressMap">
        <key column="uid"></key>
        <map-key column="shortName" type="string" ></map-key>
        <element column="address" type="string" ></element>
      </map>


</class>


</hibernate-mapping>

App.java

public class App {

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

// 保存set
@Test
public void testSaveSet() throws Exception {
    Session session = sf.openSession();
    session.beginTransaction();

    //-- 保存
    Set<String> addressSet = new HashSet<String>();
    addressSet.add("广州");
    addressSet.add("深圳");
    // 用户对象
    User user = new User();
    user.setUserName("Jack");
    user.setAddress(addressSet);

    // 保存
    session.save(user);

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

// 保存list/map
@Test
public void testSaveList() throws Exception {
    Session session = sf.openSession();
    session.beginTransaction();
    User user = new User();
    user.setUserName("Tom");
//      // 用户对象  --  list
//      user.getAddressList().add("广州");
//      user.getAddressList().add("深圳");
//      // 保存
//      session.save(user);

    // 用户对象  --  Map
    user.getAddressMap().put("A0001", "广州");
    user.getAddressMap().put("A0002", "深圳");

    // 保存
    session.save(user);

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


// 获取
@Test
public void testGet() throws Exception {
    Session session = sf.openSession();
    session.beginTransaction();

    // 获取
    User user = (User) session.get(User.class, 3); // 及时加载
    System.out.println(user.getUserId());
    System.out.println(user.getUserName());

    // 当查询用户，同时可以获取用户关联的list集合的数据 (因为有正确映射)
    // 当使用到集合数据的使用，才向数据库发送执行的sql语句  (懒加载)
    System.out.println(user.getAddressList());

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

关联映射

多对一映射与一对多

java 关系网设计_User

public class Dept {

private int deptId;
private String deptName;
// 【一对多】 部门对应的多个员工
private Set<Employee> emps = new HashSet<Employee>();

public class Employee {

private int empId;
private String empName;
private double salary;
// 【多对一】员工与部门
private Dept dept;

Dept.hbm.xml

<?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="cn.itcast.b_one2Many">

<class name="Dept" table="t_dept">
    <id name="deptId">
        <generator class="native"></generator>
    </id>   
    <property name="deptName" length="20"></property>

    <!-- 
        一对多关联映射配置  （通过部门管理到员工）
        Dept 映射关键点：
        1.  指定 映射的集合属性： "emps"
        2.  集合属性对应的集合表： "t_employee"
        3.  集合表的外键字段   "t_employee. dept_id"
        4.  集合元素的类型

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


</class>


</hibernate-mapping>

Employee.hbm.xml

<?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="cn.itcast.b_one2Many">

<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>

测试

public class App {

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.getEmps().add(emp_zs);
    dept.getEmps().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 deptId=? where empId=?    维护员工引用的部门的id
        Hibernate: update t_employee set deptId=? 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_zs);
    session.save(emp_ls);// 再保存多的一方，关系会自动维护(映射配置完)

    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 (?, ?, ?)
        少生成2条update  sql
     */
}

}

总结

在一对多与多对一的关联关系中，保存数据最好的通过多的一方来维护关系，这样可以减少update语句的生成，从而提高hibernate的执行效率！

配置一对多与多对一，这种叫“双向关联”
只配置一对多，叫“单项一对多”
只配置多对一，叫“单项多对一”

注意：
配置了哪一方，哪一方才有维护关联关系的权限！

查询

public class App2_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.getEmps());// 懒加载


    // 通过员工房，获取另外一方
    Employee emp = (Employee) session.get(Employee.class, 1);
    System.out.println(emp.getEmpName());
    System.out.println(emp.getDept().getDeptName());


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

}

Inverse属性

Inverse属性，是在维护关联关系的时候起作用的。
表示控制权是否转移。(在一的一方起作用)

Inverse , 控制反转。
Inverse = false 不反转；当前方有控制权（默认）
True 控制反转；当前方没有控制权

维护关联关系中，是否设置inverse属性：

1. 保存数据 
    有影响。
   如果设置控制反转,即inverse=true, 然后通过部门方维护关联关系。在保存部门的时候，同时保存员工， 数据会保存，但关联关系不会维护。即外键字段为NULL
2. 获取数据

    无影响。

3. 解除关联关系？
    有影响。
    inverse=false，  可以解除关联
inverse=true，  当前方(部门)没有控制权，不能解除关联关系
(不会生成update语句,也不会报错)
    4. 删除数据对关联关系的影响？
    有影响。
    inverse=false, 有控制权， 可以删除。先清空外键引用，再删除数据。
    inverse=true,  没有控制权: 如果删除的记录有被外键引用，会报错，违反主外键引用约束！  如果删除的记录没有被引用，可以直接删除。

示例

public class App3_inverse {

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

// 1. 保存数据 
@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.getEmps().add(emp_zs);
    dept.getEmps().add(emp_ls);  // inverse=true,  不会设置关联。
                                //                 此时的关联应该通过员工方维护。


    // 保存
    session.save(emp_zs);
    session.save(emp_ls);
    session.save(dept); // 保存部门，部门下所有的员工  

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

//2. 是否设置inverse，对获取数据的影响？   无.
@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.getEmps());

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

// 3. 是否设置inverse，对解除关联关系影响？
// inverse=false，  可以解除关联
// inverse=true，  当前方(部门)没有控制权，不能解除关联关系(不会生成update语句,也不会报错)
// 
@Test
public void removeRelation() {
    Session session = sf.openSession();
    session.beginTransaction();

    // 获取部门
    Dept dept = (Dept) session.get(Dept.class, 2);
    // 解除关系
    dept.getEmps().clear();

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


//3. 是否设置inverse属性，在删除数据中对关联关系的影响?
// inverse=false, 有控制权， 可以删除。先清空外键引用，再删除数据。
// inverse=true,  没有控制权: 如果删除的记录有被外键引用，会报错，违反主外键引用约束！
//                           如果删除的记录没有被引用，可以直接删除。
@Test
public void deleteData() {
    Session session = sf.openSession();
    session.beginTransaction();

    // 查询部门
    Dept dept = (Dept) session.get(Dept.class, 8);
    session.delete(dept);


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

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

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

}

cascade 属性

cascade 表示级联操作【可以设置到一的一方或多的一方】

none          不级联操作， 默认值
save-update     级联保存或更新
delete        级联删除
save-update,delete    级联保存、更新、删除
all                 同上。级联保存、更新、删除

示例

public class App4_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.getEmps().add(emp_zs);
    dept.getEmps().add(emp_ls);  

    // 保存
//      session.save(emp_zs);
//      session.save(emp_ls);
    session.save(dept); // 需要设置级联保存； 保存部门，部门下所有的员工  

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

// 级联删除
@Test
public void delete() {
    Session session = sf.openSession();
    session.beginTransaction();

    Dept dept = (Dept) session.get(Dept.class,7);
    session.delete(dept); // 级联删除

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


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

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


}

多对多映射

java 关系网设计_关联关系_02

/**
 * 开发人员
 * 
 * @author Jie.Yuan
 * 
 */
public class Developer {
private int d_id;
private String d_name;
// 开发人员，参数的多个项目
private Set<Project> projects = new HashSet<Project>();
}

/**
 * 项目
 * 
 * @author Jie.Yuan
 * 
 */
public class Project {
private int prj_id;
private String prj_name;
// 项目下的多个员工
private Set<Developer> developers = new HashSet<Developer>();

Project.hbm.xml

<?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="cn.itcast.c_many2many">

<class name="Project" table="t_project">
    <id name="prj_id">
        <generator class="native"></generator>
    </id>   
    <property name="prj_name" length="20"></property>
    <!-- 
        多对多映射:
        1.  映射的集合属性： “developers”
        2.  集合属性，对应的中间表： “t_relation”
        3. 外键字段:  prjId
        4. 外键字段，对应的中间表字段:  did
        5.   集合属性元素的类型
     -->
     <set name="developers" table="t_relation" cascade="save-update">
        <key column="prjId"></key>
        <many-to-many column="did" class="Developer"></many-to-many>
     </set>

</class>


</hibernate-mapping>

示例

public class App1_save {

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

// 1. 多对多，保存  【只能通过一方维护另外一方，不能重复维护！】
@Test
public void save() {
    Session session = sf.openSession();
    session.beginTransaction();

    /*
     * 模拟数据： 
        电商系统（曹吉，王春）
        OA系统（王春，老张）
     */
    // 创建项目对象
    Project prj_ds = new Project();
    prj_ds.setPrj_name("电商系统");
    Project prj_oa = new Project();
    prj_oa.setPrj_name("OA系统");

    // 创建员工对象
    Developer dev_cj = new Developer();
    dev_cj.setD_name("曹吉");
    Developer dev_wc = new Developer();
    dev_wc.setD_name("王春");
    Developer dev_lz = new Developer();
    dev_lz.setD_name("老张");
    // 关系 【项目方】
    prj_ds.getDevelopers().add(dev_cj);
    prj_ds.getDevelopers().add(dev_wc); // 电商系统（曹吉，王春）
    prj_oa.getDevelopers().add(dev_wc);
    prj_oa.getDevelopers().add(dev_lz); // OA系统（王春，老张）


    // 保存
//      session.save(dev_cj);
//      session.save(dev_wc);
//      session.save(dev_lz);

    session.save(prj_ds);
    session.save(prj_oa);   // 必须要设置级联保存 

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



@Test
public void bak() {

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

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

}

Developer.hbm.xml

<?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="cn.itcast.c_many2many">

<class name="Developer" table="t_developer">
    <id name="d_id">
        <generator class="native"></generator>
    </id>   
    <property name="d_name" length="20"></property>

    <!-- 
        多对多映射配置： 员工方
            name  指定映射的集合属性
            table 集合属性对应的中间表
            key   指定中间表的外键字段(引用当前表t_developer主键的外键字段)
            many-to-many
                column 指定外键字段对应的项目字段
                class  集合元素的类型
     -->
    <set name="projects" table="t_relation">
        <key column="did"></key>
        <many-to-many column="prjId" class="Project"></many-to-many>
    </set>


</class>


</hibernate-mapping>

维护关联关系

设置inverse属性，在多对多种维护关联关系的影响？

1） 保存数据
有影响。
     inverse=false ，有控制权，可以维护关联关系； 保存数据的时候会把对象关系插入中间表；
    inverse=true,  没有控制权， 不会往中间表插入数据。
2） 获取数据
    无。

3） 解除关系
    // 有影响。
    // inverse=false ,有控制权， 解除关系就是删除中间表的数据。
    // inverse=true, 没有控制权，不能解除关系。
4） 删除数据
    有影响。
    // inverse=false, 有控制权。 先删除中间表数据，再删除自身。
    // inverse=true, 没有控制权。 如果删除的数据有被引用，会报错！ 否则，才可以删除

示例

public class App2_inverse {

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

// 多对多
//1. 设置inverse属性，对保存数据影响?
// 有影响。
// inverse=false ，有控制权，可以维护关联关系； 保存数据的时候会把对象关系插入中间表；
// inverse=true,  没有控制权， 不会往中间表插入数据。
@Test
public void save() {
    Session session = sf.openSession();
    session.beginTransaction();

    /*
     * 模拟数据： 
        电商系统（曹吉，王春）
        OA系统（王春，老张）
     */
    // 创建项目对象
    Project prj_ds = new Project();
    prj_ds.setPrj_name("电商系统");
    Project prj_oa = new Project();
    prj_oa.setPrj_name("OA系统");

    // 创建员工对象
    Developer dev_cj = new Developer();
    dev_cj.setD_name("曹吉");
    Developer dev_wc = new Developer();
    dev_wc.setD_name("王春");
    Developer dev_lz = new Developer();
    dev_lz.setD_name("老张");
    // 关系 【项目方】
    prj_ds.getDevelopers().add(dev_cj);
    prj_ds.getDevelopers().add(dev_wc); // 电商系统（曹吉，王春）
    prj_oa.getDevelopers().add(dev_wc);
    prj_oa.getDevelopers().add(dev_lz); // OA系统（王春，老张）


    // 保存
//      session.save(dev_cj);
//      session.save(dev_wc);
//      session.save(dev_lz);

    session.save(prj_ds);
    session.save(prj_oa);   // 必须要设置级联保存 

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

//2 .设置inverse属性， 对获取数据影响？  无
@Test
public void get() {

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

    Project prj = (Project) session.get(Project.class, 1);
    System.out.println(prj.getPrj_name());
    System.out.println(prj.getDevelopers());


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

//3. 设置inverse属性， 对解除关系影响？
// 有影响。
// inverse=false ,有控制权， 解除关系就是删除中间表的数据。
// inverse=true, 没有控制权，不能解除关系。
@Test
public void removeRelation() {

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

    Project prj = (Project) session.get(Project.class, 7);
    prj.getDevelopers().clear();

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



//3. 设置inverse属性，对删除数据的影响?
// inverse=false, 有控制权。 先删除中间表数据，再删除自身。
// inverse=true, 没有控制权。 如果删除的数据有被引用，会报错！ 否则，才可以删除
@Test
public void deleteData() {

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

    Project prj = (Project) session.get(Project.class, 1);
    session.delete(prj);

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

}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：springmvc选择题

下一篇：asible管理docker

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

java 关系网设计

java 关系网设计

hibernate 程序执行流程

集合映射

User.java

User.hbm.xml

App.java

关联映射

多对一映射与一对多

Dept.hbm.xml

Employee.hbm.xml

测试

总结

查询

Inverse属性

示例

cascade 属性

示例

多对多映射

Project.hbm.xml

示例

Developer.hbm.xml

维护关联关系

示例

51CTO博客