zoukankan      html  css  js  c++  java
  • MyBatis(3)-映射文件

    本次博文有疑问,请先看MyBatis(1)-简单入门MyBatis(2)-全局配置文件!

    如在有疑问,请留言或者咨询博主,博主每天都在!谢谢!

    映射文件:

    主要是在xxxmapper.xml文件里的配置

    映射文件指导这MyBatis如何进行数据库增删该查,有着很重要的意义。

    下面开始进入正题,最后会发一个完整版的代码

    因为实现的主要内容是增删改查,所以我们现在接口类中定义好相关的方法,后面不在进行单一的定义!

    工程的目录如下:

    EmployeeMapper.java

    package com.MrChengs.dao;
    
    import java.util.Map;
    
    import org.apache.ibatis.annotations.Param;
    import org.apache.ibatis.annotations.Select;
    
    import com.MrChengs.bean.Employee;
    
    public interface EmployeeMapper {

      //我们直接传入map public Employee getByMap(Map<String,Object> map); //查询满足两个条件的数据 public Employee getByIdAndNames(@Param("id")int id,@Param("name")String name); //查询 public Employee getEmployee(int id); //增加 public void addEmp(Employee employee); //更新 public void updateEmp(Employee employee); //删除 public void deleteById(int id); }

    1)insert-映射插入语句

    1.1)EmployeeMapper.xml

      <insert id="addEmp" >
    
                 insert into test(name,gender,email) values(#{name},#{gender},#{email})
    
         </insert>
     
    1.2)在测试类中MyBatisTest.java
       @Test
         public void test2() throws IOException{
               //1.得到SqlSeesionFactory
               SqlSessionFactory sessionFactory = getSqlSessionFactory();
               //2.得到SqlSession
               SqlSession sqlSession = sessionFactory.openSession();
               try{
                    EmployeeMapper mapper = (EmployeeMapper) sqlSession.getMapper(EmployeeMapper.class);
                    //手动添加数据:
                    Employee em = new Employee( "zhangsan", "boy", "zhangsan@qq.com");
                    mapper.addEmp(em);
                    //手动提交数据
                    sqlSession.commit();
               }finally{
                    sqlSession.close(); }}

    1.3)测试成功

    2)update映射更新语句

    2.1)EmployeeMapper.xml

     <update id="updateEmp">
               update test set name=#{name},gender=#{gender} where id=#{id}
         </update>

    2.2)测试类中

       @Test
         public void test3() throws IOException{
               //1.得到SqlSeesionFactory
               SqlSessionFactory sessionFactory = getSqlSessionFactory();
               //2.得到SqlSession
               SqlSession sqlSession = sessionFactory.openSession();
               try{
                    EmployeeMapper mapper = (EmployeeMapper) sqlSession.getMapper(EmployeeMapper.class);
                    //手动添加数据:
                    Employee em = new Employee( 6,"Jerry", "gril", null);
                    mapper.updateEmp(em);
                    //手动提交数据
                    sqlSession.commit();
               }finally{
                    sqlSession.close();}}

    2.3)测试成功!

    3)delete-映射删除操作

    3.1)EmployeeMapper.xml

         <delete id="deleteById">
               delete from test where id=#{id}
         </delete>

    3.2)测试类中

     @Test
         public void test4() throws IOException{
               //1.得到SqlSeesionFactory
               SqlSessionFactory sessionFactory = getSqlSessionFactory();
               //2.得到SqlSession
               SqlSession sqlSession = sessionFactory.openSession();
               try{
                    EmployeeMapper mapper = (EmployeeMapper) sqlSession.getMapper(EmployeeMapper.class);
                    //手动添加数据:
                    mapper.deleteById(6);
                    //手动提交数据
                    sqlSession.commit();
               }finally{
                    sqlSession.close();}}

    3.3)测试成功!

    4)关于主键的值问题

    有时候需要用到主键值的问题,所以我们需要去学习这个知识点!

    4.1)EmployeeMapper.xml

        <!-- useGeneratedKeys="true"使用自增主键获取主键的值 -->
        <!-- keyProperty=""接受对应的主键值-->
        <insert id="addEmp" useGeneratedKeys="true"  keyProperty="id">
            insert into test(name,gender,email) values(#{name},#{gender},#{email})
        </insert>

    4.2)测试类

      @Test
        public void test2() throws IOException{
            //1.得到SqlSeesionFactory
            SqlSessionFactory sessionFactory = getSqlSessionFactory();
            //2.得到SqlSession
            SqlSession sqlSession = sessionFactory.openSession();
            try{
                EmployeeMapper mapper = (EmployeeMapper) sqlSession.getMapper(EmployeeMapper.class);
                //手动添加数据:
                Employee em = new Employee( "zhangsan", "boy", "zhangsan@qq.com");
                mapper.addEmp(em);
                //获取主键值的属性值进行打印
                System.out.println(em.getId());
                //手动提交数据
                sqlSession.commit();
            }finally{
                sqlSession.close();
            }
        }

    4.3)测试成功

    5)参数处理

    5.1)单个参数:MyBatis不会做任何处理

        #{参数名} : 取出参数值

    5.1.1)xml配置文件中

    <select id="getId" resultType="com.MrChengs.bean.Employee">
            select id,name,gender,email from test where id = #{idabc}
        </select>

    5.1.2)测试类

    @Test
        public void test() throws IOException {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);        
            SqlSessionFactory sqlSessionFactory = (SqlSessionFactory) new 
                    SqlSessionFactoryBuilder().build(inputStream);
            SqlSession session = sqlSessionFactory.openSession();
            try{
                Employee employee =  session.selectOne("getId",5);
                System.out.println(employee);
            }finally{
                session.close();
            }
        }

    5.1.3)测试是成功的!

    5.2)多个参数时

    MyBatis会做特殊的处理

    多个参数时封装成map

    key param1 ,param2......

    value 传入的值

    5.2.1)接口类中的查询代码设计如上所展示的

    public Employee getByIdAndNames(@Param("id")int id,@Param("name")String name);
    此时去掉@param:
    public Employee getByIdAndNames(int id,String name);

    5.2.2) xml文件

    <select id="getByIdAndNames" resultType="com.MrChengs.bean.Employee" >
            select id,name,gender,email from test where id = #{id} and name=#{name}
     </select>

    5.2.3)测试代码

      @Test
        public void test5() throws IOException{
                    SqlSessionFactory sessionFactory = getSqlSessionFactory();
                    SqlSession sqlSession = sessionFactory.openSession();
                    try{
                        EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
                        Employee employee = mapper.getByIdAndNames(5, "MrChengs");
                        System.out.println(employee);
                    }finally{
                        sqlSession.close();
                    }
        }

    5.2.4)此时会报错

    5.2.5)处理方案:是在EmployeeMapper.xml文件中修改的

    <!-- 同时使用两个参数进行数据库的查询 -->
        <!-- public Employee getByIdAndNames(int id,String name); -->
        <select id="getByIdAndNames" resultType="com.MrChengs.bean.Employee" >
            select id,name,gender,email from test where id = #{param1} 
          and name=#{param2}
    </select>

     此时得到正确的答案!

    5.3)多个查询字段时推荐使用的命名字段

    明确指定封装参数时的map和key @param("id")
    key:使用@param指定的值
    5.3.1)接口类中
    public Employee getByIdAndNames(@Param("id")int id,@Param("name")String name);

     5.3.2)xml文件中

    <select id="getByIdAndNames" resultType="com.MrChengs.bean.Employee" >
            select id,name,gender,email from test where id = #{id} and name=#{name}
    </select>
    测试类是5.2.3中的测试类,此时可以得到正确的结果!
     
     
    5.4)
    pojo:
    如果参数过多,正好是业务逻辑的数据模型,我们直接传入pojo刚刚好
    #{属性名} : 取出传入的pojo的属性值
    如果多个参数不是业务逻辑数据,没有对应pojo,为了方法我们也可以直接传入map
    #{key}就是取出对应的值
     
    5.4.1)接口类中的
      public Employee getByMap(Map<String,Object> map);

     5.4.2)xml文件中添加

    <select id="getByMap" resultType="com.MrChengs.bean.Employee" >
               select id,name,gender,email from test where id = #{id} and name=#{name}
    </select>

    5.4.3)测试类

      @Test
        public void test6() throws IOException{
                    SqlSessionFactory sessionFactory = getSqlSessionFactory();
                    SqlSession sqlSession = sessionFactory.openSession();
                    try{
                        EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
                        Map<String, Object> map = new HashMap<>();
                        map.put("id", 5);
                        map.put("name", "MrChengs"); 
                        Employee employee = mapper.getByMap(map);
                        System.out.println(employee);
                    }finally{
                        sqlSession.close();
                    }
        }

    运行时,可以正确输出结果!

    5.5)思考问题注意

    6).参数值的获取

       #{ }:可以获取map中的值,或者pojo对象中的属性值,只能是参数部分的 

      

           ${ }:可以获取map中的值,或者pojo对象中的属性值,还可是查询中的数据表

      

    区别:
            #{} :是以预定义的形式,将sql参数设置到sql语句中, PerparedStatement;可防止注入
           ¥{}:取出值直接放在sql语句中,会有安全问题
         大多情况下,建议使用#{}
         原生sql不支持占位符,我们就可以使用 ${} 进行取值
         比如分表:按照年份拆分
              select * from  2018_salary where xxx
     
     
    #{ } : 可以规定参数的规则
            javaType   jdbcType   mode(存储过程)   numericScale
            resultMao   typeHandler   jdbcTypeName   expression(未来准备支持的功能)
     
       jdbcType:通常需要在某种特定的条件下设置
                        在做数据为 null的情况下,有时候数据库可能不能识别mybatis对null的默认处理
                        比如Oracle(会报错)
                        jdbcType OTHER :会报错为无效的类型,因为mybatis对所有的null都映射为jdbc的OTHER类型,Oracle不认识,mysql可以识别
          
    处理方法:
    由于全局配置中:jdbcTypeForNull=OTHER,Oracle不支持
    解决两种方案
    A:

    B:在全局配置里面(Oracle&MySql都课识别)

        在mybatis-config.xml文件中
       <!-- 修改全局信息 --> 
      <settings> <setting name="jdbcTypeForNull" value="NULl"/> </settings>
     7).select-映射查询元素
    Select元素来定义查询元素操作
    属性如下:
    id:唯一的标识符
        ->用来引用这一条语句,需要和接口的方法名一致
    parameterType:参数类型
        ->可以不传,MyBatis会根据TypeHandler自动判断
    resultType:返回值类型
        ->别名或者全类名,如果返回值是集合,定义集合中的元素类型
            不可以和resultMap同时使用
     
    A.查询返回的是集合属性
    在接口类中:
        //返回集合
        public List<Employee> getByList(String name);

    在xml文件中:

         <!-- 返回值是集合 -->
         <!-- resultType:如果返回值是一个集合,要写集合中的元素类型 -->
         <!-- 模糊查询 -->
         <!-- 此时查询的类型还是Emoloyee类的 -->
         <select id="getByList" resultType="com.MrChengs.bean.Employee">
               select * from test where name like #{name}
         </select>

    实现类:

     @Test
         public void testList() throws IOException{
               SqlSessionFactory sessionFactory = getSqlSessionFactory();
               SqlSession sqlSession = sessionFactory.openSession();
               try{
                    EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
                    List<Employee> name = mapper.getByList("%Mr%");
                    for(Employee em : name){
                         System.out.println(em);
                    }
               }finally{
                    sqlSession.close();
               }
         }

    数据库&结果图

     B.把单个数据封装成map

    接口类:

     //返回一条记录的map, key是列名,值是对应的值
         public  Map<String,Object> getByIdReturnMap(int id);

    xml文件:

       <!-- 单个数据封装成map -->
         <!-- public  Map<String,Object> getByIdReturnMap(int id); -->
         <select id="getByIdReturnMap" resultType="map">
               select * from test where id=#{id}
         </select>

    实现类:

         @Test
         public void testgetByIdReturnMap() throws IOException{
               SqlSessionFactory sessionFactory = getSqlSessionFactory();
               SqlSession sqlSession = sessionFactory.openSession();
               try{
                    EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
                    Map<String,Object> map = mapper.getByIdReturnMap(5);
                    System.out.println(map);
               }finally{
                    sqlSession.close();
               }
         }

    结果:

    C.把多个结果封装成map

    接口类:

       //多个记录封装成一个map Map<int,Employee>,键是记录的主键,值是封装的值
         //告诉mybatis封装map使用那个属性作为map的key
         //若改为name,则name为key
         @MapKey("id")
         public Map<Integer,Employee> getByNameMap(String name);

     xml文件:

    1  <select id="getByNameMap" resultType="com.MrChengs.bean.Employee">
    2            select * from test where name like #{name}
    3      </select>

    实现类:

    @Test
         public void testByMapName() throws IOException{
               SqlSessionFactory sessionFactory = getSqlSessionFactory();
               SqlSession sqlSession = sessionFactory.openSession();
               try{
                    EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class)
                    Map<Integer,Employee> ems = mapper.getByNameMap("%M%");
                    System.out.println(ems);
               }finally{
                    sqlSession.close();
               }
         }

    结果:

     D).resultMap自定义查询

     
    此时由于EmployeeMapper.java和EmployeeMapper.xml文件的测试内容已经相应的比较多
     
    此时创建新的文件 ,均在原来文件的相同路径下!
     
    EmployeeMapperTwo.java接口类
    EmployeeMapperTwo.xml映射文件

    在EmployeeMapperTwo.java接口类:

         //resultMap自定义结果映射
         public Employee getById(Integer id);

    在全局配置文件中进行引入:mybatis-config.xml(博主当时没引入,一致忽略这个问题,手动查询问题好久)

         <mappers>
               <mapper resource="EmployeeMapper.xml" />
               <mapper resource="EmployeeMapperTwo.xml"/>
         </mappers>
    EmployeeMapperTwo.xml映射文件中:
    (所有的相关注释都已经写好)
         <!-- 自定义某个javaBean的封装规则 -->
         <!-- type:是全类名,也可以是起的别名 -->
         <!-- id:唯一性便于引用 -->
         <resultMap type="com.MrChengs.bean.Employee" id="MyEmp">
                    <!-- 指定主键列的封装规则 -->
                    <!-- id:定义主键会底层优化 -->
                    <!-- column:指定那一列 -->
                    <!-- property:指定对应的JavaBean属性 -->
               <id column="id" property="id"/>
                    <!-- 定义普通列封装规则 -->
               <result column="name" property="name"/>
                    <!-- 其他不指定的列会自动封装 -->
                    <!-- 但是建议所有的都写出来,便于后期的维护和检查 -->
                    <result column="gender" property="gender"/>
                    <result column="email" property="email"/>
         </resultMap>
         <!-- public Employee getById(Integer id); -->
         <!-- resultMap自定义自定义结果映射 -->
         <!-- 使用resultMap则不能使用resultType两者只能二选一 -->
         <select id="getById" resultMap="MyEmp">
               select * from test where id=#{id}
         </select>

    测试类中:

    //resultMap自定义结果映射
         //public Employee getById(Integer id);
         @Test
         public void testResultMap() throws IOException{
               SqlSessionFactory sessionFactory = getSqlSessionFactory();
               SqlSession sqlSession = sessionFactory.openSession();
               try{
                    EmployeeMapperTwo mapper1 = sqlSession.getMapper(EmployeeMapperTwo.class);
                    
                    Employee emp = mapper1.getById(5);
                    System.out.println(emp);
               }finally{
                    sqlSession.close();
               }
         }

    得到查询的结果:

     E).查询时的外键约束
     
    数据库的完善:
    test表:添加新的键d_id
    新建表tbl_dept:两个件id和dept_name
    两个表建立关联关系(外键
    alter table user add foreign key(d_id) references tbl_dept(id);

    在数据库中查询两个表

    SELECT * FROM test e,tbl_dept d
    where e.d_id=d.id AND e.id=5

    方法一:

    数据库查询进一步优化方案:

    SELECT e.id id,e.name,e.gender gender,e.email email,e.d_id d_id,d.dept_name dept 
    FROM test e,tbl_dept d 
    where e.d_id=d.id AND e.id=5

    此时此刻我们开始上代码:
    接口类中:
        //场景一查询Employee同时查询Deapment
         public Employee getEmpAndDept(int id);

    xml文件中:

         <!-- 查询员工对应的部门信息 -->
         <!-- public Employee getEmpAndDept(Integer id); -->
         <!-- 结果集封装 -->
         <resultMap type="com.MrChengs.bean.Employee" id="MyEmpMangTable">
               <id column="id" property="id"/>
               <result column="name" property="name"/>
               <result column="gender" property="gender"/>
               <result column="email" property="email"/>
                    <!-- 级联属性的赋值方式!!! -->
               <result column="d_id" property="dept.id"/>
                    <!-- 级联属性的赋值方式!!! -->
               <result column="dept_name" property="dept.departName"/>
         
         </resultMap>
         <select id="getEmpAndDept" resultMap="MyEmpMangTable">
               SELECT e.id id,e.name name,e.gender gender,e.email                
           email,e.d_id d_id,d.dept_name dept_name FROM test e,tbl_dept d where e.d_id
    =d.id AND e.id=#{id} </select>

    实现的方法:

     //场景一:查询Employee的同时查询员工对应的部门
         //    Employee ---.> Department
         //一个员工与之对应的部门信息
         @Test
         public void testAndDept() throws IOException{
               SqlSessionFactory sessionFactory = getSqlSessionFactory();
               SqlSession sqlSession = sessionFactory.openSession();
               try{
                    EmployeeMapperTwo mapper = sqlSession.getMapper(EmployeeMapperTwo.class);
                    
                    Employee emp = mapper.getEmpAndDept(5);
                    System.out.println(emp);
                    System.out.println(emp.getDept());
               }finally{
                    sqlSession.close();
               }
         }

    查询结果:(可以同上上面的数据库进行对比)

     
    方法二:
    在xml文件中:
    <!-- 不使用级联属性 -->
         <resultMap type="com.MrChengs.bean.Employee" id="MyEmpMangTable1">
               <id column="id" property="id"/>
               <result column="name" property="name"/>
               <result column="gender" property="gender"/>
               <result column="email" property="email"/>
               
                    <!-- association:联合的意思,可以联合JavaBean对象 -->
                    <!-- property="dept":指定那个是联合的对象 -->
                    <!-- javaType="com.MrChengs.bean.Department": 指定这个属性对象的类型 -->
               <association property="dept" javaType="com.MrChengs.bean.Department">
                         <!--此时再次类似resultMap标签 -->
                         <!-- 此时的对象是Department -->
                    <id column="d_id" property="id"/>
                    <result column="dept_name" property="departName"/>
               </association>
         </resultMap>
         
         <select id="getEmpAndDept" resultMap="MyEmpMangTable1">
               SELECT e.id id,e.name name,e.gender gender,e.email email,
          e.d_id d_id,d.dept_name dept_name FROM test e,tbl_dept d where e.d_id
    =d.id AND e.id=#{id} </select>

    其他方法不变,依然可以查出结果!!!!

     F)association的分布实施方法(important)
     1.首先创建一个接口和一个xml映射文件,具体看图
     
    2.新添加文件的代码:
    DepartmentMapper.java
    public interface DepartmentMapper {
         public Department getDeptById(int id);
    }

    DepartmentMapper.xml

    <mapper namespace="com.MrChengs.dao.DepartmentMapper">     
        <!-- public Department getDeptById(int id); -->
         <select id="getDeptById" resultType="com.MrChengs.bean.Department">
               select id,dept_name departName from tbl_dept where id=#{id}
         </select>
    </mapper>

    解释:这两个文件其实是一个简单查询的过程

     3.在EmployeeMapper.xml文件zhong
     
    <!-- association:可以进行封闭查询 -->
         <!-- public Employee getEmpAndDeptByStep(int id); -->
         <resultMap type="com.MrChengs.bean.Employee" id="MyEmpByStep">
               <!-- 1.先查出员工信息 -->
               <id column="id" property="id"/>
               <result column="name" property="name"/>
               <result column="gender" property="gender"/>
               <result column="email" property="email"/>
               
               <!-- association 定义关联关系的封装对象 -->
               <!-- select: 调用当前属性指定的方法查出结果-->
               <!-- column:指定将那个值传递给这个方法 -->
               <association property="dept" 
               select="com.MrChengs.dao.DepartmentMapper.getDeptById"
                <!-- 传值  -->
               column="d_id"></association>
         </resultMap>
         
         
         <select id="getEmpAndDeptByStep" resultMap="MyEmpByStep">
               select * from test where id=#{id}
         </select>

    3.测试类:

    //分布查询
         @Test
         public void testAndDeptByStep() throws IOException{
               SqlSessionFactory sessionFactory = getSqlSessionFactory();
               SqlSession sqlSession = sessionFactory.openSession();
               try{
                    EmployeeMapperTwo mapper = sqlSession.getMapper(EmployeeMapperTwo.class);
                    
                    Employee emp = mapper.getEmpAndDept(5);
                    System.out.println(emp);
                    System.out.println(emp.getDept());
               }finally{
                    sqlSession.close();
               }
         }
    然后得到结果!!!
     
     
     
    分布查询相当于:
    1.select * from test where id = 5
    2.select * from tbl_dept where id = 1;
    两个步骤分开进行实现的。
     
     
     G.延迟加载
    分布查询还可以使用延迟加载
    我们每次查询EMployee时,都将部门信息一起查询出来,
    那么我们希望在使用部门信息再去查询
    此时可以节省时间资源
    在分段查询的时候,加上两个配置,在使用的时候进行加载,
    不使用的时候,不进行加载,能大大的节约查询时间
    全局配置文件:
    <settings>
               <!-- 显示的指定我们需要更改的配置信息,防止版本更新带来的问题 -->
               <setting name="lazyLoadingEnabled" value="true"/>
               <setting name="aggressiveLazyLoading" value="false"/>
    </settings>
    其余的代码不变可以进行去尝试那个测试类的代码,不适用Dept和使用Dept的方法的区别:
    注释掉使用Department类的时候,此时我们时简单的查询Employee
    使用Department类的时候,此时两个都能查询出来!
     
    H.查询部门的同时查询员工
    SELECT    d.id,d.dept_name dept,e.id id,e.name,e.gender gender,e.email email,e.d_id d_id 
    FROM test e,tbl_dept d where e.d_id
    =d.id AND d.id=1;

    在Department类中:

    在DepartmentMapper.xml文件中:

    <!-- public Department getDeptByIds(int id); -->
         <!-- 查询部门同时查看出部门里面的员工 -->
         <resultMap type="com.MrChengs.bean.Department" id="employees">
               <id column="id" property="id"/>
               <result column="dept" property="departName"/>
               
               <!-- collection:定义集合对象 -->
               <!-- ofType:指定测试集合的类型 -->
               <!-- property:定义对象的原型属性,即是我们在类中的定义方法 -->
               <collection property="employees" ofType="com.MrChengs.bean.Employee">
                    <!-- 定义集合封装规则 -->
                    <id column="id" property="id"/>
                    <result column="name" property="name"/>
                    <result column="gender" property="gender"/>
                    <result column="email" property="email"/>
               </collection>
         </resultMap>
         
         <select id="getDeptByIds" resultMap="employees">
               SELECT d.id id,d.dept_name dept,
               e.id id,e.name name,e.gender gender,e.email email
                FROM test e,tbl_dept d
                where e.d_id=d.id AND d.id=#{id}
         </select>
     
    在DepartmentMapper接口
         //查询部门时查员工
         public Department getDeptByIds(int id);

    测试类中:

    //场景二:
         //在查询部门信息的时候,查询员工信息
         //分布查询
               @Test
               public void testEmps() throws IOException{
                    SqlSessionFactory sessionFactory = getSqlSessionFactory();
                    SqlSession sqlSession = sessionFactory.openSession();
                    try{
                         DepartmentMapper mapper = sqlSession.getMapper(DepartmentMapper.class);
                         
                         Department dept = mapper.getDeptByIds(1);
                         System.out.println(dept);
                         System.out.println(dept.getEmployees());
                    }finally{
                         sqlSession.close();
                    }
               }

    相当于一个嵌套查询

     
    //collection分布查询
    DepartmentMapper.java
    //collection分布查询
         public Department getDeptByIdsByStep(int id);

    EmployeeMapperTwo.java

         //collection分布实现
         public List<Employee> getEmpByStep(int id);
     
    EmployeeMapper.xml
    <!-- collection分布查询 -->
         <!-- public List<Employee> getEmpByStep(int id); -->
         <select id="getEmpByStep" resultType="com.MrChengs.bean.Employee">
               select * from test where d_id=#{d_id}
         </select>

    DepartmentMapper.xml

        <!-- 分布实现 -->
         <!-- public Department getDeptByIdsByStep(int id); -->
         <!-- collection分布实现 -->
         
         <resultMap type="com.MrChengs.bean.Department" id="MyStept">
               <id column="id" property="id"/>
               <result column="departName" property="departName"/>
               
               <collection property="employees" select="com.MrChengs.dao.EmployeeMapperTwo.getEmpByStep" column="id">
               </collection>
               
         </resultMap>
         <select id="getDeptByIdsByStep" resultMap="MyStept">
                    select id,dept_name departName from tbl_dept where id=#{id}
         </select>

    实现类

    //collection 分布实现
               @Test
               public void testEmpsStep() throws IOException{
                    SqlSessionFactory sessionFactory = getSqlSessionFactory();
                    SqlSession sqlSession = sessionFactory.openSession();
                    try{
                         DepartmentMapper mapper = sqlSession.getMapper(DepartmentMapper.class);
                         
                         Department dept = mapper.getDeptByIdsByStep(1);
                         System.out.println(dept);
                         System.out.println(dept.getEmployees());
                    }finally{
                         sqlSession.close();
                    }
               }
     
    讲解:
    collection中:<discriminator javaType=""></discriminator>
    鉴别器:mybatis可以使用此属性判别某列的值,然后根据某列的值封装行为
  • 相关阅读:
    oracle 导入数据时提示只有 DBA 才能导入由其他 DBA 导出的文件
    oracle 常用语句
    android udp 无法收到数据 (模拟器中)
    android DatagramSocket send 发送数据出错
    AtCoder ABC 128E Roadwork
    AtCoder ABC 128D equeue
    AtCoder ABC 127F Absolute Minima
    AtCoder ABC 127E Cell Distance
    CodeForces 1166E The LCMs Must be Large
    CodeForces 1166D Cute Sequences
  • 原文地址:https://www.cnblogs.com/Mrchengs/p/9721608.html
Copyright © 2011-2022 走看看