Hibernate框架之路(二)多对多多关系

1、配置实体类

package cn.pojo;

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

public class User {
    /**
     * 用户表
     */
    private Integer user_id;
    private String user_name;
    private String user_pwd;
    private Set<Role> setRole = new HashSet<Role>();
    public Integer getUser_id() {
        return user_id;
    }
    public void setUser_id(Integer user_id) {
        this.user_id = user_id;
    }
    public String getUser_name() {
        return user_name;
    }
    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }
    public String getUser_pwd() {
        return user_pwd;
    }
    public void setUser_pwd(String user_pwd) {
        this.user_pwd = user_pwd;
    }
    public Set<Role> getSetRole() {
        return setRole;
    }
    public void setSetRole(Set<Role> setRole) {
        this.setRole = setRole;
    }
}

用户实体类

package cn.pojo;

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

public class Role {
    //角色表
    private Integer role_id;
    private String role_name;
    private String role_nome;

    private Set<User> setuser = new HashSet<User>();

    public Set<User> getSetuser() {
        return setuser;
    }
    public void setSetuser(Set<User> setuser) {
        this.setuser = setuser;
    }
    public Integer getRole_id() {
        return role_id;
    }
    public void setRole_id(Integer role_id) {
        this.role_id = role_id;
    }
    public String getRole_name() {
        return role_name;
    }
    public void setRole_name(String role_name) {
        this.role_name = role_name;
    }
    public String getRole_nome() {
        return role_nome;
    }
    public void setRole_nome(String role_nome) {
        this.role_nome = role_nome;
    }
}

角色实体类

2、配置映射文件

<?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>
        <class name="cn.pojo.User" table="user">
            <id name="user_id" column="user_id">
                 <generator class="native"></generator>
            </id>
            <!-- 3、配置其他属性 -->
            <property name="user_name"></property>
            <property name="user_pwd" ></property>
            <!-- 第三张表 -->
            <set name="setRole" table="user_role" cascade="save-update,delete">
                <key  column="userid"></key>
                <many-to-many class="cn.pojo.Role" column="roleid"></many-to-many>
            </set>
        </class>
    </hibernate-mapping>

用户配置文件

<?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>
        <class name="cn.pojo.Role" table="role">
            <id name="role_id" column="role_id">
                 <generator class="native"></generator>
            </id>
            <!-- 3、配置其他属性 -->
            <property name="role_name"></property>
            <property name="role_nome" ></property>
            <set name="setuser" table="user_role" cascade="save-update,delete">
                <key  column="roleid"></key>
                <many-to-many class="cn.pojo.User" column="userid"></many-to-many>
            </set>
        </class>
    </hibernate-mapping>

角色配置文件

3、配置核心文件

4、加载核心文件

5、测试

package cn.junit;

import static org.junit.Assert.*;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import com.unitl.HibernateUtils;

import cn.pojo.Role;
import cn.pojo.User;

public class Text1 {
//    添加操作
    @Test
    public void test() {
        SessionFactory factory = null;
        Session session = null;
        Transaction ts = null;
        try {
            factory = HibernateUtils.getSessionFactory();
            session = factory.openSession();
            ts = session.beginTransaction();
            //创建用户
            User user1 = new User();
            user1.setUser_name("张三");
            user1.setUser_pwd("123");
            User user2 = new User();
            user2.setUser_name("李四");
            user2.setUser_pwd("456");
            //创建角色
            Role r1 = new Role();
            r1.setRole_name("经理");
            r1.setRole_nome("管理");
            Role r2 = new Role();
            r2.setRole_name("秘书");
            r2.setRole_nome("管理");
            Role r3 = new Role();
            r3.setRole_name("保安");
            r3.setRole_nome("管理");
//        用户拥有角色
            user1.getSetRole().add(r1);
            user1.getSetRole().add(r2);
            user2.getSetRole().add(r2);
            user2.getSetRole().add(r3);
//            保存用户
            session.save(user1);
            session.save(user2);
            ts.commit();
        } catch (Exception e) {
            ts.rollback();
        }finally{
            session.close();
            factory.close();
        }
    }
    /**
     *一般不删除
     */
    @Test
    public void test2() {
        SessionFactory factory = null;
        Session session = null;
        Transaction ts = null;
        try {
            factory = HibernateUtils.getSessionFactory();
            session = factory.openSession();
            ts = session.beginTransaction();
            User user = session.get(User.class, 1);
            session.delete(user);
            ts.commit();
        } catch (Exception e) {
            ts.rollback();
        }finally{
            session.close();
            factory.close();
        }
    }
    /**
     * 维护表
     * 让某个用户拥有某个角色
     */
    @Test
    public void test3() {
        SessionFactory factory = null;
        Session session = null;
        Transaction ts = null;
        try {
            factory = HibernateUtils.getSessionFactory();
            session = factory.openSession();
            ts = session.beginTransaction();
//            查询id
            User user = session.get(User.class, 4);
            Role role = session.get(Role.class, 4);
//            把用户保存到set集合里
            user.getSetRole().add(role);
            ts.commit();
        } catch (Exception e) {
            ts.rollback();
        }finally{
            session.close();
            factory.close();
        }
    }
    /**
     * 维护表
     * 让某个用户没有某个角色
     */
    @Test
    public void test4() {
        SessionFactory factory = null;
        Session session = null;
        Transaction ts = null;
        try {
            factory = HibernateUtils.getSessionFactory();
            session = factory.openSession();
            ts = session.beginTransaction();
//            查询id
            User user = session.get(User.class, 4);
            Role role = session.get(Role.class, 4);
//            把用户保存到set集合里
            user.getSetRole().remove(role);
            ts.commit();
        } catch (Exception e) {
            ts.rollback();
        }finally{
            session.close();
            factory.close();
        }
    }
}

时间: 2024-10-13 07:30:56

Hibernate框架之路(二)多对多多关系的相关文章

使用annotation配置hibernate(3):多对多关系配置

数据库表结构 Student.java 1 @Entity 2 @Table(name = "student") 3 public class Student { 4 @Id 5 @Column(name = "id") 6 @GenericGenerator(name = "generator",strategy = "native") 7 @GeneratedValue(generator = "generato

Hibernate中一对多和多对一关系

1.单向多对一和双向多对一的区别? 只需要从一方获取另一方的数据时 就使用单向关联双方都需要获取对方数据时 就使用双向关系 部门--人员 使用人员时如果只需要获取对应部门信息(user.getdeptarment())不需要 从部门下的人员信息时,就配置成单向 多对一 使用部门时如果只需要获取部门下人员信息(deptartmanet.getusers())不需要 从人员获取部门信息时,就配置成单向 一对多 既要获取部门下人员 deptartmanet.getusers()又要从人员获取部门信息

Hibernate自身一对多和多对多关系映射

一对多关系映射大家都明白,关系双方都一个含有对方多个引用,但自身一对多很多同学都不明白什么意思,那么首先我就说明一下什么是自身一对多,其实也很好理解,自身一对多就是自身含有本身的多个引用,例如新闻类别,新闻包含体育新闻和政治新闻,体育新闻内有含有足球新闻和篮球新闻,其实他们都属于新闻,只是名字不同而已,下面我们就以新闻类别为例来具体说明一下: 首先我们来看一下新闻类别的类图: 类图:category 从上面的图我们可以看出:每一个新闻类别都有一个父类别和一个孩子类别的set集合,这个父类别和孩子

Hibernate框架之路(二)一对多关系

在下列案例中: 客户是一:联系人是多:客户可以拥有多个联系人:一个联系人只有一个客户 1.编写实体类 package com.pojo; import java.util.HashSet; import java.util.Set; public class User { private Integer uId; //客户ID(主表) 客户是一 private String uName; //名字 private String uTel; //手机 // 在客户的表中显示多个联系人 // 使用s

hibernate框架的学习(二)

hibernate的核心配置和API 一:核心配置分为三大部分  必须的配置 .可选的配置和引入映射文件. 1.必须的配置 连接数据库的参数:驱动类  url路径  用户名  密码  方言 <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url"

Hibernate框架之路(四)hibernate查询方式

OID查询 /** * OID 查询 * 根据ID查询 * 一对多查询 */ @Test public void test() { SessionFactory factory = null; Session session = null; Transaction ts = null; try { factory = HibernateUtils.getSessionFactory(); session = factory.openSession(); ts = session.beginTra

Hibernate框架简介

面试被问及了Hibernate框架,虽然问的很少,很简单,但是还是简单的总结一下吧,以备以后不时之需. 什么是Hibernate框架? 百科定义:Hibernate框架式一个开源的对象关系映射(ORM)框架,是对JDBC的轻量级的对象封装,使java程序员可以使用对象思维来操纵DB. 白话版:在Hibernate之前,我们是如何操作DB的?JDBC,需要在程序中嵌入SQL语句.效率低下,不能忍啊.但是Hibernate的出现,让我们无需再操纵SQL语句了,每个表实例被实例化为一个java对象,操

深入浅出Hibernate(二)多对一关系映射

学习Hibernate是为了更方便的操作数据库,在数据库中的关系模型中存在多对一的关系,比如下图所示的员工和部门之间的关系,那么这种关系在Hibernate中如何映射呢?让我用一个小Demo来详细讲解. 建立映射分为以下几步: 1.设计domain对象Department.Employee,代码如下: package cn.itcast.hibernate.domain; public class Department { private int id; private String name;

Hibernate映射(二)——多对一关系映射

上篇学习了Hibernate的基本映射,也就是单表映射,很容易就能理解,但是对于关系数据库来说,表之间存在关系是比不可少的,关系数据库中存在的关系是通过主外键建立起来的,反应到Hibernate要如何通过对象表现呢?下面我们就继续学习Hibernate的对象关系映射. 我们先从最常见的多对一和一对多关系开始: 多对一 所谓多对一,在数据库中即在多的一端添加外键关联到一的一端,比如用户(User)和用户所在组(Group)的关系:一个User只属于一个Group,一个Group有多个Group,并