【MyBatis】映射文件示例

本文以实例说明Mapper文件的标签的使用。

配置文件在【MyBatis】配置文件示例

DAO文件

DepartmentMapper.java

package com.atguigu.mybatis.dao;

import com.atguigu.mybatis.bean.Department;

public interface DepartmentMapper {

    public Department getDeptById(Integer id);

    public Department getDeptByIdPlus(Integer id);

    public Department getDeptByIdStep(Integer id);
}

EmployeeMapper.java

package com.atguigu.mybatis.dao;

import java.util.List;
import java.util.Map;

import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Param;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapper {

    //多条记录封装一个map：Map<Integer,Employee>:键是这条记录的主键，值是记录封装后的javaBean
    //@MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
    @MapKey("lastName")
    public Map<String, Employee> getEmpByLastNameLikeReturnMap(String lastName);

    //返回一条记录的map；key就是列名，值就是对应的值
    public Map<String, Object> getEmpByIdReturnMap(Integer id);

    public List<Employee> getEmpsByLastNameLike(String lastName);

    public Employee getEmpByMap(Map<String, Object> map);

    public Employee getEmpByIdAndLastName(@Param("id")Integer id,@Param("lastName")String lastName);

    public Employee getEmpById(Integer id);

    public Long addEmp(Employee employee);

    public boolean updateEmp(Employee employee);

    public void deleteEmpById(Integer id);

}

EmployeeMapperPlus.java

package com.atguigu.mybatis.dao;

import java.util.List;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapperPlus {

    public Employee getEmpById(Integer id);

    public Employee getEmpAndDept(Integer id);

    public Employee getEmpByIdStep(Integer id);

    public List<Employee> getEmpsByDeptId(Integer deptId);

}

映射文件

DepartmentMapper.xml 结果集示例，分段查询

<?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">
<mapper namespace="com.atguigu.mybatis.dao.DepartmentMapper">
    <!--public Department getDeptById(Integer id);  -->
    <select id="getDeptById" resultType="com.atguigu.mybatis.bean.Department">
        select id,dept_name departmentName from tbl_dept where id=#{id}
    </select>

    <!--
    public class Department {
            private Integer id;
            private String departmentName;
            private List<Employee> emps;
      did  dept_name  ||  eid  last_name  email   gender
     -->

    <!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则  -->
    <resultMap type="com.atguigu.mybatis.bean.Department" id="MyDept">
        <id column="did" property="id"/>
        <result column="dept_name" property="departmentName"/>
        <!--
            collection定义关联集合类型的属性的封装规则
            ofType:指定集合里面元素的类型
        -->
        <collection property="emps" ofType="com.atguigu.mybatis.bean.Employee">
            <!-- 定义这个集合中元素的封装规则 -->
            <id column="eid" property="id"/>
            <result column="last_name" property="lastName"/>
            <result column="email" property="email"/>
            <result column="gender" property="gender"/>
        </collection>
    </resultMap>
    <!-- public Department getDeptByIdPlus(Integer id); -->
    <select id="getDeptByIdPlus" resultMap="MyDept">
        SELECT d.id did,d.dept_name dept_name,
                e.id eid,e.last_name last_name,e.email email,e.gender gender
        FROM tbl_dept d
        LEFT JOIN tbl_employee e
        ON d.id=e.d_id
        WHERE d.id=#{id}
    </select>

    <!-- collection：分段查询 -->
    <resultMap type="com.atguigu.mybatis.bean.Department" id="MyDeptStep">
        <id column="id" property="id"/>
        <id column="dept_name" property="departmentName"/>
        <collection property="emps"
            select="com.atguigu.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
            column="{deptId=id}" fetchType="lazy"></collection>
    </resultMap>
    <!-- public Department getDeptByIdStep(Integer id); -->
    <select id="getDeptByIdStep" resultMap="MyDeptStep">
        select id,dept_name from tbl_dept where id=#{id}
    </select>

    <!-- 扩展：多列的值传递过去：
            将多列的值封装map传递；
            column="{key1=column1,key2=column2}"
        fetchType="lazy"：表示使用延迟加载；
                - lazy：延迟
                - eager：立即
     -->
</mapper>

EmployeeMapper.xml MySql和Oracle获取主键的方式

<?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">
<mapper namespace="com.atguigu.mybatis.dao.EmployeeMapper">
<!--
namespace:名称空间;指定为接口的全类名
id：唯一标识
resultType：返回值类型
#{id}：从传递过来的参数中取出id值
public Employee getEmpById(Integer id);
 -->

    <!--public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName);  -->
    <select id="getEmpByLastNameLikeReturnMap" resultType="com.atguigu.mybatis.bean.Employee">
        select * from tbl_employee where last_name like #{lastName}
    </select>

    <!--public Map<String, Object> getEmpByIdReturnMap(Integer id);  -->
    <select id="getEmpByIdReturnMap" resultType="map">
        select * from tbl_employee where id=#{id}
    </select>

    <!-- public List<Employee> getEmpsByLastNameLike(String lastName); -->
    <!--resultType：如果返回的是一个集合，要写集合中元素的类型  -->
    <select id="getEmpsByLastNameLike" resultType="com.atguigu.mybatis.bean.Employee">
        select * from tbl_employee where last_name like #{lastName}
    </select>

    <!-- public Employee getEmpByMap(Map<String, Object> map); -->
    <select id="getEmpByMap" resultType="com.atguigu.mybatis.bean.Employee">
        select * from ${tableName} where id=${id} and last_name=#{lastName}
    </select>

    <!--  public Employee getEmpByIdAndLastName(Integer id,String lastName);-->
    <select id="getEmpByIdAndLastName" resultType="com.atguigu.mybatis.bean.Employee">
        select * from tbl_employee where id = #{id} and last_name=#{lastName}
    </select>

    <select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee">
        select * from tbl_employee where id = #{id}
    </select>
    <select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee"
        databaseId="mysql">
        select * from tbl_employee where id = #{id}
    </select>
    <select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee"
        databaseId="oracle">
        select EMPLOYEE_ID id,LAST_NAME lastName,EMAIL email
        from employees where EMPLOYEE_ID=#{id}
    </select>

    <!-- public void addEmp(Employee employee); -->
    <!-- parameterType：参数类型，可以省略，
    获取自增主键的值：
        mysql支持自增主键，自增主键值的获取，mybatis也是利用statement.getGenreatedKeys()；
        useGeneratedKeys="true"；使用自增主键获取主键值策略
        keyProperty；指定对应的主键属性，也就是mybatis获取到主键值以后，将这个值封装给javaBean的哪个属性
    -->
    <insert id="addEmp" parameterType="com.atguigu.mybatis.bean.Employee"
        useGeneratedKeys="true" keyProperty="id" databaseId="mysql">
        insert into tbl_employee(last_name,email,gender)
        values(#{lastName},#{email},#{gender})
    </insert>

    <!--
    获取非自增主键的值：
        Oracle不支持自增；Oracle使用序列来模拟自增；
        每次插入的数据的主键是从序列中拿到的值；如何获取到这个值；
     -->
    <insert id="addEmp" databaseId="oracle">
        <!--
        keyProperty:查出的主键值封装给javaBean的哪个属性
        order="BEFORE":当前sql在插入sql之前运行
               AFTER：当前sql在插入sql之后运行
        resultType:查出的数据的返回值类型

        BEFORE运行顺序：
            先运行selectKey查询id的sql；查出id值封装给javaBean的id属性
            在运行插入的sql；就可以取出id属性对应的值
        AFTER运行顺序：
            先运行插入的sql（从序列中取出新值作为id）；
            再运行selectKey查询id的sql；
         -->
        <selectKey keyProperty="id" order="BEFORE" resultType="Integer">
            <!-- 编写查询主键的sql语句 -->
            <!-- BEFORE-->
            select EMPLOYEES_SEQ.nextval from dual
            <!-- AFTER：
             select EMPLOYEES_SEQ.currval from dual -->
        </selectKey>

        <!-- 插入时的主键是从序列中拿到的 -->
        <!-- BEFORE:-->
        insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL)
        values(#{id},#{lastName},#{email<!-- ,jdbcType=NULL -->})
        <!-- AFTER：
        insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL)
        values(employees_seq.nextval,#{lastName},#{email}) -->
    </insert>

    <!-- public void updateEmp(Employee employee);  -->
    <update id="updateEmp">
        update tbl_employee
        set last_name=#{lastName},email=#{email},gender=#{gender}
        where id=#{id}
    </update>

    <!-- public void deleteEmpById(Integer id); -->
    <delete id="deleteEmpById">
        delete from tbl_employee where id=#{id}
    </delete>

</mapper>

EmployeeMapperPlus.xml 结果集的封装：一对一，一对多，以及延迟加载和解释器的使用

<?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">
<mapper namespace="com.atguigu.mybatis.dao.EmployeeMapperPlus">

    <!--自定义某个javaBean的封装规则
    type：自定义规则的Java类型
    id:唯一id方便引用
      -->
    <resultMap type="com.atguigu.mybatis.bean.Employee" id="MySimpleEmp">
        <!--指定主键列的封装规则
        id定义主键会底层有优化；
        column：指定哪一列
        property：指定对应的javaBean属性
          -->
        <id column="id" property="id"/>
        <!-- 定义普通列封装规则 -->
        <result column="last_name" property="lastName"/>
        <!-- 其他不指定的列会自动封装：我们只要写resultMap就把全部的映射规则都写上。 -->
        <result column="email" property="email"/>
        <result column="gender" property="gender"/>
    </resultMap>

    <!-- resultMap:自定义结果集映射规则；  -->
    <!-- public Employee getEmpById(Integer id); -->
    <select id="getEmpById"  resultMap="MySimpleEmp">
        select * from tbl_employee where id=#{id}
    </select>

    <!--
    场景一：
        查询Employee的同时查询员工对应的部门
        Employee===Department
        一个员工有与之对应的部门信息；
        id  last_name  gender    d_id     did  dept_name (private Department dept;)
     -->

    <!--
        联合查询：级联属性封装结果集
      -->
    <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="gender" property="gender"/>
        <result column="did" property="dept.id"/>
        <result column="dept_name" property="dept.departmentName"/>
    </resultMap>

    <!--
        使用association定义关联的单个对象的封装规则；
     -->
    <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp2">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="gender" property="gender"/>

        <!--  association可以指定联合的javaBean对象
        property="dept"：指定哪个属性是联合的对象
        javaType:指定这个属性对象的类型[不能省略]
        -->
        <association property="dept" javaType="com.atguigu.mybatis.bean.Department">
            <id column="did" property="id"/>
            <result column="dept_name" property="departmentName"/>
        </association>
    </resultMap>
    <!--  public Employee getEmpAndDept(Integer id);-->
    <select id="getEmpAndDept" resultMap="MyDifEmp">
        SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
        d.id did,d.dept_name dept_name FROM tbl_employee e,tbl_dept d
        WHERE e.d_id=d.id AND e.id=#{id}
    </select>

    <!-- 使用association进行分步查询：
        1、先按照员工id查询员工信息
        2、根据查询员工信息中的d_id值去部门表查出部门信息
        3、部门设置到员工中；
     -->

     <!--  id  last_name  email   gender    d_id   -->
     <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpByStep">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="email" property="email"/>
        <result column="gender" property="gender"/>
        <!-- association定义关联对象的封装规则
            select:表明当前属性是调用select指定的方法查出的结果
            column:指定将哪一列的值传给这个方法

            流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性
         -->
        <association property="dept"
            select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
            column="d_id">
        </association>
     </resultMap>
     <!--  public Employee getEmpByIdStep(Integer id);-->
     <select id="getEmpByIdStep" resultMap="MyEmpByStep">
        select * from tbl_employee where id=#{id}
        <if test="_parameter!=null">
            and 1=1
        </if>
     </select>

     <!-- 可以使用延迟加载（懒加载）；(按需加载)
        Employee==>Dept：
            我们每次查询Employee对象的时候，都将一起查询出来。
            部门信息在我们使用的时候再去查询；
            分段查询的基础之上加上两个配置：
      -->
    <!-- ==================association============================ -->

    <!--
    场景二：
        查询部门的时候将部门对应的所有员工信息也查询出来：注释在DepartmentMapper.xml中
     -->
    <!-- public List<Employee> getEmpsByDeptId(Integer deptId); -->
    <select id="getEmpsByDeptId" resultType="com.atguigu.mybatis.bean.Employee">
        select * from tbl_employee where d_id=#{deptId}
    </select>

    <!-- =======================鉴别器============================ -->
    <!-- <discriminator javaType=""></discriminator>
        鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为
        封装Employee：
            如果查出的是女生：就把部门信息查询出来，否则不查询；
            如果是男生，把last_name这一列的值赋值给email;
     -->
     <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpDis">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="email" property="email"/>
        <result column="gender" property="gender"/>
        <!--
            column：指定判定的列名
            javaType：列值对应的java类型  -->
        <discriminator javaType="string" column="gender">
            <!--女生  resultType:指定封装的结果类型；不能缺少。/resultMap-->
            <case value="0" resultType="com.atguigu.mybatis.bean.Employee">
                <association property="dept"
                    select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
                    column="d_id">
                </association>
            </case>
            <!--男生 ;如果是男生，把last_name这一列的值赋值给email; -->
            <case value="1" resultType="com.atguigu.mybatis.bean.Employee">
                <id column="id" property="id"/>
                <result column="last_name" property="lastName"/>
                <result column="last_name" property="email"/>
                <result column="gender" property="gender"/>
            </case>
        </discriminator>
     </resultMap>
</mapper>

Bean

Employee.java

package com.atguigu.mybatis.bean;

import java.io.Serializable;

import org.apache.ibatis.type.Alias;

@Alias("emp")
public class Employee implements Serializable{

    private static final long serialVersionUID = 1L;
    private Integer id;
    private String lastName;
    private String email;
    private String gender;
    private Department dept;

    public Employee() {
        super();
    }

    public Employee(Integer id, String lastName, String email, String gender,
            Department dept) {
        super();
        this.id = id;
        this.lastName = lastName;
        this.email = email;
        this.gender = gender;
        this.dept = dept;
    }

    public Employee(Integer id, String lastName, String email, String gender) {
        super();
        this.id = id;
        this.lastName = lastName;
        this.email = email;
        this.gender = gender;
    }

    public Department getDept() {
        return dept;
    }

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

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    @Override
    public String toString() {
        return "Employee [id=" + id + ", lastName=" + lastName + ", email="
                + email + ", gender=" + gender + "]";
    }

}

Department.java

package com.atguigu.mybatis.bean;

import java.io.Serializable;
import java.util.List;

public class Department implements Serializable{

    private static final long serialVersionUID = 1L;
    private Integer id;
    private String departmentName;
    private List<Employee> emps;

    public Department(Integer id) {
        super();
        this.id = id;
    }
    public Department() {
        super();
        // TODO Auto-generated constructor stub
    }
    public List<Employee> getEmps() {
        return emps;
    }
    public void setEmps(List<Employee> emps) {
        this.emps = emps;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getDepartmentName() {
        return departmentName;
    }
    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }
    @Override
    public String toString() {
        return "Department [id=" + id + ", departmentName=" + departmentName
                + "]";
    }
}

测试类

MyBatisTest.java

package com.atguigu.mybatis.test;

import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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.atguigu.mybatis.bean.Department;
import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.dao.DepartmentMapper;
import com.atguigu.mybatis.dao.EmployeeMapper;
import com.atguigu.mybatis.dao.EmployeeMapperAnnotation;
import com.atguigu.mybatis.dao.EmployeeMapperPlus;

/**
 * 1、接口式编程
 *  原生：     Dao     ====>  DaoImpl
 *  mybatis：    Mapper  ====>  xxMapper.xml
 *
 * 2、SqlSession代表和数据库的一次会话；用完必须关闭；
 * 3、SqlSession和connection一样她都是非线程安全。每次使用都应该去获取新的对象。
 * 4、mapper接口没有实现类，但是mybatis会为这个接口生成一个代理对象。
 *      （将接口和xml进行绑定）
 *      EmployeeMapper empMapper =  sqlSession.getMapper(EmployeeMapper.class);
 * 5、两个重要的配置文件：
 *      mybatis的全局配置文件：包含数据库连接池信息，事务管理器信息等...系统运行环境信息
 *      sql映射文件：保存了每一个sql语句的映射信息：
 *                  将sql抽取出来。
 *
 *
 * @author lfy
 *
 */
public class MyBatisTest {

    public SqlSessionFactory getSqlSessionFactory() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        return new SqlSessionFactoryBuilder().build(inputStream);
    }

    /**
     * 1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象 有数据源一些运行环境信息
     * 2、sql映射文件；配置了每一个sql，以及sql的封装规则等。
     * 3、将sql映射文件注册在全局配置文件中
     * 4、写代码：
     *      1）、根据全局配置文件得到SqlSessionFactory；
     *      2）、使用sqlSession工厂，获取到sqlSession对象使用他来执行增删改查
     *          一个sqlSession就是代表和数据库的一次会话，用完关闭
     *      3）、使用sql的唯一标志来告诉MyBatis执行哪个sql。sql都是保存在sql映射文件中的。
     *
     * @throws IOException
     */
    @Test
    public void test() throws IOException {

        // 2、获取sqlSession实例，能直接执行已经映射的sql语句
        // sql的唯一标识：statement Unique identifier matching the statement to use.
        // 执行sql要用的参数：parameter A parameter object to pass to the statement.
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

        SqlSession openSession = sqlSessionFactory.openSession();
        try {
            Employee employee = openSession.selectOne(
                    "com.atguigu.mybatis.EmployeeMapper.selectEmp", 1);
            System.out.println(employee);
        } finally {
            openSession.close();
        }

    }

    @Test
    public void test01() throws IOException {
        // 1、获取sqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        // 2、获取sqlSession对象
        SqlSession openSession = sqlSessionFactory.openSession();
        try {
            // 3、获取接口的实现类对象
            //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            Employee employee = mapper.getEmpById(1);
            System.out.println(mapper.getClass());
            System.out.println(employee);
        } finally {
            openSession.close();
        }

    }

    @Test
    public void test02() throws IOException{
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession openSession = sqlSessionFactory.openSession();
        try{
            EmployeeMapperAnnotation mapper = openSession.getMapper(EmployeeMapperAnnotation.class);
            Employee empById = mapper.getEmpById(1);
            System.out.println(empById);
        }finally{
            openSession.close();
        }
    }

    /**
     * 测试增删改
     * 1、mybatis允许增删改直接定义以下类型返回值
     *      Integer、Long、Boolean、void
     * 2、我们需要手动提交数据
     *      sqlSessionFactory.openSession();===》手动提交
     *      sqlSessionFactory.openSession(true);===》自动提交
     * @throws IOException
     */
    @Test
    public void test03() throws IOException{

        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        //1、获取到的SqlSession不会自动提交数据
        SqlSession openSession = sqlSessionFactory.openSession();

        try{
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            //测试添加
            Employee employee = new Employee(null, "jerry4",null, "1");
            mapper.addEmp(employee);
            System.out.println(employee.getId());

            //测试修改
            //Employee employee = new Employee(1, "Tom", "[email protected]", "0");
            //boolean updateEmp = mapper.updateEmp(employee);
            //System.out.println(updateEmp);
            //测试删除
            //mapper.deleteEmpById(2);
            //2、手动提交数据
            openSession.commit();
        }finally{
            openSession.close();
        }

    }

    @Test
    public void test04() throws IOException{

        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        //1、获取到的SqlSession不会自动提交数据
        SqlSession openSession = sqlSessionFactory.openSession();

        try{
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            //Employee employee = mapper.getEmpByIdAndLastName(1, "tom");
            Map<String, Object> map = new HashMap<>();
            map.put("id", 2);
            map.put("lastName", "Tom");
            map.put("tableName", "tbl_employee");
            Employee employee = mapper.getEmpByMap(map);

            System.out.println(employee);

            /*List<Employee> like = mapper.getEmpsByLastNameLike("%e%");
            for (Employee employee : like) {
                System.out.println(employee);
            }*/

            /*Map<String, Object> map = mapper.getEmpByIdReturnMap(1);
            System.out.println(map);*/
            /*Map<String, Employee> map = mapper.getEmpByLastNameLikeReturnMap("%r%");
            System.out.println(map);*/

        }finally{
            openSession.close();
        }
    }

    @Test
    public void test05() throws IOException{
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession openSession = sqlSessionFactory.openSession();
        try{
            EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
            /*Employee empById = mapper.getEmpById(1);
            System.out.println(empById);*/
            /*Employee empAndDept = mapper.getEmpAndDept(1);
            System.out.println(empAndDept);
            System.out.println(empAndDept.getDept());*/
            Employee employee = mapper.getEmpByIdStep(3);
            System.out.println(employee);
            //System.out.println(employee.getDept());
            System.out.println(employee.getDept());
        }finally{
            openSession.close();
        }

    }

    @Test
    public void test06() throws IOException{
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession openSession = sqlSessionFactory.openSession();

        try{
            DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
            /*Department department = mapper.getDeptByIdPlus(1);
            System.out.println(department);
            System.out.println(department.getEmps());*/
            Department deptByIdStep = mapper.getDeptByIdStep(1);
            System.out.println(deptByIdStep.getDepartmentName());
            System.out.println(deptByIdStep.getEmps());
        }finally{
            openSession.close();
        }
    }   

}

原文地址：https://www.cnblogs.com/z00377750/p/12397556.html

时间： 2024-10-29 05:02:37

【MyBatis】映射文件示例的相关文章

6.Mybatis 映射文件标签详解

编写的测试代码在下面,没有jar包(上传的大小限制啦) 1.1     Mybatis映射文件(核心) 1.1.1 输入映射 1.1.1.1  ParameterType 指定输入参数的java类型,可以使用别名或者类的全限定名.它可以接收简单类型.POJO.HashMap. 1.1.1.1.1      传递简单类型 参考需求:根据用户ID查询用户信息. 1.1.1.1.2      传递POJO对象 1.1.1.1.2.1     需求 根据用户性别和用户名称来查询用户信息 1.1.1.1.

如何在mybatis映射文件里面使用java方法

在mybatis的映射xml文件调用java类的方法: 1. SELECT * FROM EC_CORE_USER WHERE (user_name=#{userName} or mail =#{userName} or mobile_phone = '${@[email protected](userName)}') and  user_password=#{userPassword} 入上面代码所示.此处应注意,方法必须为静态方法. 2.获取类里面的常量: r.czmc='${@[email

20180601_Eclipse自动生成mybatis映射文件

Eclipse自动生成mybatis映射文件 1.安装MyBatis Generator插件 打开Eclipse,找到Help--Eclipse Marketplace. 搜索MyBatis Generator,Install安装即可. 2.新建generatorConfig.xml文件,填写配置信息 generatorConfig.xml 1 <?xml version="1.0" encoding="UTF-8"?> 2 <!DOCTYPE g

Mybatis映射文件sql语句学习心得

现有数据库表: CREATE TABLE `dept_p` ( `DEPT_ID` varchar(40) NOT NULL, `DEPT_NAME` varchar(50) DEFAULT NULL, `PARENT_ID` varchar(40) DEFAULT NULL COMMENT '自关联,多对一', `STATE` int(11) DEFAULT NULL COMMENT '1启用0停用', `CREATE_BY` varchar(40) DEFAULT NULL COMMENT

mybatis映射文件遇到的小问题

mybatis的映射文件插入操作时: 如果对应的属性是String类型的,那么一定要做空串的判断. 比如注册的时候,如果需要向数据库中插入一条记录时,对应的字段没有给他赋值,这个String类型的值传到后台的时候值是空的字符串. sql语句一定要写成这样 <if test="associationName != null and associationName !='' "> association_name, </if> 以后有插入操作时,String类型的属

mybatis映射文件select_resultMap_关联查询_collection定义关联集合

知识点:查询一个实体类,并查出这个类下面的集合 Employee.java实体类 package com.hand.mybatis.bean;public class Employee {    private Integer eId;    private String eName;    private Integer gender;    private String email;    private Department dept;        public Employee() {

Mybatis映射文件中数据库表列名称和POJO成员域的联系

下面是Mybatis的SQL映射文件. <?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"> <select id="findbyname"

mybatis映射文件之基本的增删改查

借之前配置好的环境: 1.首先在Employee .java中加上有参的构造器和无参的构造器. 2.采用mapper中的class属性配置映射文件. <mappers> <mapper class="com.gong.mybatis.dao.EmployeeMapper" /> </mappers> 3.EmployeeMapper.java package com.gong.mybatis.dao; import com.gong.mybatis.

MyBatis映射文件

Mybatis 如何进行参数处理,传参处理? 单个参数:mybatis不会做特殊处理, #{参数名/任意名}:取出参数值. 多个参数:mybatis会做特殊处理. 多个参数会被封装成 一个map, key:param1...paramN,或者参数的索引也可以 value:传入的参数值 #{}就是从map中获取指定的key的值: 异常: org.apache.ibatis.binding.BindingException: Parameter 'id' not found. Available p