mybatis学习

1.mybatis基础

1.1创建一个基于maven的mybatis工程

（1）创建数据库表

CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(255) DEFAULT NULL,
  `sex` int(11) DEFAULT NULL,
  `birth_day` datetime DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=14 DEFAULT CHARSET=utf8;

(2)创建一个maven工程，其pom.xml为

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.jsoft</groupId>
  <artifactId>mybatisdemo</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>mybatisdemo</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <!-- Mybatis核心 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.7</version>
    </dependency>

    <!-- MySQL驱动 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.3</version>
    </dependency>

    <!-- log4j日志,为了展示mysql的sql语句 -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

  </dependencies>
</project>

(3).创建一个log4j配置文件log4j.xml，在resources包下,主要是展示mybatis调试过程

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

(4).创建一个实体类User和t_user表对应

public class User {
    private Integer id;
    private String userName;
    private Integer  sex;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getSex() {
        return sex;
    }

    public void setSex(Integer sex) {
        this.sex = sex;
    }
    
}

(5)创建一个mapper接口类UserMapper.xml

public interface UserMapper {
    /**
     * 添加用户信息
     */
    int insertUser();
    }

（6）创建mybatis配置文件-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>

    <settings>
        <!--将表中字段的下划线自动转换为驼峰,没有转化的则无法填充-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>
    <!--
    别名的好处
    <select id="ListAll" resultType="com.mxz.mybatis.domain.User">
    select id, name, salary from t_user
    </select>
    如果没有别名：入参或者出参是类的必须带报名，有别名后就可以直接用类名：

    -->
    <typeAliases>
        <package name="com.jsoft.po"/>
    </typeAliases>
    <!--设置连接数据库的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://192.168.4.175:3306/mybatis?characterEncoding=utf-8"/>
                <property name="username" value="app"/>
                <property name="password" value="c536e510"/>
            </dataSource>
        </environment>
    </environments>


    <!--引入映射文件-->
    <!--
    1.一个一个引入，麻烦
     <mapper resource="UserMappers.xml"/>
       <mapper resource="com/jsoft/mapper/UserMappers.xml"/>
    2.引入包，推荐
    注意：
			1. 此方式必须保证mapper接口和mapper映射文件必须在相同的包下
			2. mapper接口要和mapper映射文件的名字一致
	 <package name="com.jsoft.mapper"/>
    -->
    <mappers>


        <package name="com.jsoft.mapper"/>

    </mappers>
</configuration>

(7)测试类

public class AppTest 
{
   

    @Test
    public void testInsertUser() throws IOException {

        UserMapper userMapper = getMapper();
        //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的SQL语句
        int result = userMapper.insertUser();

    }
    public static UserMapper  getMapper()throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //获取sqlSession，此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务
        //SqlSession sqlSession = sqlSessionFactory.openSession();
        //创建SqlSession对象，此时通过SqlSession对象所操作的sql都会自动提交
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //通过代理模式创建UserMapper接口的代理实现类对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        return userMapper;
    }
}

（8）总结

1.mybatis核心类

<dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.7</version>
    </dependency>
    <!-- MySQL驱动 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.3</version>
    </dependency>

2.mybatis的模式mapper.xml和接口需要在同一class目录下，Mapper接口类名和xml配置名同名

1.2 mybatis-config.xml配置文件详解

1.2.1属性解释

配置项	含义	解释
configuration	包裹所有配置标签	整个配置文件的顶级标签。
properties	属性	该标签可以引入外部配置的属性，也可以自己配置。该配置标签所在的同一个配置文件中的其他配置均可引用此配置中的属性。
settings	全局参数	用来配置一些改变运行时行为的信息。例如是否使用缓存机制，是否使用延迟加载，是否使用错误处理机制等。并且可以设置最大并发请求数量、最大并发事务数量，以及是否启用命名空间等。
typeAliases	别名	用来设置一些别名来替代Java的长类型声明（如: java.lang.int变为int），减少配置编码的冗余。
typeHandlers	类处理器	将SQL中返回的数据库类型转换为相应的Java类型的处理器配置。
objectFactory	对象工厂	实例化目标类的工厂类配置。
plugins	插件	可以通过插件修改MyBatis的核心行为，例如对语句执行的某一点进行拦截调用。
environments	环境集合属性对象	数据库环境信息的集合。在一个配置文件中，可以有多种数据库环境集合，这样可以使MyBatis将SQL同时映射至多个数据库。
environment	环境子属性对象	数据库环境配置的详细配置
transactionManager	事务管理	指定MyBatis的事务管理器。
dataSource	数据源	使用其中的type指定数据源的连接类型，在标签对中可以使用property属性指定数据库连接池的其他信息
mappers	映射器	配置SQL映射文件的位置，告知MyBatis去哪里加载SQL映射配置。

注意：元素有先后顺序

1.2.2 properties属性配置

（1）创建属性文件 database.properties

mysqldriver=com.mysql.cj.jdbc.Driver
mysqlurl=jdbc:mysql://192.168.152.184:3306/jdbcstudb?allowMultiQueries=true
mysqluser=root
mysqlpwd=123456

（2）在mybatis-config.xm文件配置引用

    <properties resource="database.properties"></properties>

在config.xml文件里用${属性名称}直接引用

<!--设置连接数据库的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${mysqldriver}"/>
                <property name="url" value="${mysqlurl}"/>
                <property name="username" value="${mysqluser}"/>
                <property name="password" value="${mysqlpwd}"/>
            </dataSource>
        </environment>
    </environments>

1.2.3 settings（设置）

settings配置也是MyBatis全局配置文件中比较重要的配置，它影响MyBatiis框架在运行时的一些行为。settings配置缓存、延迟加载、结果集控制、执行器、分页设置、命名规则等一系列控制性参数，与MyBatis的运行性能息息相关。所有的setting配置都被包裹在settings标签对中。




eg:

  <settings>
        <!--将表中字段的下划线自动转换为驼峰,没有转化的则无法填充-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>

1.2.4 typeAliases别名

就是跟实体类映射类取一个别名。在mapper配置文件里如下：

  <select id="ListAll" resultType="com.mxz.mybatis.domain.User">
    select id, name, salary from t_user
    </select>

别名的好处:
如果没有别名：入参或者出参是类的必须带报名，有别名后就可以直接用类名：

<select id="getUserById" resultType="User">
        select * from t_user where id=4
    </select>

eg：

 <typeAliases>
        <package name="org.example.pojo"/>
    </typeAliases>

1.2.5 plugins（插件）

在某种情况下，需要在执行程序的过程中对某一点进行拦截，并在拦截后做出一系列处理，此时就需要使用一种“拦截器”。在MyBatis中，对某种方法进行拦截调用的机制，被称为 plugin 插件。使用 plugin 可以很好地对方法地调用进行监控，而且还可以修改或重写方法的行为逻辑。在 MyBatis 中允许使用 plugin 来拦截的方法如下

Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
ParameterHandler (getParameterObject, setParameters)
ResultSetHandler (handleResultSets, handleOutputParameters)
StatementHandler (prepare, parameterize, batch, update, query)

插件使用场景

插件使用的场景有：日志记录、权限控制、缓存控制、分页等。
使用plugin拦截和覆盖MyBatis的核心方法时，一定要小心谨慎，否则可能会影响MyBatis的核心功能

1.2.6 environments（环境配置）

在MyBatis全局配置文件中，environments是放置有关数据库连接数据的配置标签，所有与外部数据库进行交互的数据都配置在该标签中，在environments标签中可以配置多个数据库连接环境，以便SQL语句可以适用于多个数据库环境。

在environments中可以配置一个个单独的environment，它们代表多个数据库环境的配置信息。每个environment都包含事务管理器（transactionManager）和数据源（dataSource）信息。如下是一个完整的environments配置：

<environments default="mysqlDev">
        <environment id="mysqlDev">
            <!--            事务管理-->
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${mysqldriver}"/>
                <property name="url" value="${mysqlurl}"/>
                <property name="username" value="${mysqluser}"/>
                <property name="password" value="${mysqlpwd}"/>
            </dataSource>
        </environment>
    </environments>

1.2.7 mappers（映射器）

MyBatis是基于SQL映射配置的框架，SQL语句都写在Mapper配置文件中，那么当构建SqlSession类之后，是需要读取Mapper 配置文件中的SQL配置。而mappers标签就是用来配置需要加载的SQL映射配置文件路径的。

mappers标签下有许多mapper子标签，每一个mapper子标签中配置的都是一个独立的Mapper映射配置文件的路径。有以下几种配置方式：
（1）使用相对路径进行配置

<mappers>
    <mapper resource="org/mybatis/mappers/UserMapper.xml"/>
    <mapper resource="org/mybatis/mappers/ProductMapper.xml"/>
    <mapper resource="org/mybatis/mappers/ManagerMapper.xml"/>
</mappers>

(2)使用接口信息进行配置

<mappers>
    <mapper class="org.mybatis.mappers.UserMapper"/>
    <mapper class="org.mybatis.mappers.ProductMapper"/>
    <mapper class="org.mybatis.mappers.ManagerMapper"/>
</mappers>

(3)使用接口所在包进行配置

<mappers>
    <package name="org.mybatis.mappers"/>
</mappers>

使用第三种方式更简单，但必须保证（1）：xxx.xml和接口类在同一class目录下(2)xml和java类名必须一样，如UserMapper.java,UserMapper.xml

1.3 Mapper.xml映射文件

Mapper映射文件是在实际开发过程中使用最多的。Mapper文件中包含的元素有：

• cache – 配置给定命名空间的缓存。

• cache-ref – 从其他命名空间引用缓存配置。

• resultMap – 映射复杂的结果对象。

• sql – 可以重用的 SQL 块,也可以被其他语句引用。

• insert – 映射插入语句

• update – 映射更新语句

• delete – 映射删除语句

1.3.1 命名空间

namespac就是对应的接口类，一个接口对应一个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">
<!--
  namespace绑定了与之对应的接口,值是该接口的全限定名;这个参数有且只有一个
-->
<mapper namespace="cn.rainbowbus.dao.CustomerMapper">

</mapper>

1.3.2 sql

可以重用的 SQL 块,也可以被其他语句引用,目的是多处使用
id为key,在其它地方通过引用
注意sql代码块，里可携带参数

<!--id为key,在其它地方通过<include refid="sql的ID" />引用-->
    <sql id="tbl_insert">
        user_name,sex,birth_day
    </sql>
    <sql id="inserval">
        #{userName},#{sex},#{birthDay}
    </sql>
 <!-- 引用SQL -->
<insert id="addUser"  useGeneratedKeys="true" keyProperty="id">
        insert into t_user(<include refid="tbl_insert"/> )values(<include refid="inserval"/>)
    </insert>

1.3.2 insert语句

1.id 对应接口方法名
2.useGeneratedKeys=“true” keyProperty=“自增长主键名” 自增长主键
3.parameterType： 传入参数对象的类，如果是对象如com.jsoft.po.User,此参与一般可省略

（1）参数是对象或者Map
参数是MAP,和实体类其实是一致的
java方法

 int addUser(User user);
 int addUser1(Map user);

xml配置

    <insert id="addUser"  useGeneratedKeys="true" keyProperty="id">
        insert into t_user(<include refid="tbl_insert"/> )values(<include refid="inserval"/>)
    </insert>

    <insert id="addUser1"  useGeneratedKeys="true" keyProperty="id" parameterType="java.util.Map">
        insert into t_user(<include refid="tbl_insert"/> )values(<include refid="inserval"/>)
    </insert>

1.3.3 select语句

1.id：和接口方法名对应
2.resultType ：返回的记录集合类型，基础类型：string int map list ,类对象：jsoft.com.User
3.parameterType： 传入参数对象的类，如果是对象如com.jsoft.po.User,此参与一般可省略

 <select id="getListByParam" resultType="User" >
        select * from t_user where user_name= #{userName} and sex=#{sex}
    </select>
    <select id="getListBySingleParam" resultType="User" >

         select * from t_user where user_name= #{userName}
    </select>

    <select id="getListByMapParam" resultType="User">
         select * from t_user where user_name= #{userName} and sex=#{sex}

    </select>

    <select id="getListByBeanParam" resultType="User">
          select * from t_user where user_name= #{userName} and sex=#{sex}
    </select>


    <select id="getCount" resultType="int">
        select count(*) from t_user;
    </select>

    <select id="getUserName" resultType="string">
          select user_name from t_user where id=4
    </select>

    <select id="getUser" resultType="User">
        select * from t_user
    </select>

    <select id="getMapById" resultType="map">
          select * from t_user where id=#{id}
    </select>

    <select id="getAllMap" resultType="map">
         select * from t_user
    </select>

    <select id="getAllUserToMap" resultType="map">
         select * from t_user
    </select>

    <select id="getUsersByName" resultType="User">
        select * from t_user where user_name like "%"#{userName}"%"
    </select>

1.3.4 update语句

1.id和 parameterType，和select一致

<update id="updateByExample" parameterType="map" >
  
    update t_dept
    set id = #{record.id,jdbcType=INTEGER},
      dept_name = #{record.deptName,jdbcType=VARCHAR}
    <if test="_parameter != null" >
      <include refid="Update_By_Example_Where_Clause" />
    </if>
  </update>

1.3.5 delete语句

1.id和 parameterType，和select一致

<delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
    delete from t_dept
    where id = #{id,jdbcType=INTEGER}
</delete>

1.3.6输入参数和读取

java接口和mapper.xml文件里面获取参数对应关系
1.在xml里用parameterType来标明参数的类型。
parameterType一般情况下可省略不写
(1)如果是对象（java本身对象和自定义对象）就用包.类名(自定义类可以配置别名)

<delete parameterType="java.lang.Integer/java.util.Date/java.util.Map/com.jsoft.po.User">
</delete >

(2)也可以用简写如string map list int等

<delete parameterType="string/map/list/int">
</delete >

2.多参数传递@Param
在java里定义是，参数变量前必须加@Param(“在xml文件来取的变量名”)，如@Param(“userName”)
这在xml文件里${userName}

 int addParam(@Param("userName")String s1,@Param("sex")Integer s2);

3.list或者数组传递

Java
注意：即使是单个参数，必须使用@Param(“ids”)来定义 ，否则报错
list和array对应的mapper.xml写法都一样，一般都通过foreach 来循环

/**
     * 入参为list
     * @param ids
     * @return
     */
    List<User> getListByListParam(@Param("ids") List<Integer> ids);
 /**
     * 入参为数组
     * @param ids
     * @return
     */
    List<User> getListByArrayParam(@Param("ids") Integer[] ids);

xml

 <select id="getListByListParam" resultType="User">
        select * from t_user where id in
        <foreach collection="ids" item="id" index="index" open="(" close=")" separator=",">
            #{id}
        </foreach>
    </select>
    <select id="getListByArrayParam" resultType="User">
        select * from t_user where id in
        <foreach collection="ids" item="id" index="index" open="(" close=")" separator=",">
            #{id}
        </foreach>
    </select>```

4.mapper.xml文件里读取入参，用#{}还是${}
#{} 在编译时用sql预处理占位符 ?,然后把值注入，避免SQL注入，一般采用#{}
${}直接把值读出来，和其他SQL拼接成SQL,不会使用预处理占位符?
eg:

<select id="getUserByIds" resultType="User">
          select * from t_user where id=#{id}
 </select>

    <select id="getUserByIds" resultType="User">
          select * from t_user where id=${id}
    </select>

下面不能#{}

 <delete id="deleteByIds">
   delete from student where in(${ids}); 而不能写成：delete from student where in(#{ids});
  </delete>

1.3.7 mapper.xml返回参数

xml里返回参数用resultType来标注返回的对象类型，有java对象：string int map 简写，也可以用java.lang.String
自定义类就用如:com.jsoft.Usesr，也可以用别名

（1）java接口和mapper.xml文件的对接

 /**
     * 返回一个基本类型
     *     <select id="getCount" resultType="int">
     *         select count(*) from t_user;
     *     </select>
     * @return
     */
   public  int getCount();

    /**
     * 返回一个字符串
     *   <select id="getUserName" resultType="string">
     *           select user_name from t_user where id=4
     *     </select>
     */
   public    String getUserName();

    /**
     * 如果查询语句返回多条数据，程序报错
     *  <select id="getUser" resultType="User">
     *         select * from t_user
     *  </select>
     * @return
     */
  public     User getUser();

2.用map数据类型来返回
有时候，我们不想定义一个bean，则可以用map来代替
（1）返回对象是map
返回对象是map，相当于一个bean,mybatis会自动把map.put(字段名,字段值)填充进去，
如意如果这个字段值是null.不会压入值put.put(字段名,null)
Java

   public  Map<String,Object> getMapById(Integer id);

xml

 <select id="getMapById" resultType="map">
     select * from t_user where id=#{id}
 </select>

读取

 @Test
    public void TestListMapParam()throws IOException {
        UserMapper userMapper = getMapper();
        //一条数据，map相当于bean
        Map<String,Object> map=userMapper.getMapById(13);
        for (String key : map.keySet()) {
            System.out.println("key= " + key + " and value= " + map.get(key));
        }
    }
    

(2).返回对象是List

  /**
     * list<map>返回多条记录， resultType="map"
     * 
     * @return
     */
    List<Map<String,Object>> getListMap();

xml
注意：resultType是map，不是list

 <select id="getAllMap" resultType="map">
     select * from t_user
  </select>

测试读取

@Test
    public void TestListMapParam1()throws IOException {
        UserMapper userMapper = getMapper();
        List<Map<String,Object>> list=userMapper.getListMap();
        for(Map<String,Object> map:list){
            System.out.println("======================");
            for (String key : map.keySet()) {
            System.out.println("key= " + key + " and value= " + map.get(key));
            }

        }
    }

(3)@MapKey注解读取多行
@MapKey注解，形成一个map<主键值,map<String,Object>的对象，就是把主键值和这条数据的map对应起来

接口

@MapKey("id")
    Map<Integer, Map<String,Object>> getAllUserToMap();

xml

<select id="getAllUserToMap" resultType="map">
         select * from t_user
 </select>

测试

@Test
    public void TestListMapParam2()throws IOException {
        UserMapper userMapper = getMapper();
         Map<Integer,Map<String,Object>> map=userMapper.getAllUserToMap();
        for (Integer key : map.keySet()) {

            System.out.println("key= " + key + " and value= " +map.get(key));
            Map<String,Object> m=map.get(key);
            for (String k : m.keySet()) {
            System.out.println("field= " + k + " , value= " + m.get(k));
            }
        }
    }

1.4mybatis语法

1.4.1 循环语句-foreach

<select id="getListByListParam" resultType="User">
    select * from t_user where id in
    <foreach collection="ids" item="id" index="index" open="(" close=")" separator=",">
        #{id}
    </foreach>
</select>

参数说明：

collection :list或者数据的名称，注意：参数如果使用了@Param(“ids”)来声明，则这里就用声明的属性名，否则默认是list
item: 循环出来的变量名，如xx,则循环里可以用#{xx}或者#{xx.xx}来取值
index: 索引名称，从0开始，循环里可以通过#{index}来取值
separator： 分隔符，拼接sql用的符号
open:循环开始时增加的前缀
close:循环结束时增加的后缀

java接口:

 /**
     * 入参为list
     */
    List<User> getListByListParam(@Param("ids") List<Integer> ids);

    /**
     * 入参为数组
     */
    List<User> getListByArrayParam(@Param("ids") Integer[] ids);

xml

<select id="getListByListParam" resultType="User">
        select * from t_user where id in
        <foreach collection="ids" item="id" index="index" open="(" close=")" separator=",">
            #{id}
        </foreach>
    </select>
    <select id="getListByArrayParam" resultType="User">
        select * from t_user where id in
        <foreach collection="ids" item="id" index="index" open="(" close=")" separator=",">
            #{id}
        </foreach>
    </select>

运行结果

eg:批量插入多条数据

<insert id="insertRepaymentProtocol"
		parameterType="java.util.List">
		insert into t_repayment_protocol
		(id,loan_id,create_time,remarks,protocol_repay_amount,
		remain_amount,protocol_repay_date,warning_status,create_by,update_by,del_flag)
		values
		<foreach collection="list" item="repay" index="index"
			separator=",">
			(
			#{repay.id},#{repay.loanId},#{repay.createTime},#{repay.remarks},
			#{repay.protocolRepayAmount},#{repay.remainAmount},#{repay.protocolRepayDate},
			#{repay.warningStatus},#{repay.createBy},#{repay.updateBy},#{repay.delFlag})
		</foreach>

	</insert>

执行效果：

1.4.2条件语句-if

【if test=“条件”】程序块[/if] 如果test的条件为true的时候，执行程序块
注意:
1.条件里面的是参数而不是参数值，所以不需要用${}
2.等于是 ==不是=（=是赋值），!= > 联接是and或者or
3.if没有对应elseif else去配套

 
<!--List<Emp> getEmpListByCondition(Emp emp);-->
<select id="getEmpListByMoreTJ" resultType="Emp"> 
   select * from t_emp where 1=1
  <if test="ename != '' and ename != null"> 
     and ename = #{ename}
  </if>
  <if test="age != '' and age != null"> 
     and age = #{age}
  </if>
  <if test="sex != '' and sex != null"> 
     and sex = #{sex}
   </if>
</select>

容易出错：
下面语法，如果传递参数为0，if将会执行，因为type=1是赋值，返回的是true

<if test="type!=null and type=1"> ORDER BY seq ASC</if>

1.4.3 where语句

where语句的好处是当后面where没有输出的时候，where将不显示，一半和if搭配使用

注意：这段代码有bug，不能去掉and

<select id="getEmpListByMoreTJ2" resultType="Emp"> select * from t_emp
<where>
  <if test="ename != '' and ename != null"> 
    ename = #{ename}
  </if>
  <if test="age != '' and age != null"> 
    and age = #{age}
  </if>
  <if test="sex != '' and sex != null"> 
    and sex = #{sex}
  </if>
</where>
</select>

也可以用 where 1=1
[if] and [/if]来实现

1.4.4 trim语句

trim用于去掉或添加标签中的内容
prefix：在trim标签中的内容的前面添加某些内容
prefixOverrides：在trim标签中的内容的前面去掉某些内容s
uffix：在trim标签中的内容的后面添加某些内容suffix
suffixOverrides：在trim标签中的内容的后面去掉某些内容

<select id="getEmpListByMoreTJ" resultType="Emp">
   select * from t_emp
 <trim prefix="where" suffixOverrides="and">
   <if test="ename != '' and ename != null">
     ename = #{ename} and
   </if>
   <if test="age != '' and age != null"> 
     age = #{age} and
   </if>
   <if test="sex != '' and sex != null"> 
     sex = #{sex}
   </if>
 </trim>
</select>

1.4.5 choose、when、 otherwise

这三个相当于if…else if…else

 
<!--List<Emp> getEmpListByChoose(Emp emp);-->
<select id="getEmpListByChoose" resultType="Emp">
  select <include refid="empColumns"></include> from t_emp
  <where>
  <choose>
  <when test="ename != '' and ename != null"> 
    ename = #{ename}
  </when>
  <when test="age != '' and age != null"> 
    age = #{age}
  </when>
  <when test="sex != '' and sex != null"> 
    sex = #{sex}
  </when>
  <when test="email != '' and email != null"> 
    email = #{email}
  </when>
</choose>
</where>
</select>

1.5特殊语法

1.5.1模糊查询

/**
 *测试模糊查询
 *@param mohu
 *@return
*/
List<User> testMohu(@Param("mohu") String mohu);

 
<!--List<User> testMohu(@Param("mohu") String mohu);-->
<select id="testMohu" resultType="User">
  <!--select * from t_user where username like '%${mohu}%'-->
  <!--select * from t_user where username like concat('%',#{mohu},'%')--> 
  select * from t_user where username like "%"#{mohu}"%"
</select>

1.5.2 批量删除

 
/**
  *批量删除
  *@param ids
  *@return
*/
int deleteMore(@Param("ids") String ids);

 
<!--int deleteMore(@Param("ids") String ids);-->
<delete id="deleteMore">
   delete from t_user where id in (${ids})
</delete>

1.5.3 动态设置表名

<!--List<User> getAllUser(@Param("tableName") String tableName);-->
  <select id="getAllUser" resultType="User"> 
    select * from ${tableName}
  </select>

1.5.4获得自增长主键

<!--int insertUser(User user);-->
<insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
 insert into t_user values(null,#{username},#{password},#{age},#{sex})
</insert>