精华内容
下载资源
问答
  • 1 . 集合映射  需求:购物商城,用户有多个地址。 // javabean设计 // javabean设计 public class User { private int userId;... // 个用户,对应多个地址 private Set<String> address; privat...

    1 . 集合映射

      需求:购物商城,用户有多个地址。

    // javabean设计

    // javabean设计
    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>();
        
    }
    

    分别用Set 、List 、Map 集合对地址进行保存。

    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="User类所在包名"> 
        <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>
    

    测试类:

        
      private static SessionFactory sf;
    static {
    sf = new Configuration()
    .configure()
    .addClass(User.class) //(测试) 会自动加载映射文件:User.hbm.xml
    .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(); }

    集合数据的获取

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

    2 . 一对多 多对一映射

    需求:

      部门与员工

           一个部门有多个员工;        【一对多】

           多个员工,属于一个部门    【多对一】

    数据库设计:

    • 数据库:
      • t_dept   部门表
        • deptId   deptName
        •    1          开发部
        •    2          财务部
      • t_employee  员工表
        • empId empName    salary     dept_id   外键引用
        •      1          小王         10000        1
        •      2          小李          5000         1
        •      3          小郑          7000         2
        •      4          小高          6000         2

     javabean

    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
     部门方(Dept) 映射的关键点:
               1. 指定 映射的集合 属性:   "emps”
               2. 指定集合属性对应的表: "t_employee”
               3. 集合表的外键字段         “t_employee.dept_id”
               4. 集合元素的类型 
    <?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="类所在包名">
        <class name="Dept" table="t_dept">
            <id name="deptId">
                <generator class="native"></generator>
            </id>    
            <property name="deptName" length="20"></property>
    
             <set name="emps">   <!-- table="t_employee" -->
                  <key column="dept_id"></key>
                  <one-to-many class="Employee"/>
             </set> 
        </class>
    </hibernate-mapping>
    

    Employee.hbm.xml

    员工(Employee )映射关键点:

            1. 映射的部门属性:dept
            2. 映射的部门对象,对应的外键字段 dept_id
            3. 部门的类型
    <?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>
    
             <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
             */
        }
        
    }
    

    总结:

      最好  让多的一方来维护  【员工  多的一方 】  可以提高 效率

    获取 ://通过 部门方,获取另一方
    Dept dept = (Dept)session.get(Dept.class,1);
    syso(dept.getDeptName());
    syso(dept.getEmps());       //懒加载
    //单项多对一  不行 必须双向配置  才能维护
    //通过员工方,获取另外一方
    Employee emp = (Employee) session.get(Employee.class,1);
    syso(emp.getEmpName());
    syso(emp.getDept().getDeptName);

    配置一对多与多对一,这种叫“双向关联”

    只配置一对多,           叫“单项一对多”

    只配置多对一,           叫“单项多对一”

    3 . inverse属性 +  cascade级联属性

    Inverse属性

    ,是在维护关联关系的时候起作用的。

           表示控制权是否转移。(在一的一方起作用)

      < set name="emps" 
        inverse 属性是在维护关联关系的时候起作用的。
                表示控制权是否转移。
                (在 1 的地方起作用 Dept)    不能在多的地方使用
        inverse ,控制反转。
        inverse = false 不反转 当前方有控制权。
                     = true  反转。 当前方没有控制权。
        inverse = fasle 默认值  表示有控制权
     是否设置inverse属性对保存数据是否有影响 ?有影响
        维护关联关系中,
            1. 保存数据
                    如果设置控制 反转 ,即inverse=true 通过部门方维护关联关系。
            在保存部门的时候,同时保存员工,数据会保存,但关联关系不会维护。
            即外键关系为null;
            2. 获取数据
                    无影响
            3. 解除关联关系?
                    有影响!
                    inverse = false  可以解除关联
                    inverse = true   没有控制权,不能解除关联关系(不会生成update语句,也不会报错)
            4. 删除数据对关联关系的影响?
                    有影响
                    inverse = false  可以删除部门 ,先清空外键引用,再删除数据
                    inverse = true   没有控制权  不能删除 不生成update 语句,直接删除dept表(除非没有被外键引用),否则会报错。

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

             none          不级联操作, 默认值

             save-update     级联保存或更新

             delete                  级联删除

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

             all                 同上。级联保存、更新、删除

    save-update   只需要保存dept  关联对象会自动保存
    delete    级联删除   删除部门 会删除部门的所有员工
            inverse 与 cascade 区别?
            功能是叠加的,不会有交集  
            设置了反转以后,级联还是会起作用的。

    4 . 多对多映射

    需求:

    项目与开发人员
            Project   Developer
         一个项目 有多个开发人员
         一个开发人员 ,参与多个项目
    模拟数据:
      电商系统( 小王  小郑)
      OA系统(小郑   小高)
    DB设计
    t_project 项目表
        prj_id     prj_name     prj_date
            1          电商系统         。。
            2           OA系统          。。
    t_developer 员工信息表
        d_id        d_name       
            1            小王
            2            小郑
            3            小高
    t_relation 项目员工关系表
          prj_id    d_id
            1            1
            1            2
            2            2
            2            3

     JavaBean

    Develper

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

     Project

    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="类所在包名">
        <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>
    

     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="类所在包名">
        <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>
    

    测试:

        @Test
        public void testSaveSet() throws Exception {
            Session session = sf.openSession();
            session.beginTransaction();
            // 创建项目
            Project prj_ds = new Project();
            prj_ds.setPrj_name("电商系统");
            Project prj_oa = new Project();
            prj_oa.setPrj_name("OA系统");
            // 创建员工
            Developer dev_1 = new Developer();
            dev_1.setD_name("小王");
            Developer dev_2 = new Developer();
            dev_2.setD_name("小郑");    
            Developer dev_3 = new Developer();
            dev_3.setD_name("小高");
    //        //设置关系
    //        prj_ds.getDevelopers().add(dev_1);
    //        prj_ds.getDevelopers().add(dev_2);
    //        prj_oa.getDevelopers().add(dev_2);
    //        prj_oa.getDevelopers().add(dev_3);
    //        // 保存
    //        session.save(prj_ds);
    //        session.save(prj_oa);//需要在 Project.hbm.xml 设置级联 cascade="save-update"
    //        
            dev_1.getProjects().add(prj_ds);
            dev_2.getProjects().add(prj_ds);
            dev_2.getProjects().add(prj_oa);
            dev_3.getProjects().add(prj_oa);
            
            session.save(dev_1);
            session.save(dev_2);
            session.save(dev_3);//需要在 Developer.hbm.xml 设置级联 cascade="save-update"
            
            session.getTransaction().commit();
            session.close();
        }
    
    }
    
    多对多的维护     是否对中间表 操作
    inverse 属性对多对多关系的影响
         保存数据
                有影响 没有向中间表插入数据
          获取数据
                无影响
        解除关系
                有影响
                有控制权时,解除关系就是删除中间表的数据
                么有控制权时,不能解除关系
        删除数据
                有影响
                有控制权时,先删除中间表数据 再删除项目
                没有控制权时。会报错 直接删除项目 ,没有删除中间表数据 就报错 因为有引用

     老师与学员,

      一个老师,对应多个学员

      一个学员,有多个老师教

     父亲/孩子

     学生与考试成绩

     ….

    一对多:

             <set name="映射的集合属性" table="(可选)集合属性对应的外键表">

                <key column="外键表的,外键字段" />

                <one-to-many class="集合元素的类型" />

             </set>

    多对一:

        <many-to-one name="对象属性" class="对象类型" column="外键字段字段" />

    多对多

        <set name="" table="">

            <key column="" />

            <many-to-many column="" class="">

        </set>

    5 . 一对一映射

    需求: 用户 与 身份证 信息
                一个用户记录对应一条身份证信息!  一对一关系

     数据库设计:

            用户表:
            t_user
            userId          u_name        
                1                tom   
            身份证表:
            t_idcard
            cardNum                place        user_id(外键  唯一!)    基于外键
             442124XXX           广州市            1
      基于主键
            t_user
            userId         u_name
                1                    tom
            t_idcard    
            user_id(引用外键,并作为主键)        cardNum         palce
                 1                                   4421230XX        广州

    基于外键的映射

     JavaBean

    // 身份证
    public class IdCard {
        // 身份证号(主键)
        private String cardNum;// 对象唯一表示(Object Identified, OID)
        private String place; //  身份证地址
        // 身份证与用户,一对一的关系
        private User user;
    }
    // 用户
    public class User {
        private int userId;
        private String userName;
        // 用户与身份证信息, 一对一关系
        private IdCard idCard;
    }

     映射: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="类所在包名>
        <class name="User" table="t_user">
            <id name="userId">
                <generator class="native"></generator>
            </id>    
            <property name="userName" length="20"></property>
            <!-- 
                一对一映射: 没有外键方
             -->
             <one-to-one name="idCard" class="IdCard"></one-to-one>  
        </class>  
    </hibernate-mapping>
    

    IdCard.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="类所在包名">
        <class name="IdCard" table="t_IdCard">
            <id name="cardNum">
                <generator class="assigned"></generator>
            </id>    
            <property name="place" length="20"></property>
            <!-- 
                一对一映射,有外键方
                unique="true"   给外键字段添加唯一约束
             -->
             <many-to-one name="user" unique="true" column="user_id" class="User" cascade="save-update"></many-to-one>
        </class> 
    </hibernate-mapping>
    

     测试:

    public class app {
        private static SessionFactory sf;
        static {
            sf = new Configuration().configure().addClass(User.class)
                    .addClass(IdCard.class) // 测试时候使用
                    .buildSessionFactory();
        }
        @Test
        public void testSaveSet() throws Exception {
            Session session = sf.openSession();
            session.beginTransaction();
            // 用户
            User user = new User();
            user.setUserName("yif");
            // 身份证
            IdCard idCard = new IdCard();
            idCard.setCardNum("1212xasxsxx");
            idCard.setPlace("成都");
            // 关系
            idCard.setUser(user);
            // 保存
            session.save(idCard);
            session.getTransaction().commit();
            session.close();
        }
    
    }
    

    基于主键的映射

    修改JavaBean

    public class Idcard{
        private int user_id;
       //身份证号 主键
        private String cardNum;     //对象唯一表示 (Object Identified,OID)
        private String palce;       //身份证地址    、
        //身份证与用户  ,一对一的关系
        private User user;
    }
    

    IdCard.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="类所在包名">  
        <class name="IdCard" table="t_IdCard">
            <id name="user_id">
                <!-- 
                    id 节点指定的是主键映射, 即user_id是主键
                    主键生成方式: foreign  即把别的表的主键作为当前表的主键;
                            property (关键字不能修改)指定引用的对象     对象的全名 cn..User、  对象映射 cn.User.hbm.xml、   table(id)
                 -->
                <generator class="foreign">
                    <param name="property">user</param>
                </generator>
            </id>    
            <property name="cardNum" length="20"></property>
            <property name="place" length="20"></property>
            <!-- 
                一对一映射,有外键方
                (基于主键的映射)
                 constrained="true"  指定在主键上添加外键约束
             -->
            <one-to-one name="user" class="User" constrained="true"  cascade="save-update"></one-to-one> 
        </class>
    </hibernate-mapping>
    

     测试:

    @Test
        public void testSaveSet1() throws Exception {
            Session session = sf.openSession();
            session.beginTransaction();
    
            //用户
            User user = new User();
            user.setUserName("yif");
            //身份证
            IdCard idCard = new IdCard();
            idCard.setCardNum("12312dasxx");
            idCard.setPlace("成都");
            //关系
            idCard.setUser(user);
          //保存
             session.save(idCard);
            
            session.getTransaction().commit();
            session.close();
        }
    
    展开全文
  • 当Java中实体类属性和数据库字段不一致时候,我们可以通过resultMap进行映射,例如我们要查询个user表中用户全部信息,在Java中属性是password,而数据库字段是pwd,所以我们就引入了resultMap来取代...

    处理属性和字段不一致

    通过resultMap
    当Java中实体类属性和数据库字段不一致的时候,我们可以通过resultMap进行映射,例如我们要查询一个user表中的用户的全部信息,在Java中属性是password,而数据库字段是pwd,所以我们的就引入了resultMap来取代resultType

    <resultMap id="UserMap" type="com.com.hzy.pojo.User">
        <result property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="password" column="pwd"/>
    </resultMap>
    
    <select id="getUserList" resultMap="UserMap">
            select * from user
    </select>
    

    通过SQL语句别名
    在查询指定字段的时候,把不一致的字段指定别名为Java属性

     <select id="getUserByNameAndPassword" resultType="com.hzy.pojo.User">
         select id,username,pwd password from user where username = #{username} and pwd = #{password}
     </select>
    

    处理复杂属性

    当出现联表查询的时候,会出现一对一一对多的关系
    如果有两张表,分别是学生和老师
    在这里插入图片描述
    在这里插入图片描述
    站在学生的角度看,一个学生是对应一个老师的,这是一对一,在学生信息表中只有老师的id而没有老师的名字,我们想要通过联表查询查询出学生的信息和老师的名字。
    此时的Student类是带有复杂类型Teacher的类
    在这里插入图片描述
    在这里插入图片描述

    那么我们在进行resultMap映射的时候,会牵扯到对象的映射,用到association标签

    <resultMap id="studentTeacher" type="com.hzy.pojo.Student">
        <result property="id" column="id"/>
        <result property="studentName" column="student_name"/>
        <association property="teacher" javaType="com.hzy.pojo.Teacher">
            <result property="teacherName" column="teacher_name"/>
        </association>
    </resultMap>
    
    <select id="findAllStudent" resultMap="studentTeacher">
        SELECT s.id,s.student_name,t.teacher_name FROM student s,teacher t
    </select>
    

    如果我们站在老师的角度来看,那就是一个老师对应多个学生,这是一对多
    在这里插入图片描述
    在这里插入图片描述
    此时用到一个标签是collection

    <resultMap id="teacherStudent" type="com.hzy.pojo.Teacher">
        <result property="id" column="id"/>
        <result property="teacherName" column="teacher_name"/>
        <collection property="studentList" ofType="com.hzy.pojo.Student">
            <result property="id" column="id"/>
            <result property="studentName" column="student_name"/>
            <result property="teacherId" column="teacher_id"/>
        </collection>
    </resultMap>
    <select id="findAllTeacher" resultMap="teacherStudent">
        SELECT t.id,t.teacher_name,s.student_name FROM teacher t,student s
    </select>
    
    展开全文
  • 一对一映射和一对多映射的配置 用户表和角色表 需求:根据用户id查询用户表和角色表的数据。 一对一映射:假设用户和角色是一对一的关系: 1、 在SysUser类里添加角色属性:SysRole role 目的是:SysUser类里即包含...

    一对一映射和一对多映射的配置

    用户表和角色表
    需求:根据用户id查询用户表和角色表的数据。

    一对一映射:假设用户和角色是一对一的关系:
    1、 在SysUser类里添加角色属性:SysRole role
    目的是:SysUser类里即包含用户数据,也包含角色数据。
    2、 UserMapper.java 接口里添加查询的方法
    //根据用户id去查询用户信息和对应的角色信息
    SysUser selectUserAndRoleByUserId(long userid);
    3、 分别配置UserMapper.xml和RoleMapper.xml
    1、UserMapper.xml中的配置用户表的映射关系

    2、RoleMapper.xml的配置角色表的映射关系

    <resultMap type="SysRole" id="roleMap">
    	<id property="id" column="id"/>
    	<result property="roleName" column="role_name"/>
    	<result property="enabled" column="enabled"/>
    	<result property="createBy" column="create_by"/>
    	<result property="createTime" column="create_time"/>
    </resultMap>
    

    3、在UserMapper.xml中配置用户表和角色表的关联关系
    <!—这个关联关系起名叫:userRoleMap,
    A、继承userMap
    B、使用association 标签关联角色表的映射关系roleMap–>

    <resultMap type="SysUser" id="userRoleMap" extends="userMap">
    	<association property="role" columnPrefix="role_" 
    	resultMap="com.lwzy.t2.mapper.RoleMapper.roleMap"/>
    </resultMap>
    

    4、 书写sql语句(注意:角色表的字段都起别名,前面加role_ ,是为了避免某些字段和用户表的字段重名)

    <select id="selectUserAndRoleByUserId" resultMap="userRoleMap">
    	select u.*,
    	r.id role_id,
    	r.role_name role_role_name,
    	r.enabled role_enabled,
    	r.create_by role_create_by,
    	r.create_time role_create_time
        from sys_user u,sys_user_role ur,sys_role r
        where u.id=ur.user_id 
        and r.id=ur.role_id
        and u.id=#{userid}
    </select>
    

    一对多映射:假设用户和角色是一对多的关系:

    和上面一对一的区别有两处地方:
    1、 在SysUser类里添加角色属性:List roleList
    2、 配置关联时,不使用association,使用collection; property=”roleList”

    <resultMap type="SysUser" id="userRoleMap" extends="userMap">
    	<collection property="roleList" columnPrefix="role_" 
    	resultMap="com.lwzy.t2.mapper.RoleMapper.roleMap"/>
    </resultMap>
    
    展开全文
  • PHP改编了Jimmy Bogard著名的.NET AutoMapper,以自动将个对象的属性映射到另个对象。 PHP与众不同 PHP不是类型安全的。 虽然数组,类和接口支持函数参数的类型提示,但是不能指定返回类型。 为了确保安全的...
  • OrderMapper.xml(实体类Sql配置文件,resultMap配置一对一、一对多关联属性的映射): &lt;?xml version="1.0" encoding="UTF-8" ?&gt; &lt;!DOCTYPE mapper ...

    Mybatis的Jar包下载:https://pan.baidu.com/s/16P-MGgn53e1EtCL6wQ9VWA  密码:1azq

     

    OrderMapper.xml(实体类的Sql配置文件,resultMap配置一对一、一对多关联属性的映射):

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    
    <!-- 配置原生Sql语句   -->
    <mapper namespace="com.xxx.mybatis.mapper.OrderMapper">
    	
    	<!-- 一对一关联查询  (一个订单关联一个用户) -->
    	<!-- 手动配置数据库表的列名与返回对象属性的映射关系 (有关联属性) -->
    	<resultMap type="Order" id="order">
    		<result column="id" property="id"/>  <!-- order对象的属性 -->
    		<result column="user_id" property="userId"/>
    		<result column="number" property="number"/>  <!-- 关联查询时(多表查询),列名和属性名相同时,不可以省略不写。 单表查询时(没有关联属性)列名和属性名相同时,可以省略 -->
    		<!-- 关联属性的映射(一对一) -->
    		<association property="user" javaType="User" >  <!-- user是Order类中的关联属性。  javaType:必须指定user属性的类型 -->
    			<id column="user_id" property="id"/>  <!-- User对象的属性 -->
    			<result column="username" property="username"/>
    		</association>
    	</resultMap>
    	
    	<select id="selectOrders" resultMap="order">  <!-- 返回对象有关联属性时,必须用resultMap手动配置映射关系 -->
    		SELECT 
    		o.id,
    		o.user_id, 
    		o.number,
    		o.createtime,
    		u.username 
    		FROM orders o 
    		left join user u 
    		on o.user_id = u.id
    	</select>
    	
    	<!-- 一对多关联查询 (一个用户关联多个订单)-->
    	<resultMap type="User" id="user">
    		<id column="user_id" property="id"/>  <!-- User对象的属性 -->
    		<result column="username" property="username"/>  <!-- id标签表示主键属性;result表示非主键属性 -->
    		<!-- 关联属性的映射(一对多) -->
    		<collection property="orderList" ofType="Order" >  <!-- orderList是User类中的关联属性。 ofType:必须指定orderList属性是什么类型的集合 -->
    			<id column="id" property="id"/>    <!-- order对象的属性 -->
    			<result column="number" property="number"/>
    		</collection>
    	</resultMap>
    	
    	<select id="selectUserList" resultMap="user">
    		SELECT 
    		o.id,
    		o.user_id, 
    		o.number,
    		o.createtime,
    		u.username 
    		FROM user u
    		left join orders o 
    		on o.user_id = u.id
    	</select>
    
    </mapper>

    OrderMapper.java(遵循四个原则的Dao层接口):

    package com.xxx.mybatis.mapper;
    
    import java.util.List;
    
    import com.xxx.mybatis.pojo.Order;
    import com.xxx.mybatis.pojo.User;
    
    public interface OrderMapper {
    	
    	//遵循四个原则:
    	//OrderMapper.xml中配置的命名空间要与该接口的全类名保持一致(com.xxx.mybatis.mapper.OrderMapper) 
    	//接口中的方法名  == OrderMapper.xml中配置的sql语句的id名
    	//返回值类型  与  OrderMapper.xml文件中配置的返回值类型(resultType)要一致
    	//方法的输入参数类型 与OrderMapper.xml中配置的输入参数的类型(parameterType)要一致
    	
    	//一对一关联 查询  以订单为中心 关联用户
    	public List<Order> selectOrders();
    	
    	//一对多关联
    	public List<User> selectUserList();
    	
    }

    Test.java(测试类):

    package com.xxx.mybatis.junit;
    
    import java.io.InputStream;
    import java.util.List;
    
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.junit.Test;
    
    import com.xxx.mybatis.mapper.OrderMapper;
    import com.xxx.mybatis.pojo.Order;
    import com.xxx.mybatis.pojo.User;
    
    public class Test {
    
    	@Test
    	//一对一
    	public void testOrderList() throws Exception {
    		String resource = "sqlMapConfig.xml";
    		InputStream in = Resources.getResourceAsStream(resource);
    		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
    		SqlSession sqlSession = sqlSessionFactory.openSession();
    		//---------------------------------------------------------------------
    		
    		//SqlSession会根据接口自动生成这个接口的实现类  (动态代理)。
    		OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
    		List<Order> selectOrdersList = orderMapper.selectOrders();
    		
    		for (Order order : selectOrdersList) {
    			System.out.println(order);
    		}
    	}
    	
    	@Test
    	//一对多
    	public void testUserList() throws Exception {
    		String resource = "sqlMapConfig.xml";
    		InputStream in = Resources.getResourceAsStream(resource);
    		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
    		SqlSession sqlSession = sqlSessionFactory.openSession();
    		//---------------------------------------------------------------------
    		
    		//SqlSession会根据接口自动生成这个接口的实现类  (动态代理)。
    		OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
    		List<User> users = orderMapper.selectUserList();
    		for (User user : users) {
    			System.out.println(user);
    		}
    	}
    	
    }
    

    Order.java(实体类):

    package com.xxx.mybatis.pojo;
    
    import java.io.Serializable;
    import java.util.Date;
    
    public class Order  implements Serializable{
        
    	private static final long serialVersionUID = 1L;
    	private Integer id;
        private Integer userId;
        private String number;
        private Date createtime;
        private String note;
        
        //关联用户对象User
        private User user;
        
        
        //.....getter和setter方法..........
        
    }

    User.java(实体类):

    package com.xxx.mybatis.pojo;
    
    import java.io.Serializable;
    import java.util.Date;
    import java.util.List;
    
    public class User implements Serializable {
    	
    	private static final long serialVersionUID = 1L;
    	private Integer id;
    	private String username; //用户姓名
    	private String sex;   //性别
    	private Date birthday; //生日
    	private String address; //地址
    	
    	//关联订单 (List)
    	private List<Order> orderList;
    	
    	
    	//.....getter和setter方法..........
    	
    }
    

    src/sqlMapConfig.xml(Mybatis的核心配置文件):

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    
    <configuration>
     
    	<properties resource="jdbc.properties"/>
    	
    	<!-- 为类型配置别名 -->
    	<typeAliases>
    		<!-- 该包及其子包下的所有类都会自动取简单类名为别名,且别名首字母大小写都可以 -->
    		<package name="com.xxx.mybatis.pojo"/>
    	</typeAliases>
    	
    	<!-- 连接数据库的参数配置。和spring整合后 environments配置将废除    -->
    	<environments default="development">
    		<environment id="development">
    			<!-- 使用jdbc事务管理 -->
    			<transactionManager type="JDBC" />
    			<!-- 数据库连接池 -->
    			<dataSource type="POOLED">
    				<property name="driver" value="${jdbc.driver}" />
    				<property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
    				<property name="username" value="root" />
    				<property name="password" value="123" />
    			</dataSource>
    		</environment>
    	</environments>
    	
    	<!-- 加载外部实体类的Sql映射文件 -->
    	<mappers>
    		<package name="com.xxx.mybatis.mapper" />  <!-- 该包下的所有类对应的xml映射文件都会包含进来(推荐)。必须满足该包下的xml文件的名字和位置与对应类相同 -->
    	</mappers>
    	
    </configuration>
    

     

    展开全文
  • 映射一对多表关系时候存在一个inverse问题,一直以来对inverse不怎么了解,今天用到它想要弄明白,在网上看了无数个帖子还是不懂,最后终于看到一位高人一篇帖子,解释得很透彻,终于彻底了解inverse含义...
  • 昨天在做一个小项目的时候,使用了mybatis作为持久层,在进行一对多的结果集映射的时候,发生了结果集映射结果没有成功,后来在断的实验之下,终于发现的问题的所在,原来是column字段的问题,在学习mybatis的时候,...
  • 文章目录ResultMap结果集映射一、解决属性名和字段名不一致问题1、问题背景2、解决方法方法1:AS指定别名方法2(推荐):ResultMap结果集映射3、ResultMap结果集映射二、解决JavaBean中复杂属性【多对一的情况】...
  • 上篇博客写到了,实体之间关系有很多种,这次主要来说一下其中一种一对多关联映射,因为个人觉得一对关联映射是比较常见,例如我们常用继承关系也是一对关联关系。从上篇博客我们也知道,关联关系有...
  • 一对一映射 ## 使用内容: Mysql : User 用户表 Department 部门表 1 ----------------- 1 n <--------------- 1 UserDao 接口 —> 定义对应查询方法 User JavaBean 对应数据库表按固定格式生成 Department...
  • 目录一对多Java数据结构xml配置多对一Java数据结构xml配置PS一对一遇到两张表有相同列名情况 一对多 Java数据结构 一一方实体类中含有多一方list,例如,SysDictType与SysDictData,一对多,则,SysDictData有...
  • association 属性 映射到多一中”方“复杂类型”属性,例如javabean user对象中嵌套个复杂类型属性 property 映射数据列实体类属性 这里就是role javaType 完整java类名或者别名 res...
  • 对于订单来说订单对用户为一对一的关系,对于用户来说用户对订单是一对多关系 一对一关系 1、在pojo中添加相关属性,并设置getter和setter方法 Orders.java public class Orders { private Integer id; private...
  • 对一映射 在查询时,需要获取两张以上关联表数据,通过关联映射,可以由一个对象获取关联对象信息,例如:查询一个Emp员工对象,可以 通过关联映射获取员工所在部门Dept对象信息 MyBatis多对一有以下两...
  • 一对多 多对一 Department.hbm.xml Employee.hbm.xml 要说明信息有: 要说明信息有: 1,集合表(员工表) 1,关联是什么类型 2,集合外键 2,外键列 3,集合元素 ...
  • 前面已经讲解了一对多和多对一的映射是怎么配置了,也讲解了inverse和cascade属性对关联关系影响,本博文讲解多对多的映射一对一的映射! 多对多映射 需求:一个项目由多个员工开发,一个员工开发多个项目 ...
  • Hibernate的一对映射

    2020-08-14 11:10:36
    Hibernate一对多映射关联关系一对多简单示例 ...关联分为一对一、一对多、多对多、多对一、注意关联是有方向。 一对多简单示例 我这边使用订单与订单项关联关系来进行简单示例,首先订单实体类: pa
  • Hierbnate中生成一对一映射关系策略有主键映射以及外键映射两种。 主键映射: 通过将两个相关联表生成共享主键,完成一对一数据库表结构。 外键映射: 会在一个表中生成用于链接另一个表外键,再通过unique...
  • Hibernate的一对多和多对一映射 单向 一到多的映射  通过set来配置,set标签的属性有  以学生和班级的关系为例  在一方即班级的映射文件中可以这样配置 <set name="students" table="student"> ...
  • Entity Framework 一对多关系映射

    千次阅读 2019-06-30 20:04:24
    EF中关系映射也是一个很关键内容,关系映射属性映射一样,也是在 OnModelCreating 中配置映射。EF中关系映射有如下三种: One-to-Many Relationship(一对多) Many-to-Many Relationship(多对多) One-to-...
  • 一对一映射之resultType 需求:联合order表和user表,查询每个用户订单信息和用户信息 步骤: 1 定义orders订单PO类 属性与表对应 2 由于要得到用户订单列表,所以订单类中要有user属性 创建OrdersExt扩展...
  • 映射一对一关联

    2019-09-24 18:05:12
    一对一关系映射即为关系双方都含有对方一个引用其实在生活中一对一关系也很常见比如人和身份证学生和学号等都是一对一关系映射一对一映射分为单向和双向没种关系映射又可以分为主键关联映射,唯一...
  • 1一对一映射 1.1.1 使用resultMap配置一对一映射 association标签的映射查询常用的属性如下。 property: 对应实体类中的属性名,必填项。 javaType:属性对应的Java类型。 resultMap:可以直接使用现有...
  • 6.一对一的关联映射

    2019-01-19 12:19:21
    1.一对一的单向关联映射 类图: 表关系: 1.创建model类 必须要给IdCard这端一个主键,还有指定一对一的关系 public class IDCard { private Integer cardId; //提供身份证主键 private String ...
  • 本文主要Hibernate注解进行讲解,由于篇幅原因,将注解部分分为两篇文章来写。集合映射和关联关系映射将在后面一文讲解。本文包括以下五个部分: 基础映射。主键映射。基本属性映射。复合属性映射。继承映射。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,588
精华内容 2,235
关键字:

一对一映射的属性