【MyBatis】MyBatis入门笔记1（近2w字）

 
IDE： IntelliJ IDEA 2020.2
 

零 l  写在前面

---

1、以初学者的视角记录笔记
2、课程链接：[链接]
3、资料链接：[笔记对应课程的配套资料]，提取码：5m91
4、实操很重要！！！
5、本文主讲MyBatis
6、前文链接：[Spring入门笔记1] [Spring入门笔记2] [Spring入门笔记3]
 
 
 
 
 

一 l  简单介绍

---

来源：
MyBatis本是apache的一个开源项目iBatis，后经改进改名为MyBatis。
 
作用：
MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
 
原理：
Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。
 
 
 
 
 

二 l  MyBatis快速入门

---

具体流程视频中有，依赖也已经包含在了项目里。

链接：[MyBatis下载地址]
 
开发步骤如下（项目中mysql-connector-java- x.x.x.jar版本过老会报错）：

（一）创建PO（model）类，根据需求创建

PO类，可以看作是存储数据库数据的单个实体，比如一个user。
 
一般有private属性和对应的get/set方法。
 

（二）创建全局配置文件SqlMapConfig.xml

全局配置文件在在classpath（一般是src）目录下。
SqlMapConfig.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>
    <!-- 配置mybatis的环境信息，可以有多个环境所以是复数 -->
    <environments default="development">
        <environment id="development">
            <!-- 配置JDBC事务控制，由mybatis进行管理 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源，采用dbcp连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!-- 低版本的mysql链接需要指定编码，高版本需要指定时区 -->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatisday1?serverTimezone=Asia/Shanghai&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

 

（三）编写映射文件

在classpath（一般是src）目录下，创建sqlmap文件夹。在sqlmap目录下，创建User.xml映射文件。
User.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="user">
    <!-- 参数解释
        [id]：statement的id，要求在命名空间内唯一
        [parameterType]：传入参数的java类型（用来查询元素的类型）
        [resultType]：查询出的单条结果集对应的java类型
        [#{}]： 表示一个占位符?
        [#{id}]：表示该占位符待接收参数的名称为id。
        注意：如果参数为简单类型时，#{}里面的参数名称可以是任意定义
     -->
     <!-- 根据id查询 -->
    <select id="findUserById" parameterType="int" resultType="com.gyf.model.User">
        SELECT * FROM user WHERE id = #{a}
    </select>
</mapper>

 

（四）加载映射文件，在SqlMapConfig.xml中进行加载

SqlMapConfig.xml（全局配置文件）

<!-- 在configuration标签中添加如下代码，接着</environments>写 -->
<mappers>
    <mapper resource="com/gyf/sqlmap/User.xml"/>
</mappers>

 

（五）编写测试程序，即编写Java代码，连接并操作数据库

Java代码思路：
a) 读取配置文件；
b) 通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。
c) 通过SqlSessionFactory创建SqlSession。
d) 调用SqlSession的操作数据库方法。
e) 关闭SqlSession。

Demo01.java

public class Demo01 {
    @Test
    public void test1() throws IOException {
        // a)读取配置文件；
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");

        // b)通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);

        // c)通过SqlSessionFactory创建SqlSession。
        SqlSession session = sessionFactory.openSession();

        // d)调用SqlSession的操作数据库方法。
        //查询一条结果
        User user = session.selectOne("findUserById",10);
        System.out.println(user);
        session.commit();
        
        // e)关闭SqlSession。
        session.close();
    }
}

 
 
 
 
 

三 l  映射文件中的其他查询

---

（一）模糊查询用户信息

User.xml（mapper标签内）

<!--
    [${}]：表示拼接SQL字符串
    [${value}]：表示要拼接的是简单类型参数。
    注意：
    简单类型:int,byte,... string
    1、如果参数为简单类型时，${}里面的参数名称必须为value
    2、${}会引起SQL注入，一般情况下不推荐使用。但是有些场景必须使用${}，比如order by ${colname}
-->
<select id="findUserByName" parameterType="String" resultType="com.gyf.model.User">
    SELECT * FROM user WHERE username LIKE '%${value}%'
</select>

测试.java（第d步）

// 查询多条结果，匹配字符串
List<User> users = session.selectList("findUserByName","张");

 

（二）插入用户信息

User.xml（mapper标签内）

<!-- 插入数据。这里的占位是写模型(User对象)的属性 -->
<insert id="insertUser" parameterType="com.gyf.model.User">
    INSERT INTO user (username,sex,birthday,address)
    VALUE (#{username},#{sex},#{birthday},#{address});
</insert>

测试.java（第d步）

User user = new User("qwe","2",new Date(),"广州");
int affectRow = session.insert("insertUser",user);
session.commit();  // 事务提交

 

（三）删除用户信息

User.xml（mapper标签内）

<!-- 删除数据 -->
<delete id="deleteUser" parameterType="int">
    DELETE FROM user where id = #{id};
</delete>

测试.java（第d步）

int affectRow = session.delete("deleteUser",27);
session.commit();  // 事务提交

 

（四）更新用户信息

User.xml（mapper标签内）

<!-- 更新数据 -->
<update id="updateUser" parameterType="com.gyf.model.User">
    UPDATE user SET address = #{address},sex = #{sex}
    WHERE id = #{id}
</update>

测试.java（第d步）

User user = new  User();
user.setId(32);
user.setSex("男");
user.setAddress("北京");
int affectRow = session.update("updateUser",user);
session.commit();  // 事务提交

 

（五）主键返回——获取MySQL自增主键

User.xml（mapper标签内）

<!-- 插入时自动返回主键id -->
<insert id="insertUser2" parameterType="com.gyf.model.User">
    <!--
        [selectKey标签]：通过select查询来生成主键
        [keyProperty]：指定存放 "生成主键" 的属性
        [resultType]："生成主键" 所对应的Java类型
        [order]：指定该查询主键SQL语句的执行顺序，相对于insert语句，after就是在insert语句之后执行
        [last_insert_id]：MySQL的函数，要配合insert语句一起使用
    -->
    <selectKey keyProperty="id" resultType="int" order="AFTER">
        SELECT LAST_INSERT_ID()
    </selectKey>
    INSERT INTO user (username,sex,birthday,address)
    VALUE (#{username},#{sex},#{birthday},#{address});
</insert>

测试.java（第d步）

User user = new User("insert_return","2",new Date(),"广州");
int affectRow = session.insert("insertUser2",user);
session.commit();  // 事务提交

 

（六）主键返回——获取MySQL自增UUID

User.xml（mapper标签内）

<!-- 插入时自动返回UUID -->
<insert id="insertUser" parameterType="com.gyf.domain.User">
    <selectKey keyProperty="id" resultType="String" order="BEFORE">
        SELECT UUID()
    </selectKey>
    INSERT INTO USER (username,sex,birthday,address) 
    VALUES(#{username},#{sex},#{birthday},#{address})
</insert>

测试.java（第d步）

User user = new User("insert_return","2",new Date(),"广州");
int affectRow = session.insert("insertUser2",user);
session.commit();  // 事务提交

 

（七）映射文件配置总结

1、parameterType和resultType
  parameterType指定 输入参数 的java类型，可以填写别名或Java类的全限定名。
  resultType指定 输出结果 的java类型，可以填写别名或Java类的全限定名。

2、#{}和${}

	#{}	${}
解释	相当于预处理中的占位符"?"	相当于拼接SQL串，对传入的值不做任何解释的原样输出
是否可以接受 HashMap、POJO类型的参数	是	是
简单类型参数的要求	#{}里面可以是value， 也可以是其他	${}里面只能是value
是否可以防止SQL注入	是	否

3、selectOne和selectList
  selectOne：只能查询0或1条记录，大于1条记录会报错
  selectList ：可以查询0或N条记录
 
 
 
 
 

四 l  MyBatis的Dao编写

---

（一）编写dao层【一般不用，有更多好方式】

xml配置不变（使用User.xml）

UserDao.java

public interface UserDao {
    // 保存一个用户
    public void save(User user);
    public User findUserById(int id);
}

UserDaoImpl.java

public class UserDaoImpl implements UserDao {

    private SqlSessionFactory ssf;

    public UserDaoImpl() {}

    public UserDaoImpl(SqlSessionFactory ssf) { this.ssf = ssf; }

    @Override
    public void save(User user) {
        //获取session
        SqlSession session = ssf.openSession();
        //插入数据
        session.insert("insertUser",user);
        session.commit();
        session.close();
    }

    @Override
    public User findUserById(int id) {
        //获取session
        SqlSession session = ssf.openSession();
        //插入数据
        User user = session.selectOne("findUserById",id);
        session.close();
        return user;
    }
}

测试.java

public class Demo03 {
    SqlSessionFactory sessionFactory;

    @Before
    public void before() throws IOException {
        // a)读取配置文件；
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
        // b)通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。
        sessionFactory = new SqlSessionFactoryBuilder().build(is);
    }

    @Test
    public void test1() throws IOException {
        // 创建dao
        UserDao userDao = new UserDaoImpl(sessionFactory);

        User user1 = userDao.findUserById(1);
        System.out.println(user1);
        
        User user2 = new User("xxx", "x", new Date(), "xx");
        userDao.save(user2);
    }
}

 

（二）MyBatis的Dao编写【mapper代理方式实现】

Mapper代理的开发方式，只需要编写mapper接口（相当于dao接口）即可。Mybatis会自动的为mapper接口生成动态代理实现类。

不过要实现mapper代理的开发方式，需要遵循一些开发规范。

1、开发规范
（1）mapper接口 的 全限定名 要和 mapper映射文件 的 namespace的值 相同。
（2）mapper接口 的 方法名称 要和 mapper映射文件 中的 statement的id 相同；
（3）mapper接口 的 方法参数 只能有一个，且类型要和 mapper映射文件 中statement的 parameterType的值 保持一致。
（4）mapper接口 的 返回值类型 要和 mapper映射文件 中statement的 resultType值或resultMap中的type值 保持一致；

通过规范式的开发mapper接口，可以解决原始dao开发当中存在的问题：
1.去掉模板代码（如开启session、关闭session）
2.剩下去不掉的操作数据库的代码，其实就是一行代码。这行代码中硬编码的部分，通过第一和第二个规范就可以解决。

2、开始编写（不用写实现类了）
UserMapper.java

package com.gyf.mapper;
public interface UserMapper {
    /**
     * @param user
     * @return 受影响的行数
     */
    //@Insert("INSERT INTO user (username,sex,birthday,address) VALUE (#{username},#{sex},#{birthday},#{address})")
    public int save(User user);

    //@Select("SELECT * FROM user WHERE id = #{id}")
    public User findUserById(int id);
}

UserMapper.xml

<mapper namespace="com.gyf.mapper.UserMapper">
   <insert id="save" parameterType="user">
      INSERT INTO user (username,sex,birthday,address)
        VALUE (#{username},#{sex},#{birthday},#{address})
   </insert>

    <select id="findUserById" parameterType="int" resultType="user">
        SELECT * FROM user WHERE id = #{id}
    </select>
</mapper>

SqlMapConfig.xml（全局配置文件）【不需要之前的那个User.xml的配置文件了】
（这里只是mapper标签的资源改了一下）

<configuration>
    <!-- 配置mybatis的环境信息，内容省略了 -->
    <environments default="development">
        ...
    </environments>

    <mappers>
        <mapper resource="com/gyf/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

测试.java

public class Demo04 {
    SqlSession session;
    @Before
    public void before() throws IOException {
        // a)读取配置文件；
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
        // b)通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);
        session = sessionFactory.openSession();
    }

    @After
    public void after(){
        session.close();
    }

    @Test
    public void test1() throws IOException {
        UserMapper userMapper =  session.getMapper(UserMapper.class);
        
        // 获取用户数据
        System.out.println(userMapper.findUserById(1));

        // 插入用户数据
        User user2 = new User("xxx","x",new Date(),"xx");
        userMapper.save(user2);
        session.commit();
    }
}

 
 
 
 
 

五 l  Mybatis的全局配置文件中的其它配置

---

（一）db.properties数据库文件配置（properties、environments标签）

（跟Spring的JdbcTemplate差不多[前文链接]）
【旧版mysql-connector-java】src/db.properties（不用双引号把字符串括起来）：

driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatisday1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=UTF-8
name=root
password=你的mysql密码

【新版mysql-connector-java】src/db.properties（不用双引号把字符串括起来）：

driverClass=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatisday1?serverTimezone=Asia/Shanghai
name=root
password=你的mysql密码

SqlMapConfig.xml（全局配置文件）

<configuration>
    <properties resource="db.properties"/>

    <!-- 配置mybatis的环境信息 -->
    <environments default="development">
        <environment id="development">
            <!-- 配置JDBC事务控制，由mybatis进行管理 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源，采用dbcp连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="${driverClass}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${name}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="com/gyf/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

 

（二）typeAliases（typeAliases标签）

别名是为了在映射文件中，更方便的去指定参数和结果集的类型，不再用写很长的一段全限定名。
SqlMapConfig.xml（全局配置文件）
1、MyBatis默认的别名（一般用不到）

映射的类型	别名
boolean	_boolean
Boolean	boolean
byte	_byte
Byte	byte
short	_short
Short	short
int	_int、_integer
Integer	int、integer
long	_long
Long	long
float	_float
Float	float
double	_double
Double	double
String	string
Date	date
BigDecimal	decimal
BigDecimal	bigdecimal

2、自定义别名
对单个类起别名：

<typeAliases>
    <typeAlias type="全限定名" alias="别名"/>
</typeAliases>

对一整个package的类都起别名
【自动对所有类进行变换，别名就是类名第一个字母小写。比如第一个小写 User，别名就是user。】

<typeAliases>
    <package name="具体包名"/>
</typeAliases>

例子：
SqlMapConfig.xml（全局配置文件）

<configuration>
   <properties resource="db.properties"/>

   <!--配置别名-->
   <typeAliases>
       <typeAlias type="com.gyf.model.User" alias="user"/>
       <package name="com.gyf.model"/>
   </typeAliases>

   <!-- 配置mybatis的环境信息，内容省略了 -->
   <<environments default="development">
       ...
   </environments>

   <mappers>
       <mapper resource="com/gyf/mapper/UserMapper.xml"/>
   </mappers>
</configuration>

 

（三）加载映射文件的几种方式（mappers标签）

1、相对路径：<mapper resource=’’/>
UsrMappler.xml

<mappers>
    <mapper resource="com/gyf/mapper/UserMapper.xml"/>
</mappers>

2、绝对路径（一般不用）：<mapper url=’’/>
UsrMappler.xml

<mappers>
    <mapper resource="file:///D:\workspace_spingmvc\mybatis_01\config\sqlmap\User.xml"/>
</mappers>

3、写类名：<mapper class=’’/>
UsrMappler.xml

<mappers>
    <mapper resource="com/gyf/mapper/UserMapper.xml"/>
</mappers>

注意：
1.此种方法要求mapper接口和mapper映射文件要名称相同，且放到同一个目录下
2.也可使用注解开发，把xml文件删除

【不灵活】注解用法（不用xml文件，只用.java的接口，把xml文件内容放在注解里）：
UserMapper.java

public interface UserMapper {
    /**
     * @param user
     * @return 受影响的行数
     */
    @Insert("INSERT INTO user (username,sex,birthday,address) VALUE (#{username},#{sex},#{birthday},#{address})")
    public int save(User user);

    @Select("SELECT * FROM user WHERE id = #{id}")
    public User findUserById(int id);
}

4、写包名（推荐）：<package name=’’/>
UsrMappler.xml

<mappers>
    <mapper resource="com/gyf/mapper/UserMapper.xml"/>
</mappers>

注意：
1.此种方法要求mapper接口和mapper映射文件要名称相同，且放到同一个目录下

 

（四）setting【了解】

具体配置：


 
 
 
 
 

六 l  Mybatis的映射文件

---

（一）输入映射——ParameterType

指定输入参数的java类型，可以使用别名或者类的全限定名。它可以接收简单类型、POJO对象、HashMap。

1、传递简单类型（parameterType=“int”）
UsrMappler.xml

<!-- 根据用户ID查询用户信息 -->
<select id="findUserById" parameterType="int" resultType="com.gyf.model.User">
    SELECT * FROM user WHERE id = #{id}
</select>

2、传递POJO对象（parameterType=“com.gyf.model.User”）
UsrMappler.xml

<!-- 插入用户信息 -->
<insert id="save" parameterType="com.gyf.model.User">
   INSERT INTO user (username,sex,birthday,address)
     VALUE (#{username},#{sex},#{birthday},#{address})
</insert>

3、传递POJO包装对象
多表查询等复杂查询，传入信息单个类不够用，可以使用包装对象传递输入参数。
需求：
vo：键值对对象，相对于KeyValue
po(persist object)：持久化对象
pojo：简单的java对象
entity：实体

（1）定义POJO包装类
UserQueryVO.java

public class UserQueryVO {
    private User user;
    private Order order;
    
    public User getUser() { return user; }
    public void setUser(User user) { this.user = user; }
    public Order getOrder() { return order; }
    public void setOrder(Order order) { this.order = order; }
}

（2）配置接口
UserMapper.java

public interface UserMapper {
    public List<User> findUserByUserQueryVo(UserQueryVO vo);
}

（3）配置映射文件
UsrMappler.xml

<!-- 通过包装类查询用户 -->
<select id="findUserByUserQueryVo" parameterType="userQueryVO" resultType="user">
    SELECT u.* FROM user u WHERE u.id = #{user.id}
</select>

里面的user.id是userQueryVO里user对象的id

（4）配置测试
Demo05.java

public class Demo05 {
    SqlSession session;
    @Before
    public void before() throws IOException {
        ...
    }
    @After
    public void after() {
        ...
    }
    @Test
    public void test1() throws IOException {
        UserMapper userMapper = session.getMapper(UserMapper.class);

        //通过模型的包装类来查询用户
        UserQueryVO query = new UserQueryVO();

        User user = new User();
        user.setId(1);
        query.setUser(user);

        Order order = new Order();
        order.setNumber("100111");
        query.setOrder(order);

        List<User> list = userMapper.findUserByUserQueryVo(query);
        System.out.println(list);
    }
}

4、传递Map对象
（1）配置接口
UserMapper.java

public interface UserMapper {
    public List<User> findUserByMap(Map<String,Object> map);
}

（2）配置映射文件
UsrMappler.xml

<!-- 通过包装类查询用户 -->
<select id="findUserByUserQueryVo" parameterType="userQueryVO" resultType="user">
    SELECT u.* FROM user u WHERE u.id = #{user.id}
</select>

里面的user.id是userQueryVO里user对象的id

（3）配置测试
Demo05.java

public class Demo05 {
    SqlSession session;
    @Before
    public void before() throws IOException {
        ...
    }
    @After
    public void after() {
        ...
    }
    @Test
    public void test2() throws IOException {
        UserMapper userMapper = session.getMapper(UserMapper.class);

        //查询条件
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("username", "张");
        map.put("sex", "2");

        List<User> list = userMapper.findUserByMap(map);
        System.out.println(list);
    }
}

 

（二）输出映射——resultType

使用resultType进行结果映射时，查询的 列名 和映射的pojo 属性名 完全一致，该列才能映射成功。

如果查询的列名和映射的pojo属性名全部不一致，则不会创建pojo对象；
如果查询的列名和映射的pojo属性名有一个一致，就会创建pojo对象。

UsrMappler.xml
1、输出简单类型（resultType=“int”，返回int类型）

<!-- 设置返回数据为基本类型,int,double,long,string.... -->
<!-- 查询用户的个数 -->
<select id="findUserCount" parameterType="userQueryVO" resultType="int">
    SELECT COUNT(*) FROM  user WHERE sex = #{user.sex}
</select>

2、输出POJO单个对象（resultType=“user”，返回user类型）

<select id="findUserById" parameterType="int" resultType="user">
    SELECT * FROM  user WHERE id = #{?}
</select>

3、输出POJO列表（resultType=“user”，返回List<User>类型）

<select id="findUserList" parameterType="userQueryVO" resultType="user">
    SELECT * FROM  user WHERE sex=#{user.sex} AND username LIKE '%${user.username}%'
</select>

总结：
1.输出单个pojo对象和pojo列表时，mapper映射文件中的resultType的类型是一样的，mapper接口的方法返回值不同。
2.同样的mapper映射文件，返回单个对象和对象列表时，mapper接口在生成动态代理的时候，会根据返回值的类型，决定调用selectOne方法还是selectList方法。

 

（三）输出映射——resultMap

如果查询出来的列名和属性名不一致，通过定义一个resultMap将列名和pojo属性名之间作一个映射关系。
a）定义resultMap
b）使用resultMap作为statement的输出映射类型

UsrMappler.xml

<!-- 设置返回数据为resultMap -->
<resultMap id="userResultMap" type="user">
    <id property="id" column="id_"></id>
    <result property="username" column="username_"></result>
    <result property="sex" column="sex_"></result>
    <result property="birthday" column="birthday_"></result>
    <result property="address" column="address_"></result>
</resultMap>

<select id="findUserByIdResultMap" parameterType="int" resultMap="userResultMap">
    SELECT
     id id_,
     username username_,
     sex sex_,
     birthday birthday_,
     address address_
    FROM user WHERE id = #{id}
</select>

 
 
 
 
 

七 l  动态SQL

---

（一）if和where

<where>相当于直接写where，<if>条件成立后，直接拼接在where后（开头and会自动删除，不会报错）
UserMapper.xml

<!-- if和where的使用 -->
<select id="findUserList" parameterType="userQueryVO" resultType="user">
    SELECT * FROM user
    <where>
        <if test="user != null">
            <if test="user.sex != null and user.sex != ''">
                sex = #{user.sex}
            </if>
            <if test="user.username != null and user.username != ''">
                and username LIKE '%${user.username}%'
            </if>
            <if test="user.address != null and user.address != ''">
                and address LIKE '%${user.address}%'
            </if>
        </if>
    </where>
</select>

 

（二）sql片段

Mybatis提供了SQL片段的功能，可以提高SQL的可重用性。
UserMapper.xml

<sql id="select_user_where">
    <if test="user != null">
        <if test="user.sex != null and user.sex != ''">
            sex = #{user.sex}
        </if>
        <if test="user.username != null and user.username != ''">
            and username LIKE '%${user.username}%'
        </if>
        <if test="user.address != null and user.address != ''">
            and address LIKE '%${user.address}%'
        </if>
    </if>
</sql>

<select id="findUserList" parameterType="userQueryVO" resultType="user">
    SELECT * FROM user
    <where>
        <include refid="select_user_where"/>
    </where>
</select>

 

（三）foreach 遍历

1、使用VO对象传参

UserQueryVO.java

public class UserQueryVO {
    private List<Integer> ids;
    public List<Integer> getIds() { return ids; }
    public void setIds(List<Integer> ids) { this.ids = ids; }
}

UserMapper.java（接口里面添加方法）

/*查找多个id的用户数据*/
public List<User> findUserByIds(UserQueryVO vo);

UserMapper.xml

<select id="findUserByIds" parameterType="userQueryVO" resultType="user">
    <!--性别和名字 SELECT * FROM user WHERE id in (1,2,3) -->
    SELECT * FROM user
    <where>
        <if test="ids != null and ids.size > 0">
            <!--
                collection:集合,写集合属性
                item:遍历的变量（跟i差不多）
                open:遍历开始需要拼接的字符
                close：遍历结束需要拼接的字符
                separator:拼接格式（每个变量中的分隔符）
                for(Integer id : ids){}
            -->
            <foreach collection="ids" item="id" open="id in(" close=")" separator=",">
                ${id}
            </foreach>
        </if>
    </where>
</select>

测试.java

public void test4() throws IOException {
    UserMapper userMapper =  session.getMapper(UserMapper.class);
    
    //查询条件
    UserQueryVO query = new UserQueryVO();
    List<Integer> ids = new ArrayList<Integer>();
    ids.add(1);
    ids.add(10);
    ids.add(16);
    
    query.setIds(ids);
    List<User> users = userMapper.findUserByIds(query);
    System.out.println(users);
}

2、使用List传参（更方便）

不用写UserQueryVO.java

UserMapper.java（接口里面添加方法）

/*查找多个id的用户数据*/
public List<User> findUserByIds2(List<Integer> ids);

UserMapper.xml（数组的变量名统一为list，通用的类型是collection）

<!-- 5.参数是数组
    如果参数是数组的话，parameterType可以写全名【java.util.List】，也可以写别名【list】
    遍历或者判断的时候，都用list变量
-->
<select id="findUserByIds2" parameterType="list" resultType="user">
    <!--性别和名字 SELECT * FROM user WHERE id in (1,2,3) -->
    SELECT * FROM user
    <where>
        <if test="list != null and list.size > 0">
            <foreach collection="list" item="id" open="id in(" close=")" separator=",">
                ${id}
            </foreach>
        </if>
    </where>
</select>

测试.java

public void test5() throws IOException {
    UserMapper userMapper =  session.getMapper(UserMapper.class);

    //查询条件
    List<Integer> ids = new ArrayList<Integer>();
    ids.add(1);
    ids.add(10);
    ids.add(16);

    List<User> users = userMapper.findUserByIds2(ids);
    System.out.println(users);
}

 
 
 
 
 

八 l  mybatis与hibernate的区别

---

1、Mybatis技术特点：
优点：

（1）通过直接编写SQL语句，可以直接对SQL进行性能的优化；
（2）学习门槛低，学习成本低。只要有SQL基础，就可以学习mybatis，而且很容易上手；
（3）由于直接编写SQL语句，所以灵活多变，代码维护性更好。

缺点：

（1）不能支持数据库无关性，即数据库发生变更，要写多套代码进行支持，移植性不好。
    >>> 比如分表代码：Mysql是limit；Oracle是rownum。
（2）需要编写结果映射。

2、Hibernate技术特点：
优点：

（1）标准的orm框架，程序员不需要编写SQL语句。
（2）具有良好的数据库无关性，即数据库发生变化的话，代码无需再次编写。（mysql数据迁移到oracle，只需要改方言配置）

缺点:

（1）学习门槛高，需要对数据关系模型有良好的基础，而且在设置OR映射的时候，需要考虑好性能和对象模型的权衡。
（3）程序员不能自主的去进行SQL性能优化。

Mybatis应用场景：
需求多变的互联网项目，例如电商项目。

Hibernate应用场景：
需求明确、业务固定的项目，例如OA(办公自动化)项目、ERP(企业资源计划)项目等。