<?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>
    <!--开启log4j的日志打印。默认就是开启的，可以不配置-->
    <settings>
        <!--当然，这个value除了是LOG4J还可以是SLF4J-->
    	<setting name="logImpl" value="LOG4J"/>
    </settings>
    <!--配置实体类的别名。工作中一般不用，因为一旦出问题就很难搞了-->
    <typeAliases>
    	<!--给某个实体类配置别名，在Mapper文件中使用别名即可表示对应的实体类，简化代码的编写-->
        <!-- <typeAlias type="com.bjsxt.pojo.Emp" alias="emp"></typeAlias> -->
        <!-- 但是上面这种写法还是很麻烦，设想如果有一百个实体类，那么我们还是要配置一百次设置别名，因此我们换用下面这种：-->
        <package name="com.bjsxt.pojo"/> <!-- 默认该包下的所有类的类名即为别名，不区分大小写。这意味着mapper配置文件中的类似com.bjsxt.pojo.Emp的写法都可以直接写成Emp或者emp -->
    </typeAliases>
	<!--配置数据库环境，default的值为某个environment的id的值，表示当前使用的数据库环境-->
    <environments default="mysql1">
        <!--表示一个具体的数据库环境，可以配置多个-->
    	<environment id="mysql1">
            <!--表明事务的管理仍然使用原生jdbc的方式-->
        	<transactionManager type="JDBC"></transactionManager>
            <!--配置数据库的连接参数，使用数据库连接池技术-->
            <!--有POOLED、UNPOOLED和JNDI，具体介绍请看本章节的dataSource介绍-->
            <dataSource type="POOLED">
            	<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
            	<property name="url" value="jdbc:mysql://localhost:3306/db_name?serverTimezone=UTC"/>
            	<property name="username" value="root"/>
            	<property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!--配置Mapper文件的路径，用来告诉SqlSession mapper配置文件在哪，这样在最开始SqlSession就可以知道mapper配置文件有哪几个，就不需要在使用SqlSession做增删改查的时候再去找对应的mapper文件了-->
    <mappers>
    	<mapper resource="com/bjsxt/mapper/EmpMapper.xml"/>
    </mappers>
</configuration>

<!--使用相对于classpath的相对路径的资源，注意不是类，不使用. 而是使用/ -->
<mappers>
	<mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
	<mapper resource="org/mybatis/builder/BlogMapper.xml"/>
	<mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>
<!--使用全限定路径，以file开始，指定本地的绝对路径-->
<mappers>
    <!--这里的配置文件可能不在项目内，甚至是在网上的，所以这里也是以url的形式来指定的-->
	<mapper url="file:///var/mappers/AuthorMapper.xml"/>
	<mapper url="file:///var/mappers/BlogMapper.xml"/>
	<mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>
<!--使用接口的全路径名指定，是接口，所以此时使用. 而不是/ -->
<mappers>
	<mapper class="org.mybatis.builder.AuthorMapper"/>
	<mapper class="org.mybatis.builder.BlogMapper"/>
	<mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

<!--★-->
<!--使用包名指定，包含指定包下所有的接口，必须有接口才行-->
<mappers>
	<package name="org.mybatis.builder"/>
</mappers>

<?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>
    <!--引入db.properties-->
    <properties resource="db.properties"></properties>
    <!--开启log4j的日志打印。默认就是开启的，可以不配置-->
    <settings>
        <!--当然，这个value除了是LOG4J还可以是SLF4J-->
    	<setting name="logImpl" value="LOG4J"/>
    </settings>
    ...
</configuration>

// 获取mybatis配置文件的流对象
InputStream is = Resources.getResouceAsStream("file_name"); // 自动从当前项目的编译目录下获取配置文件的流对象

// 获取mybatis配置文件的流对象
InputStream is = Resources.getResourceAsStream("mybatis.xml"); // 自动从当前项目的编译目录下获取配置文件的流对象
// 获取SqlSessionFactory对象
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
// 获取SqlSession对象
SqlSession sqlSession = factory.openSession(); // 当SqlSession对象被创建成功后，已经连接好数据库了

//// 使用SQLSession对象完成数据库的单表查询操作
// List<Object> objects = sqlSession.selectList("SELECT * FROM tbl_name"); // sql语句如果写在这里，那耦合度就太高了，应该写到mapper中，如下：
// 查询所有
List<Emp> empList = sqlSession.selectList("com.bjsxt.mapper.EmpMapper.selEmp"); // "selEmp"表示mapper文件中该条sql语句的id。前缀：com.bjsxt.mapper.EmpMapper 表示mapper文件的namespace

// 根据id查询
Emp emp = sqlSession.selectOne("com.bjsxt.mapper.EmpMapper.selEmpById", 1);

// 多条件的单表查询
// 使用Map存储查询条件
HashMap<String, Object> hashMap = new HashMap<>();
hashMap.put("a", 0);
hashMap.put("b", 1);
List<Emp> emps = sqlSession.selectList("com.bjsxt.mapper.EmpMapper.selEmpBySqlAndDeptno", hashMap);
// 使用实体类对象存储查询条件
Emp emp1 = new Emp();
emp1.setSal(0.0);
emp1.setDeptno(1);
List<Emp> emps2 = sqlSession.selectList("com.bjsxt.mapper.EmpMapper.selEmpBySqlAndDeptno2", emp1);

//// 使用SqlSession对象完成数据库的单表新增、修改、删除操作
// 新增
// 创建Emp对象存储要增加的员工信息
Emp emp = new Emp();
emp.setEname("赵六");
emp.setDeptno(2);
emp.setSal(20000.00);
emp.setJob("程序员");
emp.setMgr(1);
int i = sqlSession.insert("com.bjsxt.mapper.EmpMapper.insEmp", emp);
// 提交事务
sqlSession.commit(); // 原生jdbc是自动提交事务的，当然也可以取消自动提交：conn.setAutoCommit(false); 但是mybatis必须手动提交
// 更新
Emp emp = new Emp();
emp.setEmpid(3);
emp.setEname("王五");
int i = sqlSession.update("com.bjsxt.mapper.EmpMapper.updateEmp", emp);
sqlSession.commit();
// 删除
int i = sqlSession.delete("com.bjsxt.mapper.EmpMapper.delEmp", 4);
sqlSession.commit();

// 假设有两个相关文件，一个是接口EmpMapper和一个是xml文件EmpMapper.xml
// 获取SqlSession对象之后，我们需要获取是哪个mapper
// 获取Mapper接口的实现类。注意，接口的实现类是在SqlSession对象被创建的时候即完成了生成，所以假设有5个接口，与之对应有5个xml文件，那么这5个接口实现会在SqlSession创建的时候就完成，到后面要用的时候直接取就行了
EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
// 调用EmpMapper接口中的方法
List<Emp> emps = empMapper.selEmpMapper();

//// 有参数查询
// 一个形参
// 参数为基本类型
Emp emp = empMapper.selEmpById(1);
// 参数为引用类型
Emp emp1 = new Emp();
emp1.setEmpid(2);
Emp emp2 = empMapper.selEmpById2(emp1);
// 多个参数
// 参数全部为基本类型
List<Emp> emps = empMapper.selEmpBySalDept(2.0, 1);
// 参数全部为引用类型
Emp e1 = new Emp();
e1.setSal(3.0);
Emp e2 = new Emp();
e2.setDeptno(1);
List<Emp> emps2 = empMapper.selEmpBySalDept2(e1, e2);
// 参数为引用类型和基本类型的混用
Emp e3 = new Emp();
e3.setSal(4.0);
List<Emp> emps3 = empMapper.selEmpBySalDept3(e3, 2);

<!--EmpMapper.xml文件中的sql语句-->
<!--查询所有员工信息-->
<select id="selEmpMapper" resultType="com.bjsxt.pojo.Emp">
	select empid, ename, job, mgr from emp
</select>
<!--有参数的数据库操作-->
<!--根据Id查询员工信息-->
<!--参数为一个-->
<!--类型为基本类型：使用#{0}-->
<select id="selEmpById" resultType="com.bjsxt.pojo.Emp">
    <!--下面的#{0}中的0表示接口中形参的下标-->
	select empid, ename, job, mgr from emp from emp where empid=#{0}
</select>
<!--类型为引用类型：使用#{实体类的属性名}或者#{Map集合的键名（因为形参类型可能为Map）}-->
<select id="selEmpById2" resultType="com.bjsxt.pojo.Emp">
    <!--下面的#{empid中的empid表示接口中形参Emp的属性名empid-->
	select empid, ename, job, mgr from emp from emp where empid=#{empid}
</select>

<!--参数为多个-->
<!--参数全部为基本类型：根据工资和部门编号查询员工信息，使用#{param1}，从接口方法从左至右开始，param1，param2，...-->
<select id="selEmpBySalDept" resultType="com.bjsxt.pojo.Emp">
    <!--下面的#{param2}表示形参中顺序数下去的第2个参数（注意，这里不让写#{1}了，应该写#{param2}）-->
	select empid, ename, job, mgr from emp from emp where deptno=#{param2} and sal>#{param1}
</select>
<!--参数全部为引用类型：根据工资和部门编号查询员工信息，使用#{param1.属性名}或param1为Map集合时应该使用#{param1.键名}-->
<select id="selEmpBySalDept2" resultType="com.bjsxt.pojo.Emp">
    <!--下面的#{param2.deptno}表示第二个参数Emp的deptno属性-->
	select empid, ename, job, mgr from emp from emp where deptno=#{param2.deptno} and sal>#{param1.sal}
</select>
<!--引用类型和基本类型混用：根据工资和部门编号查询员工信息-->
<select id="selEmpBySalDept3" resultType="com.bjsxt.pojo.Emp">
	select empid, ename, job, mgr from emp from emp where deptno=#{param2} and sal>#{param1.sal}
</select>

public interface EmpMapper{
    // 查询所有的员工信息
    List<Emp> selEmpMapper();
    /**
    * 带有参数的数据库操作
    */
    //// 只有一个形参
    // 根据id查询员工信息：参数类型为基本类型
    Emp selEmpById(Integer empid);
    // 根据id查询员工信息：参数类型为引用类型
    Emp selEmpById2(Emp emp);
    
    //// 参数有多个
    // 参数全部为基本类型：根据工资和部门编号查询员工信息
    List<Emp> selEmpBySalDept(Double sql, Integer deptno);
    // 参数全部为引用类型：根据工资和部门编号查询员工信息
    List<Emp> selEmpBySalDept2(Emp e1, Emp e2);
    // 引用类型和基本类型混用：根据工资和部门编号查询员工信息
    List<Emp> selEmpBySalDept3(Emp e1, Integer deptno);
}

<?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">
<!--namespace就相当于mapper文件的id-->
<mapper namespace="com.bjsxt.mapper.EmpMapper">
	<!--使用Mybatis完成单表的查询-->
    <!--
		声明查询所有的员工信息
			sql语句中没有参数
				- 使用resultType属性指明返回值存储的实体类的全限定路径
				- 如果查询结果是多条数据，使用selectList(String sqlPath)方法完成查询；如果只有一条，建议使用selectOne(String sqlPath)来完成查询
	-->
    <!--resultType表示使用哪个实体类去存数据库返回的信息-->
    <select id="selEmp" resultType="com.bjxst.pojo.Emp">
    	select * from emp
    </select>
    <!--
		根据ID查询员工信息：
			SQL语句中如果只有一个参数：
				- 使用parameterType属性指明参数的类型
				- 在SQL语句中使用#{任意字符}完成参数的占位
				- 如果查询结果是多条数据，使用selectList(String sqlPath, Object Param)方法完成查询；如果只有一条，建议使用selectOne(String sqlPath, Object Param)来完成查询
	-->
    <select id="selEmpById" resultType="com.bjsxt.pojo.Emp" parameterType="int">
    	select * from emp where empid=#{myempid}
    </select>
    
    <!--
		根据部门和工资查询员工信息
			sql语句中有多个参数的单表查询：
				- 使用parameterType属性指明参数的类型
					注意：parameterType属性表明的是Mybatis接受的实参的类型，不是SQL语句中的参数类型
				- 在SQL语句中使用#{任意字符}完成参数的占位
					注意：
						因为在Mybatis底层会自动给SQL语句中的占位符进行赋值，由我们自己赋值变为自动
						但是我们需要告诉Mybatis哪个值赋值给哪个占位符。所以Mybatis中的SQL语句中使用#{键名}的方式来完成占位以及赋值
				- 如果查询结果是多条数据，使用selectList(String sqlPath, Object Param)方法完成查询；如果只有一条，建议使用selectOne(String sqlPath, Object Param)来完成查询
	-->
    <!--parameterType="map"表示使用Map集合封装实参-->
    <select id="selEmpBySqlAndDeptno" resultType="com.bjsxt.pojo.Emp" parameterType="map">
    	select * from emp where sql > #{keyA} and deptno = #{keyB}
    </select>
    
    <!--使用实体类对象封装实参，占位使用#{属性名}-->
    <select id="selEmpBySqlAndDeptno2" parameterType="com.bjsxt.pojo.Emp" resultType="com.bjsxt.pojo.Emp">
    	select * from emp where sql > #{sql} and deptno = #{deptno}
    </select>
</mapper>

<?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">
<!--namespace就相当于mapper文件的id-->
<mapper namespace="com.bjsxt.mapper.EmpMapper">
	<!--Mybatis的增、删、改，无需使用resultType属性表明返回值类型，默认为int-->
    <!--新增-->
    <insert id="insEmp" parameterType="com.bjsxt.pojo.Emp">
    	insert into emp values(default, #{ename}, #{job}, #{mgr}, now(), #{sal}, #{comm}, #{deptno})
    </insert>
    <!--更新-->
    <update id="updateEmp" parameterType="com.bjsxt.pojo.Emp">
    	update emp set ename=#{ename}, where empid=#{empid}
    </update>
    <!--删除-->
    <delete id="delEmp" parameterType="int">
    	delete from emp where empid=#{myempid}
    </delete>
</mapper>

<settings>
	<setting name="logImpl" value="LOG4J"/>
</settings>

<settings>
	<setting name="logImpl" value="LOG4J"/>
</settings>

<!--注意下面的parameterType-->
<delete id="delEmp" parameterType="int">
    delete from emp where empid=#{myempid}
</delete>

<!--
	问题：
		我们发现在Mapper.xml文件中不同的sql语句中会存在相同的sql片段，如果每次我们都自己声明，会造成代码维护困难
	解决：
		将相同的sql脚本片段抽取出来，在外部声明，然后在sql标签中调用即可
	实现：
		sql标签：声明公共的sql脚本片段
		include标签：引入公共的sql脚本片段
-->
<sql id="empSql">
	empid,ename,job,mgr
</sql>
<!--查询所有的员工信息-->
<select id="selEmpMapper" resultType="com.bjsxt.pojo.Emp">
	select <include refid="empSql"></include> from emp 
</select>

public List<Role> findRoleByMap(Map<String, Object> parameter);

<select id="findRoleByMap" parameterType="map" resultType="role">
    SELECT id,name FROM t_role
    WHERE roleName=#{roleName}
    AND note=#{note}
<select>

RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
Map<String, Object> parameter = new HashMap<>();
parameter.put("roleName", "剑士");
parameter.put("note", "决战紫禁之巅");
List<Role> roles = roleMapper.findRolesByMap(parameter);

public List<Role> findRoleByAnnotation(@Param("roleName") String roleName, @Param("note") String note);

public class RoleParam {
    private String roleName;
    private String note;
    /*getter和setter*/
}

public List<Role> findRoleByBean(RoleParam role);

public List<Role> findRoleByMix(@Param("roleP") RoleParam role, @Param("permissionP") PermissionParam permission);

<select id="findRoleByMix" resultType="role">
    SELECT id,name FROM t_role
    WHERE roleName=#{roleP.roleName}
    AND note=#{rolep.note}
    AND level=#{permissionP.level}
<select>

<select id="selPs" resultType="com.bjsxt.pojo.Emp">
	select * from emp where ename=#{ename}
</select>

// #{}的占位
List<Emp> selPs(@Param("ename") String ename);

EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
List<Emp> emps = mapper.selPs("张三"); // 此时底层使用PreparedStatement

<select id="selPs" resultType="com.bjsxt.pojo.Emp">
	select * from emp where ename='${ename}'
</select>

// ${}的占位
List<Emp> selPs(@Param("ename") String ename);

EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
List<Emp> emps = mapper.selPs("张三"); // 此时底层使用Statement

// 模糊查询：根据员工名查询员工信息
List<Emp> selEmpByName(@Param("ename")String ename);

<!--模糊查询：根据员工姓名获取员工信息-->
<select id="selEmpByName" resultType="com.bjsxt.pojo.Emp">
    <!--下面的这个concat其实就是MySQL自带的函数，用来拼接字符串-->
	select * from emp where ename like concat('%', #{ename}, '%')
</select>

EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
List<Emp> emps = mapper.selEmpByName("三"); 

// 小于判断
List<Emp> selEmpBySal(@Param("sal") Double sal);

<!--小于判断-->
<select id="selEmpBySal" resultType="com.bjsxt.pojo.Emp">
	select * from emp where sal &lt; #{sal}
</select>

EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
List<Emp> emps = mapper.selEmpBySal(4000.0); 

List<Emp> selEmpByPage(@Param("ename") String ename, @Param("pageStart")int pageStart, @Param("pageSize")int pageSize);

<!--分页查询-->
<select id="selEmpByPage" resultType="com.bjsxt.pojo.Emp">
	select * from emp where sal &lt; #{sal} limit #{pageStart},#{pageSize}
</select>

// 分页查询
EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
List<Emp> emps = mapper.selEmpByPage(4000.0, 0, 5); 

<insert id="save" useGeneratedKeys="true" keyProperty="empno">
	insert into emp values(null,#{ename},#{job},#{mgr},#{hireDate},#{sal},#{comm},#{deptno})
</insert>

<insert id="save">
	<selectKey order="AFTER" keyProperty="empno" resultType="int">
		<!--SELECT LAST_INSERT_ID()-->
        <!--或者可以这么写：-->
        SELECT @@identity
    </selectKey>
    insert into emp(empno,ename,sal)values(null,#{ename},#{sal})
</insert>

// 根据员工的工作，部门，工资动态查询员工信息 ---if标签的使用
List<Emp> findEmp(@Param("job") String job,
                 @Param("deptno") Integer deptno,
                 @Param("sal") Double sal);

<!--
	根据员工的工作、部门、工资动态查询员工信息
	使用if标签完成逻辑判定，完成SQL语句的拼接
	使用：
		在SQL标签中声明
	属性：
		test：值为判断的逻辑条件，直接使用@Param注解中声明的名字即可获取实参。不同的条件使用 and or 关键字连接
-->
<select id="findEmp" resultType="com.bjsxt.pojo.Emp">
	select * from emp where 1=1
    <if test="job!=null and job!=''">
    	and job=#{job}
    </if>
    <if test="deptno!=null and deptno!=''">
    	and deptno=#{deptno}
    </if>
    <if test="sal!=null and sal!=''">
    	and sal > #{sal}
    </if>
</select>

EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
// 动态SQL查询
List<Emp> emps = empMapper.findEmp(null, 1, null);

<if test="collection!=null and collection.size()!=0">
</if>

// 根据员工的工作，部门，工资动态查询员工信息 ---where标签的使用
List<Emp> findEmp(@Param("job") String job,
                 @Param("deptno") Integer deptno,
                 @Param("sal") Double sal);

<!--
	根据员工的工作、部门、工资动态查询员工信息
	where标签的使用：
		作用：相当于声明了where关键字
		注意：
			只有当条件成立时才会生成where关键字，并且会自动忽略第一个and关键字
			因为无法预知哪个条件会成立，所以建议每个条件前都声明SQL语句的条件链接符号（and|or）

-->
<select id="findEmp" resultType="com.bjsxt.pojo.Emp">
	select * from emp
    <where>
    	<if test="job!=null and job!=''">
    		and job=#{job}
        </if>
        <if test="deptno!=null and deptno!=''">
            and deptno=#{deptno}
        </if>
        <if test="sal!=null and sal!=''">
            and sal > #{sal}
        </if>
    </where>
</select>

EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
// 动态SQL查询
List<Emp> emps = empMapper.findEmp(null, 1, null);

// 根据员工的工作，部门，工资动态查询员工信息 ---bind标签的使用
List<Emp> findEmp(@Param("job") String job,
                 @Param("deptno") Integer deptno,
                 @Param("sal") Double sal);

<!--
	根据员工的工作、部门、工资动态查询员工信息
	bind标签的使用：
		作用：将接收到的实参进行进一步的修饰后传递给SQL语句使用
		使用：
			<bind name="新的键名" value="原始数据的名字+'拼接的新数据'"/>
			一般在模糊查询的时候使用（拼接%）
-->
<select id="findEmp" resultType="com.bjsxt.pojo.Emp">
	<bind name="job_alias" value="job+'qq1'"/>
    select * from emp where job=#{job_alias} and deptno=#{deptno} and sal=#{sal}
</select>

EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
// 动态SQL查询
List<Emp> emps = empMapper.findEmp("讲师", 1, 10000.0);

// set标签的使用
int updateEmp(Emp emp);

<!--
	set标签的作用：
		set标签用在update语句中给字段赋值。借助if的配置，可以只对有具体值的字段进行更新。set元素会自动帮助添加set关键字，自动去掉最后一个if语句的多余的逗号
-->
<update id="updateEmp">
	update emp
    <set>
    	<if test="ename!=null and ename !=''">
        	ename=#{ename},
        </if>
        <if test="job!=null and job !=''">
        	job=#{job},
        </if>
        <if test="mgr!=null and mgr !=''">
        	mgr=#{mgr},
        </if>
        <if test="sal!=null and sal !=''">
        	sal=#{sal},
        </if>
        <!--写下面这一句的原因是：如果一个要更新的字段都没有，那么就会生成这样的sql语句：update emp where id=?，显然是会报错的，为了防止这种情况，更新一下empid即可（empid是一定存在的），这样的话就算一个要更新的字段都没，也会生成这样的sql语句：update emp set empid=? where empid=?，这样就不会报错了-->
        empid=#{empid},
    </set>
</update>

EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
// set标签
Emp emp = new Emp();
emp.setEmpId(1);
emp.setEmpName("qyf");
int i = empMapper.updateEmp(emp);

List<Emp> findEmpByIds(List<Integer> ids);

<!--
	foreach标签的作用：
		foreach标签是非常强大的，它允许你指定一个集合或数组，声明集合项和索引变量，他们可以用在标签内。它也允许你指定开放和关闭的字符串，在迭代之间放置分隔符。这个元素是很智能的，它不会偶然地附加多余的分隔符
		注意：你可以传递一个List实例或者数组作为参数对象传给mybatis。当你这么做的时候，mybatis会自动将它包装在一个Map中，用名称在作为键。List实例将会以“list”作为键，而数组实例将会以“array”作为键
		特别注意：在进行sql优化时有一点就是建议少用in语句，因为对性能有影响。如果in中元素很多的话，会对性能有较大影响，此时就不建议使用foreach语句了
-->
<select id="findEmpByIds" resultType="com.bjsxt.pojo.Emp">
	select * from emp where empid in
    <foreach collection="list" open="(" close=")" separator="," item="id">
    	#{id}
    </foreach>
</select>

List<Emp> findEmpByIds(@Param("ids") List<Integer> ids);

<select id="findEmpByIds" resultType="com.bjsxt.pojo.Emp">
	select * from emp where empid in
    <foreach collection="ids" open="(" close=")" separator="," item="id">
    	#{id}
    </foreach>
</select>

EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
List<Integer> ids = new ArrayList<>();
ids.add(1);
ids.add(2);
List<Emp> emps = empMapper.findEmpByIds(ids);

List<Emp> findEmpByNameAndIds(@Param("ename")String ename, @Param("ids") List<Integer> ids);

<select id="findEmpByNameAndIds" resultType="com.bjsxt.pojo.Emp">
	select * from emp where
    ename like concat('%', #{ename}, '%')
    and
    empid in
    <foreach collection="ids" open="(" close=")" separator="," item="id">
    	#{id}
    </foreach>
</select>

EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
List<Integer> ids = new ArrayList<>();
ids.add(1);
ids.add(2);
List<Emp> emps = empMapper.findEmpByNameAndIds("张三", ids);

// 多对一：查询员工及其部门信息
List<Emp> selEmpInfoMapper();

// 一对多：查询部门及其员工信息
List<Emp> selEmpInfoByDeptnoMapper(@Param("deptno")Integer deptno);

// 多对一：查询员工及其部门信息
// 根据部门编号获取部门信息
Dept selDeptByIdMapper(@Param("deptno")Integer deptno);

// 一对多：查询部门及其员工信息
List<Dept> selDeptInfoMapper();

<!--
	多对一：查询员工及其部门信息
-->
<select id="selEmpInfoMapper" resultType="com.bjsxt.pojo.Emp">
	select * from emp
</select>

<!--
	一对多：查询部门及其员工信息
-->
<select id="selEmpInfoByDeptnoMapper" resultType="com.bjsxt.pojo.Dept">
	select * from emp where deptno=#{deptno}
</select>

<!--
	多对一：查询员工及其部门信息
	根据部门编号获取部门信息
-->
<select id="selDeptByIdMapper" resultType="com.bjsxt.pojo.Dept">
	select * from dept where deptno=#{deptno}
</select>

<!--
	一对多：查询部门及其员工信息
-->
<select id="selDeptInfoMapper" resultType="com.bjsxt.pojo.Dept">
	select * from dept
</select>

// 多对一：查询员工及其部门信息
// 获取员工mapper
EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
// 获取部门mapper
DeptMapper deptMapper = sqlSession.getMapper(DeptMapper.class);
// 1、查询所有的员工信息
List<Emp> emps = empMapper.selEmpInfoMapper();
// 2、遍历结果，根据员工的部门编号获取部门信息，并存储到对应的员工对象中
for(Emp emp: emps){
    // 根据员工的部门编号获取部门信息
    Dept dept = deptMapper.selDeptByIdMapper(emp.getDeptno());
    emp.setDept(dept);
}

// 一对多：查询部门及其员工信息
// 获取员工mapper
EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
// 获取部门mapper
DeptMapper deptMapper = sqlSession.getMapper(DeptMapper.class);
// 1、查询所有的部门信息
List<Dept> depts = deptMapper.selDeptInfoMapper();
// 2、循环查询部门的员工信息，并将结果存储到对应的部门对象中
for(Dept dept: depts){
    // 根据部门编号获取员工信息
    List<Emp> emps = empMapper.selEmpInfoByDeptnoMapper(dept.getDeptno());
    // 将结果存储到部门对象中
    dept.setEmpList(emps);
}

// 级联查询
// 多对一：查询员工及其部门信息
List<Emp> selEmpInfoMapper();

// 级联查询
// 一对多：查询部门及其员工信息
List<Dept> selDeptInfoMapper();

<!--
	级联查询
	多对一：查询员工及其部门信息
-->
<resultMap id="rm2" type="com.bjsxt.pojo.Emp">
	<result property="ename2" column="ename"></result>
	<result property="job2" column="job"></result>
    <!--注意：我们说resultMap中属性和字段一致的就可以省略不写，但是级联查询中很有可能出现两个表存在公共同名字段，那么两个表中的公共的字段不能省略，否则查出来的结果中该公共字段就会为null（原因是mybatis底层在将部门信息赋值到员工的时候会通过员工表的deptno去查询部门信息，这个时候相当于deptno就已经被用过一次了，那么它就不会被使用第二次，导致就不会再给员工信息表中的deptno赋值了，导致了查出来的结果中deptno为null）-->
    <!--这个地方我们写清楚了公共字段deptno的映射，mybatis底层就一定会给deptno赋值-->
    <result property="deptno" column="deptno"></result>
	<!--mybatis实现级联查询的奥妙在这-->
    <!--这里的column表示的意义就不一样了，它的作用是告诉select使用deptno的值去查；同时property表示的意义也不一样了，它的作用是select查出来的东西赋值给实体的dept属性-->
    <association property="dept" column="deptno" select="com.bjsxt.mapper.DeptMapper.selDeptByIdMapper"></association>
</resultMap>
<select id="selEmpInfoMapper" resultMap="rm2">
	select * from emp
</select>

<!--
	级联查询
	一对多：查询部门及其员工信息
-->
<resultMap id="rm" type="com.bjsxt.pojo.Dept">
    <id property="deptno" column="deptno"></id>
	<!--使用collection标签来表明员工信息的获取-->
    <!--上面多对一的时候我们用了association标签，这里用了collection标签，怎么辨别到底用什么标签呢？很简单，多对一中一个实体对应一个实体，因此结果只可能是一个，所以用association；一对多中一个实体对应多个实体，因此结果可能有多个，所以用collection-->
    <!--下面的ofType告诉mybatis对于empList的查询结果的类型是什么-->
    <!--这里的column表示的意义就不一样了，它的作用是告诉select使用deptno的值去查；同时property表示的意义也不一样了，它的作用是select查出来的东西赋值给实体的empList属性-->
    <collection property="empList" ofType="com.bjsxt.pojo.Emp" column="deptno" select="com.bjsxt.mapper.EmpMapper.selEmpInfoByDeptnoMapper"></collection>
</resultMap>
<select id="selDeptInfoMapper" resultMap="rm">
	select * from dept
</select>

// 级联查询
// 多对一：查询员工及其部门信息
EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
List<Emp> emps = mapper.selEmpInfoMapper();
// 一对多：查询部门及其员工信息
DeptMapper mapper2 = sqlSession.getMapper(DeptMapper.class);
// 查询
List<Dept> depts = mapper2.selDeptInfoMapper(); // 注意：由于使用mybatis的级联查询，对于Dept实体中的List<Emp> empList中的Emp的查询，mybatis是按照属性字段名一致为前提去查询的，所以一旦属性字段名不一致，mybatis查出来的Emp中的某些属性字段名不一致的属性将会为null

select * from emp;
select * from dept where deptno = 20;
select * from dept where deptno = 30;
select * from dept where deptno = 30;

select * from dept;
select * from emp where deptno = 10;
select * from emp where deptno = 20;
select * from emp where deptno = 30;
select * from emp where deptno = 40;

<settings>
    <!--lazyLoadingEnabled表示是否开启延迟加载。是mybatis是否启用懒加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态-->
	<seting name="lazyLoadingEnabled" value="true"/>
	<!--aggressiveLazyLoading开启时，任何方法的调用都会加载懒加载对象的所有属性。否则，每个属性会按需加载-->
    <seting name="aggressiveLazyLoading" value="true"/>
</settings>

// 多对一：查询员工及其部门信息
List<Emp> selEmpInfoMapper();

// 一对多：查询部门及其员工信息
List<Emp> selDeptInfoMapper();

<!--联合查询方式-->
<!--多对一：查询员工及其部门信息-->
<resultMap id="rm3" type="com.bjsxt.pojo.Emp">
	<!--联合查询的时候属性字段映射不能省略！-->
    <id property="empid" column="empid"></id>
    <result property="ename" column="ename"></result>
    <result property="job" column="job"></result>
    <result property="mgr" column="mgr"></result>
    <result property="deptno" column="deptno"></result>
	<!--下面的association标签不用写column了，因为sql语句已经把数据都查出来了，但是需要写javaType指定property的数据的类型-->
    <association property="dept" javaType="com.bjsxt.pojo.Dept">
		<!--联合查询的时候属性字段映射不能省略！-->
    	<id property="deptno" column="deptno"></id>
        <result property="dname" column="dname"></result>
        <result property="ddesc" column="ddesc"></result>
    </association>
</resultMap>
<select id="selEmpInfoMapper" resultMap="rm3">
	select * from emp e
    join dept d
    on e.deptno=d.deptno
</select>

<!--联合查询方式-->
<!--一对多：查询部门及其员工信息-->
<resultMap id="rm3" type="com.bjsxt.pojo.Dept">
	<!--联合查询的时候属性字段映射不能省略！-->
	<id property="deptno" column="deptno"></id>
    <result property="dname" column="dname"></result>
    <result property="ddesc" column="ddesc"></result>
    <collection property="empList" ofType="com.bjsxt.pojo.Emp">
		<!--联合查询的时候属性字段映射不能省略！-->
    	<id property="empid" column="empid"></id>
        <result property="ename" column="ename"></result>
        <result property="job" column="job"></result>
        <result property="mgr" column="mgr"></result>
        <result property="sal" column="sal"></result>
        <result property="comm" column="comm"></result>
        <result property="deptno" column="deptno"></result>
    </collection>
</resultMap>
<select id="selDeptInfoMapper" resultMap="rm3">
	select * from dept d
    join emp e
    on e.deptno=d.deptno
</select>

// 多表联合查询
// 多对一：查询员工及其部门信息
EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
List<Emp> emps = mapper.selEmpInfoMapper();

// 一对多：查询部门及其员工信息
DeptMapper mapper2 = sqlSession.getMapper(DeptMapper.class);
List<Dept> emps = mapper2.selDeptInfoMapper();

// 自动注入-Autowired
List<Emp> selEmpByAuto();
// 手动注入-ResultMap
List<Emp> selEmpByResultMap();

<!--注入规则-->
<!--
	自动注入：mybatis在完成查询后，会自动的按照实体类的属性名和查询结果的字段名一致的规则将数据注入到实体类对象中。
	注意：
		1、实体类的属性名必须和字段名一致
		2、在查询标签上使用resultType表明要注入的实体类的全限定路径
	
	手动注入：如果我们设计的存储查询结果的实体类的属性名和查询结果的字段名不一致，需要手动配置实体类和查询结果之间的映射关系
	使用：
		1、在查询标签上使用ResultMap属性引入声明的规则的ID
		2、使用resultMap标签表明映射关系
	注意：
		1、resultMap配置的映射关系中可以只写属性名和字段名不一致的那些字段
-->
<!--自动注入-->
<select id="selEmpByAuto" resultType="com.bjsxt.pojo.Emp">
	select * from emp
</select>

<!--手动注入-->
<!--使用resultMap标签声明查询结果和实体类之间的映射关系-->
<resultMap id="rm1" type="com.bjsxt.pojo.Emp">
	<id property="empid" column="empid"></id>
    <result property="ename2" column="ename"></result>
    <result property="job2" column="job"></result>
    <result property="mgr" column="mgr"></result>
    <result property="sal" column="sal"></result>
    <result property="deptno" column="deptno"></result>
</resultMap>
<select id="selEmpByResultMap" resultMap="rm1">
    select * from emp
</select>

EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
// 查询所有的员工信息（使用自动注入规则）
List<Emp> emps = empMapper.selEmpByAuto(); // 此时如果实体类Emp中有属性ename2，但是数据库中没有该字段（或者说数据库中该字段叫ename），那么此时查到的结果中实体Emp的属性ename2将会是null

// 查询所有的员工信息（使用手动注入规则）
List<Emp> emps = empMapper.selEmpByResultMap();

<resultMap id="rm" type="com.bjsxt.pojo.Emp">
	<id property="empid" javaType="java.lang.Integer" column="empid"></id>
</resultMap>

<select id="selectByPrimaryKey" resultMap="BaseResultMap">
    select *
    from emp
    where id = #{id,jdbcType=INTEGER}
</select>

<resultMap>
    <!-- 下面这两个字段就是联合主键 -->
　　 <id property="enterId" column="enter_id"/>
	<id property="sId" column="s_id"/>
</resultMap>

// 查询所有的员工信息
@Select("select * from emp")
List<Emp> selEmpInfoMapper();
// 根据id获取员工信息
@Select("select * from emp where empid=#{empid}")
Emp selEmpByIdMapper(@Param("empid")Integer empid);
// 根据岗位和工资查询员工信息
@Select("select * from emp where job like concat('%',#{job},'%') and sal>#{sal}")
List<Emp> selEmpByJobSqlMapper(@Param("job")String job, @Param("sal")Double sal);
// 新增员工信息
@Insert("insert into emp values(default,#{ename},#{job},#{mgr},now(),#{sal},#{comm},#{deptno})")
int addEmpMapper(Emp emp);
// 更新员工信息
@Update("update emp set ename=#{ename} where empid=#{empid}")
int updateEmpMapper(@Param("ename")String ename, @Param("empid")String empid);
// 删除
@Delete("delete from emp where empid=#{empid}")
int delEmp(@Param("empid")Integer empid);

InputStream is = Resources.getResourceAsStream("mybatis.xml");
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);

SqlSession session = factory.openSession();

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

Employee emp = mapper.findAll();
Employee emp = mapper.findById(7839);
int n= mapper.insert(emp);

session.selectList("com.bjsxt.mapper.EmployeeMapper.selectAll");
session.selectOne("com.bjsxt.mapper.EmployeeMapper.selectById", 7839);
session.update("com.bjsxt.mapper.EmployeeMapper.updateEmp", emp);

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>

  <properties resource="db.properties"/>
  <!--mysql 连接数据库jar 这里选择自己本地位置-->
  <classPathEntry location="C:\Users\hgb\.m2\repository\mysql\mysql-connector-java\8.0.23\mysql-connector-java-8.0.23.jar" />

  <context id="mysqlTables" targetRuntime="MyBatis3Simple">

    <!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
    <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                    connectionURL="jdbc:mysql://localhost:3306/demo"
                    userId="root"
                    password="root">
    </jdbcConnection>

    <plugin type="org.mybatis.generator.plugins.SerializablePlugin"/>

    <commentGenerator>
        <property name="suppressDate" value="true"/>
        <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
        <property name="suppressAllComments" value="true"/>
    </commentGenerator>

    <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL 和
           NUMERIC 类型解析为java.math.BigDecimal -->
    <javaTypeResolver>
        <property name="forceBigDecimals" value="true"/>
        <property name="useJSR310Types" value="true"/>
    </javaTypeResolver>

    <!-- targetProject:生成PO类的位置 -->
    <javaModelGenerator targetPackage="com.deya.simple.futures.report.entity.po" targetProject="src/main/java">
      <property name="enableSubPackages" value="true" />
      <property name="trimStrings" value="true" />
    </javaModelGenerator>
    <!-- targetProject:mapper映射文件生成的位置
         如果maven工程只是单独的一个工程，targetProject="src/main/java"
         若果maven工程是分模块的工程，targetProject="所属模块的名称"，例如：
         targetProject="ecps-manager-mapper"，下同-->
    <sqlMapGenerator targetPackage="mapper"  targetProject="src/main/resources">
      <property name="enableSubPackages" value="true" />
    </sqlMapGenerator>

    <!-- targetPackage：mapper接口生成的位置 -->
    <javaClientGenerator type="XMLMAPPER" targetPackage="com.deya.simple.futures.report.dao"  targetProject="src/main/java">
      <property name="enableSubPackages" value="true" />
    </javaClientGenerator>

    <!-- 指定数据库表 -->
    <table schema="MYSQLADMIN" tableName="USER" domainObjectName="Customer" >
      <property name="useActualColumnNames" value="true"/>
      <generatedKey column="ID" sqlStatement="DB2" identity="true" />
      <columnOverride column="DATE_FIELD" property="startDate" />
      <ignoreColumn column="FRED" />
      <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" />
    </table>

  </context>
</generatorConfiguration>

<context id="default" targetRuntime="MyBatis3">

public class DefaultJavaTypeResolver extends JavaTypeResolverDefaultImpl {

    public DefaultJavaTypeResolver() {
        super();
        typeMap.put(Types.SMALLINT, new JdbcTypeInformation("SMALLINT",
                new FullyQualifiedJavaType(Integer.class.getName())));
        typeMap.put(Types.TINYINT, new JdbcTypeInformation("TINYINT",
                new FullyQualifiedJavaType(Integer.class.getName())));
    }
}

<dependency>
    <groupId>org.mybatis.dynamic-sql</groupId>
    <artifactId>mybatis-dynamic-sql</artifactId>
    <version>1.1.4</version>
</dependency>

<context id="default" targetRuntime="MyBatis3DynamicSql">
...

<javaClientGenerator type="ANNOTATEDMAPPER"
...

<context id="default" targetRuntime="MyBatis3Simple">
...

<javaClientGenerator type="XMLMAPPER"
...

public class DefaultJavaTypeResolver extends JavaTypeResolverDefaultImpl {

    public DefaultJavaTypeResolver() {
        super();
        typeMap.put(Types.SMALLINT, new JdbcTypeInformation("SMALLINT",
                new FullyQualifiedJavaType(Integer.class.getName())));
        typeMap.put(Types.TINYINT, new JdbcTypeInformation("TINYINT",
                new FullyQualifiedJavaType(Integer.class.getName())));
    }
}

<javaTypeResolver type="club.throwable.mbg.DefaultJavaTypeResolver">
        <property name="forceBigDecimals" value="false"/>
</javaTypeResolver>
...

public class Main {

    public static void main(String[] args) throws Exception {
        List<String> warnings = new ArrayList<>();
        // 如果已经存在生成过的文件是否进行覆盖
        boolean overwrite = true;
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(Main.class.getResourceAsStream("/generator-configuration.xml"));
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator generator = new MyBatisGenerator(config, callback, warnings);
        generator.generate(null);
    }
}

<dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.4.0</version>
</dependency>

List<String> warnings = new ArrayList<>();
// 如果已经存在生成过的文件是否进行覆盖
boolean overwrite = true;
File configFile = new File("ClassPath路径/generator-configuration.xml");
ConfigurationParser cp = new ConfigurationParser(warnings);
Configuration config = cp.parseConfiguration(configFile);
DefaultShellCallback callback = new DefaultShellCallback(overwrite);
MyBatisGenerator generator = new MyBatisGenerator(config, callback, warnings);
generator.generate(null);

<plugins>
    <plugin>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-maven-plugin</artifactId>
        <version>1.4.0</version>
        <executions>
            <execution>
                <id>Generate MyBatis Artifacts</id>
                <goals>
                    <goal>generate</goal>
                </goals>
            </execution>
        </executions>
        <configuration>
            <!-- 输出详细信息 -->
            <verbose>true</verbose>
            <!-- 覆盖生成文件 -->
            <overwrite>true</overwrite>
            <!-- 定义配置文件 -->
            <configurationFile>${basedir}/src/main/resources/generator-configuration.xml</configurationFile>
        </configuration>
    </plugin>
</plugins>