Mybatis基础学习

Mybatis

创建实体类

public class Employee {
    private Integer id;
    private String lastName;
    private String gender;
    private String email;
    private Department dept;

    public Employee() {
    }

    public Employee(Integer id, String lastName, String gender, String email, Department dept) {
        this.id = id;
        this.lastName = lastName;
        this.gender = gender;
        this.email = email;
        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 getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Department getDept() {
        return dept;
    }

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

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", lastName='" + lastName + '\'' +
                ", gender='" + gender + '\'' +
                ", email='" + email + '\'' +
                ", dept=" + dept +
                '}';
    }
}

public class Department {

    private Integer id;
    private String departmentName;
    private List<Employee> emps;

    public Department() {
    }

    public Department(Integer id, String departmentName, List<Employee> emps) {
        this.id = id;
        this.departmentName = departmentName;
        this.emps = emps;
    }

    public Department(Integer id) {
        this.id = id;
    }

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

    public List<Employee> getEmps() {
        return emps;
    }

    public void setEmps(List<Employee> emps) {
        this.emps = emps;
    }

    @Override
    public String toString() {
        return "Department{" +
                "id=" + id +
                ", departmentName='" + departmentName + '\'' +
                ", emps=" + emps +
                '}';
    }
}

单表查询

对于参数传递，Mybatis对传过来的参数，使用map进行封装，所以取值时是取map中的key，使用Mybatis的@Param注解可以给参数指定key值

employee表

public interface EmployeeMapper {
    /**
     * 根据id获取员工信息
     * @return employee
     * @param id 员工id
     */
    Employee getEmpById(Integer id);

    /**
     * 插入员工信息
     * @param employee 员工
     */
    boolean addEmp(Employee employee);
    void updateEmp(Employee employee);
    void deleteEmpById(Integer id);

    Employee getEmpByIdAndName(@Param("id") Integer id,@Param("name") String name);

    /**
     * 注解 @MapKey("id") 告诉mybatis在封装map时使用哪个属性作为map的键
     * @param lastName lastname
     * @return map
     */
    @MapKey("lastName")
    Map<String, Employee> getEmpByLastName(String lastName);
}

对应的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.djx.mybatis.dao.EmployeeMapper">
    <insert id="addEmp" parameterType="com.djx.mybatis.pojo.Employee">
        insert into tbl_employee(last_name, gender, email) VALUES (#{lastName},#{gender},#{email})
    </insert>
    <update id="updateEmp" >
        update tbl_employee set last_name=#{lastName},gender=#{gender},email=#{email} where id=#{id}
    </update>
    <delete id="deleteEmpById">
        delete from tbl_employee where id=#{id}
    </delete>
    <select id="getEmpById" resultType="com.djx.mybatis.pojo.Employee">
        select * from tbl_employee where id = #{id}
    </select>
    <select id="getEmpByIdAndName" resultType="com.djx.mybatis.pojo.Employee">
        select * from tbl_employee where id=#{id} and last_name=#{name}
    </select>
    <select id="getEmpByLastName" resultType="com.djx.mybatis.pojo.Employee">
        select * from tbl_employee where last_name like #{lastName}
    </select>
</mapper>

一对一查询(一个员工对应一个部门)

public interface EmployeeMapperPlus {

    Employee getEmpById(@Param("id") Integer id);

    Employee getEmpAndDept(@Param("id") Integer id);

    Employee getEmpByIdStep(Integer id);

    List<Employee> getEmpsByDeptId(Integer deptId);
}

<?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.djx.mybatis.dao.EmployeeMapperPlus">
<!--========= 一 对 一 查 询 =========================================================================-->
    <resultMap id="myEmp" type="com.djx.mybatis.pojo.Employee">
        <!--指定主键列的封装规则
        id定义主键在底层会有优化
        column：指定查出来的哪一列
        property：指定对应的JavaBean属性
        -->
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="gender" property="gender"/>
        <result column="email" property="email"/>
        <!--其他不指定的列会自动封装，但是建议只要写了resultMap就把全部的映射规则都写上-->
    </resultMap>

    <select id="getEmpById" resultMap="myEmp">
        select * from tbl_employee where id=#{id}
    </select>


    <!--
    联合查询：级联属性封装结果
    -->
    <resultMap id="myEmpPlus" type="com.djx.mybatis.pojo.Employee">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="gender" property="gender"/>
        <result column="email" property="email"/>
        <result column="did" property="dept.id"/>
        <result column="deptname" property="dept.departmentName"/>
    </resultMap>

    <!--
   association可以指定那个属性是联合的JavaBean对象
   property="dept": 指定employee中那个属性是联合的对象
   javaType：指定这个属性对象的类型（不能省略）
   -->
    <resultMap id="myEmpPlus2" type="com.djx.mybatis.pojo.Employee">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="gender" property="gender"/>
        <result column="email" property="email"/>
        <association property="dept" javaType="com.djx.mybatis.pojo.Department">
            <id column="did" property="id"/>
            <result column="deptname" property="departmentName"/>
        </association>
    </resultMap>

    <select id="getEmpAndDept" resultMap="myEmpPlus2">
        SELECT e.id id,e.last_name last_name,e.gender gender,e.email email,d.id did,d.dept_name deptname
        FROM tbl_employee e INNER JOIN tbl_dept d
        ON e.d_id = d.id AND e.id = 1
    </select>

<!--============================================================================-->

    <!--使用association进行分步查询
        1、先按照员工id查询员工信息
        2、根据查出员工信息中的d_id值去部门表查出部门信息
        3、部门设置到员工中
    -->
    
    <!--
        association定义关联对象的封装规则
        select:表明但钱属性是调用select指定的方法查出的结果
        column：指定将哪一列的值传给这个方法
        流程：通过column指定的值，使用select指定的方法查出对象，并封装给property指定的属性
        
        <resultMap id="test" type="com.djx.mybatis.pojo.Department">
            <result column="id" property="id"/>
            <result column="dept_name" property="departmentName"/>
        </resultMap>
        <select id="getDeptById" resultMap="test">
            select *
            FROM tbl_dept
            where id=#{id}
        </select>
        
        注意：如果要引用其他xml文件中的方法作为子查询，那么最好自定义其结果集映射规则（即编写对应的resultMap），否则mybatis可能封装不上
    -->
    <resultMap id="myEmpByStep" type="com.djx.mybatis.pojo.Employee">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="gender" property="gender"/>
        <result column="email" property="email"/>
        <association column="d_id" property="dept" select="com.djx.mybatis.dao.DepartmentMapper.getDeptById"/>
    </resultMap>
    <select id="getEmpByIdStep" resultMap="myEmpByStep">
        select * from tbl_employee where id=#{id}
    </select>

    <!--======== 一 对 多 查 询 见 DepartmentMapper.xml collection的分布查询（子查询）的引用=========-->
    <select id="getEmpsByDeptId" resultType="com.djx.mybatis.pojo.Employee">
        select * from tbl_employee where d_id = #{deptId}
    </select>
</mapper>

一对多查询(一个部门对应多个员工)

public interface DepartmentMapper {
    Department getDeptById(Integer id);

    /**
     * 查出该部门下的所有员工
     * @param id
     * @return
     */
    Department getDeptByIdPlus(Integer id);
    Department getDeptByIdStep(Integer id);
}

<?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.djx.mybatis.dao.DepartmentMapper">

    <!--===================EmployeeMapperPlus.xml中分布查询（子查询）的引用==============================-->
    <resultMap id="test" type="com.djx.mybatis.pojo.Department">
        <result column="id" property="id"/>
        <result column="dept_name" property="departmentName"/>
    </resultMap>
    <select id="getDeptById" resultMap="test">
        select *
        FROM tbl_dept
        where id=#{id}
    </select>

    <!--================一对多查询========================-->
    <resultMap id="myDept" type="com.djx.mybatis.pojo.Department">
        <id column="did" property="id"/>
        <result column="dept_name" property="departmentName"/>
        <collection property="emps" ofType="com.djx.mybatis.pojo.Employee">
            <!--
                collection:定义关联集合类型的属性的封装规则
                ofType:指定集合里面元素的类型
            -->
            <id column="eid" property="id"/>
            <result column="last_name" property="lastName"/>
            <result column="email" property="email"/>
            <result column="gender" property="gender"/>
        </collection>
    </resultMap>
    <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>



    <!--
         <select id="getEmpsByDeptId" resultType="com.djx.mybatis.pojo.Employee">
            select * from tbl_employee where d_id = #{deptId}
        </select>
     -->
    <resultMap id="myDeptStep" type="com.djx.mybatis.pojo.Department">
        <id column="id" property="id"/>
        <result column="departmentName" property="departmentName"/>
        <collection column="id" property="emps" select="com.djx.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"/>
    </resultMap>
    <select id="getDeptByIdStep" resultMap="myDeptStep">
        select id,dept_name departmentName from tbl_dept where id = #{id}
    </select>
</mapper>

动态SQL

public interface EmployeeMapperDynamicSql {

    List<Employee> getEmpsByConditionIf(Employee employee);
    List<Employee> getEmpsByConditionTrim(Employee employee);
    List<Employee> getEmpsByConditionChoose(Employee employee);
    Integer updateEmp(Employee employee);

    Integer insertEmps(List<Employee> list);

    List<Employee> getEmpsByForeach(List<Integer> list);

    List<Employee> getEmpsByBind(String name);
}

<?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.djx.mybatis.dao.EmployeeMapperDynamicSql">
    <!--批量插入-->
    <insert id="insertEmps">
        insert into tbl_employee (last_name, gender, email, d_id) values
        <foreach collection="list" item="emp" separator=",">
            (#{emp.lastName},#{emp.gender},#{emp.email},#{emp.dept.id})
        </foreach>
    </insert>

    <!--批量更新-->
    <update id="updateEmp">
        update tbl_employee
        <set>
            <if test="lastName!=null and lastName!=''">
                last_name=#{lastName},
            </if>
            <if test="gender!=null">
                gender=#{gender},
            </if>
            <if test="email!=null" >
                email=#{email},
            </if>
        </set>
        where id=#{id}
        <!--
        <trim prefix="set" suffixOverrides=",">
            <if test="lastName!=null and lastName!=''">
                last_name=#{lastName},
            </if>
            <if test="gender!=null">
                gender=#{gender},
            </if>
            <if test="email!=null" >
                email=#{email},
            </if>
        </trim>
        where id=#{id}
        -->
    </update>

    <select id="getEmpsByConditionIf" resultType="com.djx.mybatis.pojo.Employee">
        select *
        from tbl_employee
        <where>
            <if test="id!=null">
                id=#{id}
            </if>
            <if test="lastName!=null and lastName!=''">
                and last_name=#{lastName}
            </if>
            <if test="email!=null and email.trim()!=''">
                and email=#{email}
            </if>
            <if test="gender!=null">
                and gender=#{gender}
            </if>
        </where>
    </select>

    <select id="getEmpsByConditionTrim" resultType="com.djx.mybatis.pojo.Employee">
        select *
        from tbl_employee
        <trim prefix="where" prefixOverrides="and" suffixOverrides="" suffix="" >
            <if test="id!=null">
                id=#{id}
            </if>
            <if test="lastName!=null and lastName!=''">
                and last_name=#{lastName}
            </if>
            <if test="email!=null and email.trim()!=''">
                and email=#{email}
            </if>
            <if test="'男'.toString()==gender or '女'.toString()==gender">
                and gender=#{gender}
            </if>
        </trim>
    </select>

    <select id="getEmpsByConditionChoose" resultType="com.djx.mybatis.pojo.Employee">
        select * from tbl_employee
        <where>
            <!--如果带了id就用id查，如果带了lastName就用lastName查；只会进入其中一个-->
            <choose>
                <when test="id!=null">
                    id=#{id}
                </when>
                <when test="lastName!=null and lastName!=''">
                    last_name=#{lastName}
                </when>
                <when test="email!=null">
                    email=#{email}
                </when>
                <otherwise>
                    gender='男'
                </otherwise>
            </choose>
        </where>
    </select>

    <select id="getEmpsByForeach" resultType="com.djx.mybatis.pojo.Employee">
        select * from tbl_employee where id in
        <foreach collection="list" item="i" separator="," open="(" close=")">
            #{i}
        </foreach>
    </select>

    <select id="getEmpsByBind" resultType="com.djx.mybatis.pojo.Employee">
        select * from tbl_employee
        <!--模糊查询不建议这样写，这样不灵活，建议在传参数的时候确定模糊查询规则-->
        <bind name="_lastName" value="'%'+lastName+'%'"/>
        <bind name="hasLastName" value=" latName!=null and lastName!='' "/>
        <where>
            <if test="hasLastName">
                last_name like #{_lastName}
            </if>
        </where>
    </select>
</mapper>

trim的前后缀是对于其包裹的整条语句而言的

mybatis-config.xml

<?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="db.properties"/>
    
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <setting name="jdbcTypeForNull" value="NULL"/>
        <!--以下两个设置为自查询提供懒加载（延迟加载）机制，即当不使用另一个表的属性时，
        不会执行查询第二张表的sql语句，提升了查询性能
        此设置只对子查询有用，即使用association进行分布查询
        -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="mapper/EmployeeMapper.xml"/>
        <mapper resource="mapper/EmployeeMapperPlus.xml"/>
        <mapper resource="mapper/DepartmentMapper.xml"/>
        <mapper resource="mapper/EmployeeMapperDynamicSql.xml"/>
    </mappers>
</configuration>

类路径的位置

在maven结构中类路径在target/classes/下

测试类

package com.djx.mybatis;

import com.djx.mybatis.dao.DepartmentMapper;
import com.djx.mybatis.dao.EmployeeMapper;
import com.djx.mybatis.dao.EmployeeMapperDynamicSql;
import com.djx.mybatis.dao.EmployeeMapperPlus;
import com.djx.mybatis.pojo.Department;
import com.djx.mybatis.pojo.Employee;
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 java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

public class MybatisTest {

    @Test
    public void test() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        Employee employee = sqlSession.selectOne("selectEmployee", 1);

        System.out.println(employee);

        sqlSession.close();
    }

    @Test
    public void test01() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
        Employee employee = mapper.getEmpById(1);
        System.out.println(employee);
    }

    @Test
    public void test02() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
        Employee employee = new Employee(null,"kuen","男","jerry@qq.com",null);
        boolean b = mapper.addEmp(employee);
        System.out.println(b);
        Employee employee01 = new Employee(1,"tom","男","tom@qq.com",null);
//        mapper.updateEmp(employee01);
//        mapper.deleteEmpById(7);
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void test03() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);

        Employee employee = mapper.getEmpByIdAndName(7, "kk");
        System.out.println(employee);
        sqlSession.close();
    }

    @Test
    public void test04() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
        Map<String, Employee> map = mapper.getEmpByLastName("%e%");

        System.out.println(map);
        sqlSession.close();
    }

    @Test
    public void test05() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapperPlus mapper = sqlSession.getMapper(EmployeeMapperPlus.class);

        Employee employee = mapper.getEmpById(1);
        System.out.println(employee);

        sqlSession.close();
    }

    @Test
    public void test06() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapperPlus mapper = sqlSession.getMapper(EmployeeMapperPlus.class);

        Employee employee = mapper.getEmpAndDept(7);
        System.out.println(employee);

        sqlSession.close();
    }

    @Test
    public void test07() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapperPlus mapper = sqlSession.getMapper(EmployeeMapperPlus.class);
        Employee employee = mapper.getEmpByIdStep(1);
        System.out.println(employee);

        sqlSession.close();
    }

    @Test
    public void test08() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        DepartmentMapper mapper = sqlSession.getMapper(DepartmentMapper.class);
        Department department = mapper.getDeptByIdPlus(1);
        System.out.println(department);

        sqlSession.close();
    }

    @Test
    public void test09() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        DepartmentMapper mapper = sqlSession.getMapper(DepartmentMapper.class);
        Department department = mapper.getDeptByIdStep(1);
        System.out.println(department.getEmps());

        sqlSession.close();
    }


    /*测试动态sql*/
    @Test
    public void test10() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapperDynamicSql mapper = sqlSession.getMapper(EmployeeMapperDynamicSql.class);
        List<Employee> emps = mapper.getEmpsByConditionIf(new Employee(null, "kk", "男", "29", null));
        emps.forEach(System.out::println);

        sqlSession.close();
    }

    @Test
    public void test11() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapperDynamicSql mapper = sqlSession.getMapper(EmployeeMapperDynamicSql.class);
        List<Employee> emps = mapper.getEmpsByConditionTrim(new Employee(null, "kk", "男", null, null));
        emps.forEach(System.out::println);

        sqlSession.close();
    }

    @Test
    public void test12() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapperDynamicSql mapper = sqlSession.getMapper(EmployeeMapperDynamicSql.class);
        List<Employee> emps = mapper.getEmpsByConditionChoose(new Employee(null, "", null, null, null));
        emps.forEach(System.out::println);

        sqlSession.close();
    }

    @Test
    public void test13() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapperDynamicSql mapper = sqlSession.getMapper(EmployeeMapperDynamicSql.class);
        Integer integer = mapper.updateEmp(new Employee(1, "djx", "1", null, null));
        System.out.println("结果为："+integer);
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void test14() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapperDynamicSql mapper = sqlSession.getMapper(EmployeeMapperDynamicSql.class);
        List<Employee> list = mapper.getEmpsByForeach(Arrays.asList(1, 4, 6, 7, 8));
        list.forEach(System.out::println);

        sqlSession.close();
    }

    @Test
    public void test15() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapperDynamicSql mapper = sqlSession.getMapper(EmployeeMapperDynamicSql.class);
        List<Employee> employees = new ArrayList<>();
        employees.add(new Employee(null,"kk","男","kk@qq.com",new Department(1)));
        employees.add(new Employee(null,"小强","男","小强@qq.com",new Department(1)));
        employees.add(new Employee(null,"小红","女","小红@qq.com",new Department(2)));
        employees.add(new Employee(null,"小明","男","小明@qq.com",new Department(2)));
        Integer integer = mapper.insertEmps(employees);
        System.out.println("结果为："+integer);
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void test16() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取sqlSession实例，能直接执行已经映射了的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        EmployeeMapperDynamicSql mapper = sqlSession.getMapper(EmployeeMapperDynamicSql.class);
        List<Employee> list = mapper.getEmpsByBind("");
        list.forEach(System.out::println);
        sqlSession.close();
    }
}