Mybatis介绍

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

JDBC存在的问题

1、 数据库连接创建、释放频繁造成系统资源浪费，从而影响系统性能。如果使用数据库连接池可解决此问题。
2、 Sql语句在代码中硬编码，造成代码不易维护，实际应用中sql变化的可能较大，sql变动需要改变java代码。
3、 使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护。
4、 对结果集解析存在硬编码（查询列名），sql变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成pojo对象解析比较方便。

Mybatis架构

Mybatis架构

Mybatis使用

mybaits的代码由github.com管理

下载地址：https://github.com/mybatis/mybatis-3/releases

mybatis如下：

图片.png

目录结构

• mybatis-3.2.7.jar mybatis的核心包
• lib文件夹 mybatis的依赖包所在
• mybatis-3.2.7.pdf mybatis使用手册

创建核心配置文件

<?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>
    <!-- 和spring整合后 environments配置将废除 -->
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理 -->
            <transactionManager type="JDBC" />
            <!-- 数据库连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url"
                          value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
</configuration>

• src目录下创建log4j.properties jdbc.properties

# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

• 创建pojo映射文件 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="test">
    <select id="queryUserById" parameterType="Integer" resultType="cn.probuing.mybatisintro.pojo.User">
        SELECT *
        FROM `user`
        WHERE id = #{v}
    </select>
</mapper>

标签解释

在pojo的映射文件xml中，包含<select>、<insert>、<update>、<delete> 分别对应 查询、添加、更新、删除操作

• 其中 id 代表对应标签的识别id
• parameterType代表占位符的类型
• resultType 代表返回值类型

语句解释

#{v}代表占位符 占位符标识为v
${value}代表字符串拼接 标识必须为value

select * from user where username like '%xx%'

• 对应的UserMap.xml配置文件中的SQL文件写法

SELECT * FROM `user` where username like "%"#{v}"%"

• 测试代码

@Test
    public void testSelectOne() throws IOException {
        //创建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

        //加载SqlMapConfig.xml配置文件 创建SqlSessionFactory
        SqlSessionFactory sessionFactory = builder.build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        //创建SqlSession对象
        SqlSession sqlSession = sessionFactory.openSession();
        //SqlSession执行对象查询
        User user = (User) sqlSession.selectOne("queryUserById", 1);
        System.out.println(user);
        //释放资源
        sqlSession.close();
    }

insert

• 映射文件 mapper sql书写

   <insert id="insertUser" parameterType="cn.probuing.mybatisintro.pojo.User">
        <!-- 返回最后插入的主键id -->
        <selectKey keyProperty="id" resultType="Integer" order="AFTER">
            SELECT LAST_INSERT_ID()
        </selectKey>
        insert into user(username,birthday,address,sex) values(#{username},#{birthday},#{address},#{sex})
    </insert>

update

• 映射文件 mapper sql

<!--更新用户-->
    <update id="updateUserById" parameterType="cn.probuing.mybatisintro.pojo.User">
        update user
        set username=#{username},ses=#{sex},birthday=#{birthday},address=#{address}
        where id = #{id}
    </update>

• 测试代码

  @Test
    public void testUpdateUserById() throws IOException {
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sessionFactory = builder.build(Resources.getResourceAsStream("sqlMapConfig.xml"));
        SqlSession sqlSession = sessionFactory.openSession();
        User user = new User();
        user.setId(33);
        user.setUsername("www33333");
        user.setSex("钕");
        user.setBirthday(new Date());
        user.setAddress("332211aasss");
        int line = sqlSession.insert("test.updateUserById", user);
        sqlSession.commit();
        System.out.println(line);
    }

delete

• Mapper映射文件

  <!--删除用户-->
    <delete id="deleteUserById" parameterType="Integer">
        DELETE from user
        WHERE id = #{vvvv}
    </delete>

• 测试代码

 @Test
    public void testDeleteUserById() throws IOException {
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sessionFactory = builder.build(Resources.getResourceAsStream("sqlMapConfig.xml"));
        SqlSession sqlSession = sessionFactory.openSession();
        sqlSession.delete("test.deleteUserById", 32);
        sqlSession.commit();
    }

MyBatis 解决JDBC的需求

1、数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库连接池可解决此问题。
解决：在SqlMapConfig.xml中配置数据连接池，使用连接池管理数据库链接。
2、Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。
解决：将Sql语句配置在XXXXmapper.xml文件中与java代码分离。
3、向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。
解决：Mybatis自动将java对象映射至sql语句，通过statement中的parameterType定义输入参数的类型。
4、对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。
解决：Mybatis自动将sql执行结果映射至java对象，通过statement中的resultType定义输出结果的类型

提出一个需求

MyBatis与HIbernate的不同

Mybatis和hibernate不同，它不完全是一个ORM框架，因为MyBatis需要程序员自己编写Sql语句。mybatis可以通过XML或注解方式灵活配置要运行的sql语句，并将java对象和sql语句映射生成最终执行的sql，最后将sql执行的结果再映射生成java对象。

Mybatis学习门槛低，简单易学，程序员直接编写原生态sql，可严格控制sql执行性能，灵活度高，非常适合对关系数据模型要求不高的软件开发，例如互联网软件、企业运营类软件等，因为这类软件需求变化频繁，一但需求变化要求成果输出迅速。但是灵活的前提是mybatis无法做到数据库无关性，如果需要实现支持多种数据库的软件则需要自定义多套sql映射文件，工作量大。

Hibernate对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件（例如需求固定的定制化软件）如果用hibernate开发可以节省很多代码，提高效率。但是Hibernate的学习门槛高，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡，以及怎样用好Hibernate需要具有很强的经验和能力才行。
总之，按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构都是好架构，所以框架只有适合才是最好。

Mapper动态代理方式开发

开发规范

Mapper接口开发方法只需要程序员编写Mapper接口（相当于Dao接口），由Mybatis框架根据接口定义创建接口的动态代理对象，代理对象的方法体同上边Dao接口实现类方法。
Mapper接口开发需要遵循以下规范：

• 1、 Mapper.xml文件中的namespace与mapper接口的类路径相同。
• 2、Mapper接口方法名和Mapper.xml中定义的每个statement的id相同
• 3、Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同
• 4、Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同

创建UserMapper.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="cn.probuing.mybatisintro.mapper.UserMapper">
    <!--根据id查询用户-->
    <select id="queryUserById" parameterType="int"
            resultType="cn.probuing.mybatisintro.pojo.User">
        select *
        from user
        where id = #{id}
    </select>

    <!--根据用户名查询用户-->
    <select id="queryUserByName" parameterType="String"
            resultType="cn.probuing.mybatisintro.pojo.User">
        select *
        from user
        where username like '%${value}%'
    </select>
</mapper>

创建接口UserMapper

public interface UserMapper {
    public User queryUserById(int id);
    public List<User> queryUserByName(String userName);
}

核心配置文件加载UserMapper.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命名空间 用于隔离sql -->
<mapper namespace="cn.probuing.mybatisintro.mapper.UserMapper">
    <!--根据id查询用户-->
    <select id="queryUserById" parameterType="int"
            resultType="cn.probuing.mybatisintro.pojo.User">
        select *
        from user
        where id = #{id}
    </select>

    <!--根据用户名查询用户-->
    <select id="queryUserByName" parameterType="String"
            resultType="cn.probuing.mybatisintro.pojo.User">
        select *
        from user
        where username like '%${value}%'
    </select>
</mapper>

测试代码

 /**
     * 根据id查询用户
     */
    @Test
    public void testQueryUserById() throws IOException {
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sessionFactory = builder.build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        SqlSession sqlSession = sessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = userMapper.queryUserById(31);
        System.out.println(user);
    }

    /**
     * 根据name查询用户列表
     * @throws IOException
     */
    @Test
    public void testQueryUserByname() throws IOException {
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userMapper.queryUserByName("王");
        for (User user : userList) {
            System.out.println(user);
        }
    }

SqlMapConfig.xml配置文件详解

配置内容

SqlMapConfig.xml中配置的内容和顺序如下

• properties(属性)
• settings(全局配置参数)
• typeAliases(类型别名)
• typeHandlers(类型处理器)
• objectFactory(对象工厂)
• plugins(插件)
• environments(环境集合属性对象)
  • environment(环境子属性对象)
    • transactionManager(事务管理)
    • dataSource(数据源)
• mappers(映射器)

properties(属性)

• db.properties 配置文件内容

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

• SqlMapConfig.xml

    <!-- 是用resource属性加载外部配置文件 -->
    <properties resource="db.properties">
        <!-- 在properties内部用property定义属性 -->
        <!-- 如果外部配置文件有该属性，则内部定义属性被外部属性覆盖 -->
        <property name="jdbc.username" value="root123" />
        <property name="jdbc.password" value="root123" />
    </properties>
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理 -->
            <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="sqlmap/User.xml" />
        <mapper resource="mapper/UserMapper.xml" />
    </mappers>

tips
MyBatis将按照下面的顺序来加载属性

• 在properties元素体内定义的属性首先被读取
• 然后会读取properties元素中resource或url加载的属性，它会覆盖已读取的同名属性

typeAliases(类型别名)

mybatis支持别名

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

自定义别名

• 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>
    <!-- 是用resource属性加载外部配置文件 -->
    <properties resource="db.properties">
        <!-- 在properties内部用property定义属性 -->
        <property name="jdbc.username" value="root123" />
        <property name="jdbc.password" value="root123" />
    </properties>

    <typeAliases>
        <!-- 单个别名定义 -->
        <typeAlias alias="user" type="cn.itcast.mybatis.pojo.User" />
        <!-- 批量别名定义，扫描整个包下的类，别名为类名（大小写不敏感） -->
        <package name="cn.itcast.mybatis.pojo" />
        <package name="其它包" />
    </typeAliases>

    <!-- 和spring整合后 environments配置将废除 -->
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理 -->
            <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="sqlmap/User.xml" />
        <mapper resource="mapper/UserMapper.xml" />
    </mappers>
</configuration>

在mapper.xml配置文件中，就可以使用设置的别名了
别名大小写不敏感

图片.png

mappers(映射器)

Mapper配置的几种方法

• <mapper resource=""/>
  使用相对于类路径的资源(现在的使用方式)

<mapper resource="sqlmap/User.xml" />

• <mapper class=""/> 使用mapper类接口路径

<mapper class="cn.itcast.mybatis.mapper.UserMapper"/>

此方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中

• <package name=""/> 注册指定包下的所有mapper接口

<package name="cn.probuing.xxx"/>

此方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中

Mybatis输入映射和输出映射

输出简单类型

输出POJO对象

开发中通过可以使用pojo传递查询条件
查询条件可能是综合的查询条件，不仅包括用户的查询条件还包括其它的查询条件
包装对象：Pojo类中的一个属性是另外一个pojo

创建包装类对象QueryVo

public class QueryVo {
    private User user;

    
    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
    
}

创建映射文件Mapper.xml文件

其中输入参数为包装条件对象QueryVo 输出对象为User泛型

    <!--根据用户名查询数据-->
    <select id="selectListByUserNameQueryVo" parameterType="QueryVo" resultType="cn.probuing.mybatisintro.pojo.User">
        SELECT * FROM user where username LIKE  '%${user.username}'
    </select>

Mapper接口

在UserMapper接口中添加方法

   /**
     * 根据包装条件查询用户列表数据
     *
     * @param queryVo
     * @return
     */
    public List<User> queryUserByQueryVo(QueryVo queryVo);

测试方法

    @Test
    public void testQueryVo() throws IOException {
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        QueryVo queryVo = new QueryVo();
        User user = new User();
        user.setUsername("五");
        queryVo.setUser(user);
        List<User> list = userMapper.selectListByUserNameQueryVo(queryVo);
        for (User user1 : list) {
            System.out.println(user1);
        }
    }

resultMap

在Mapper文件中，resultType可以指定将查询结果映射为POJO，前提必须是POJO和sql查询的列名一致方可映射成功。
如果sql查询字段名和POJO的属性名不一致，可以通过resultMap将字段名和属性名作为一个指定的对应关系。resultMap实质上还需要将查询结果映射到POJO对象中。
resultMap可以实现将查询结果映射为复杂类型的POJO

创建一个POJO

package cn.probuing.mybatisintro.pojo;

import java.io.Serializable;
import java.util.Date;

public class Orders  implements Serializable{
    @Override
    public String toString() {
        return "Orders [id=" + id + ", userId=" + userId + ", number=" + number + ", createtime=" + createtime
                + ", note=" + note + "]";
    }

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    private Integer id;

    private Integer userId;

    private String number;

    private Date createtime;

    private String note;
    
    //附加对象  用户对象
    private User user;
    
    
    
    
    

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Integer getId() {
        return id;
    }

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

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number == null ? null : number.trim();
    }

    public Date getCreatetime() {
        return createtime;
    }

    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note == null ? null : note.trim();
    }

    
    
}

该pojo中 order中的userid与数据库中表对应的查询列不一致

创建OrderMapper.xml映射文件

<mapper namespace="cn.probuing.mybatisintro.mapper.OrderMapper">

    <!--
        id 对应指定的resultMap标识
        type 指定映射到哪一个pojo上
    -->
    <resultMap id="orderResultMap" type="orders">
        <!--id 定义主键 如果是多个字段 则定义多个id
        标签中的property 表示 指定映射到pojo的哪个属性
        标签中的column 表示 指定映射到数据库中的列名
        -->
        <id property="id" column="id"/>
        <!--普通属性使用result定义-->
        <result property="userId" column="user_id"/>
        <result property="number" column="number"/>
        <result property="createtime" column="createtime"/>
        <result property="note" column="note"/>
    </resultMap>
    <!--resultMap标签指定一个ResultMap的标识-->
    <select id="queryOrderList" resultMap="orderResultMap">
        SELECT id, user_id,
        number,
        createtime, note FROM `orders`
    </select>

</mapper>

测试代码

  @Test
    public void testResultMapQuery() throws IOException {
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
        List<Orders> orderList = orderMapper.queryOrderList();
        for (Orders orders : orderList) {
            System.out.println(orders);
        }
    }

动态SQL

通过Mybatis提供的各种标签方法实现动态拼接SQL

if标签

编写mapper.xml文件

  <!--动态标签-->
    <select id="queryUserByWhere" parameterType="user" resultType="user">
        <!-- 考虑到sex 和username不一定同时存在 所以加入if标签进行判断 -->
        SELECT * FROM user
        WHERE 1=1
        <if test="sex !=null and sex !=''">
            and sex = #{sex}
        </if>
        <if test="username !=null and username !=''">
            and username LIKE "%${username}%"
        </if>
    </select>

上面这种判断 还是存在where 1=1 的情况，这种情况显然还是很麻烦的 ，下面我们使用where标签对上面的判断进行改造

where标签

mapper.xml文件

 <select id="queryUserByWhere" parameterType="user" resultType="user">
        <!-- 考虑到sex 和username不一定同时存在 所以加入if标签进行判断 -->
        SELECT * FROM user
        <where>

            <if test="sex !=null and sex !=''">
                and sex = #{sex}
            </if>
            <if test="username !=null and username !=''">
                and username LIKE "%${username}%"
            </if>
        </where>

    </select>

where标签会自动添加where条件，同时会处理sql语句中的第一个and关键字

sql片段

sql中可将重复的sql提取出来，使用时用Include引用，最终达到sql重用的目的
上面的sql提取出来后

 <!-- 根据条件查询用户 -->
<select id="queryUserByWhere" parameterType="user" resultType="user">
    <!-- SELECT id, username, birthday, sex, address FROM `user` -->
    <!-- 使用include标签加载sql片段；refid是sql片段id -->
    SELECT <include refid="userFields" /> FROM `user`
    <!-- where标签可以自动添加where关键字，同时处理sql语句中第一个and关键字 -->
    <where>
        <if test="sex != null">
            AND sex = #{sex}
        </if>
        <if test="username != null and username != ''">
            AND username LIKE
            '%${username}%'
        </if>
    </where>
</select>

<!-- 声明sql片段 -->
<sql id="userFields">
    id, username, birthday, sex, address
</sql>

foreach标签

向sql中传递数组或list mybatis使用foreach解析

改造QueryVo

在QueryVo中加入List代表多个id的集合

public class QueryVo implements Serializable {
    private User user;
    private List<Integer> ids;

    public List<Integer> getIds() {
        return ids;
    }

    public void setIds(List<Integer> ids) {
        this.ids = ids;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

}

Mapper.xml文件

 <!--根据ids查询用户-->
    <select id="queryUserByIds" parameterType="queryVo" resultType="user">
        SELECT * FROM user
        <where>
            <!--
             foreach标签
             collection:要遍历的集合，在这里是QueryVo中的ids属性 
             直接传递数组时collection指定array
              直接传递list时collection指定list
              




             item:遍历的项目
             open:在前面添加的sql片段
             close:在结尾处添加的sql片段
             separator:指定遍历的元素之间使用的分隔符
             -->
            <foreach collection="ids" item="item" open="id in (" close=")" separator=",">
                #{item}
            </foreach>
        </where>
    </select>

测试方法

   @Test
    public void testQueryByIds() throws IOException {
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        QueryVo queryVo = new QueryVo();
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(10);
        list.add(24);
        queryVo.setIds(list);
        List<User> users = userMapper.queryUserByIds(queryVo);
        for (User user : users) {
            System.out.println(user);
        }
    }

一对一查询

使用resultMap

改造pojo类

在Order类中加入User属性，user属性中用于存储关联查询的用户信息，对于订单来说订单关联查询用户是一对一关系，所以这里使用单个User对象存储关联查询的用户信息

public class Orders  implements Serializable{
    @Override
    public String toString() {
        return "Orders [id=" + id + ", userId=" + userId + ", number=" + number + ", createtime=" + createtime
                + ", note=" + note + "]";
    }

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    private Integer id;

    private Integer userId;

    private String number;

    private Date createtime;

    private String note;
    
    //附加对象  用户对象
    private User user;
}

Mapper.xml

  <resultMap id="orderUserResultMap" type="orders">
        <!--映射数据库主键 id-->
        <id property="id" column="id"/>
        <result property="userId" column="user_id"/>
        <result property="number" column="number"/>
        <result property="createtime" column="createtime"/>
        <result property="note" column="note"/>
        <!--一对一属性映射-->
        <association property="user" javaType="user">
            <id property="id" column="user_id"/>
            <result property="username" column="username"/>
            <result property="address" column="address"/>
        </association>
    </resultMap>
    <!--一对一关联，查询订单，订单内部包含用户属性-->
    <select id="queryOrderUserResultMap" resultMap="orderUserResultMap">
        SELECT
            o.id,
            o.user_id,
            o.number,
            o.createtime,
            o.note,
            u.username,
            u.address
        FROM
            `orders` o
            LEFT JOIN `user` u ON o.user_id = u.id
    </select>

上面的配置文件中 左关联查询时 对应映射的类与数据库查询列不一致 所以使用resultMap映射
Orders中有User属性，所以需要使用一对一映射User 使用resultMap的association标签映射User属性，在association标签下 再分别映射user对象的属性 其中指定的property是user对象的属性名 column是对应数据库列的名称

测试代码

 @Test
    public void testQueryByResultMap() throws IOException {
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
        List<Orders> orders = orderMapper.queryOrderUserResultMap();
        for (Orders order : orders) {
            System.out.println(order);
        }
    }

一对多查询

修改POJO User类

public class User implements Serializable {
    /**
     *
     */
    private static final long serialVersionUID = 1L;
    private Integer id;
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址

    private List<Orders> ordersList;

    public List<Orders> getOrdersList() {
        return ordersList;
    }

    public void setOrdersList(List<Orders> ordersList) {
        this.ordersList = ordersList;
    }
}

Mapper.xml 映射文件

  <resultMap type="User" id="user">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <!-- 一对多 -->
        <collection property="orders" ofType="Orders">
            <id column="id" property="id"/>
            <result column="user_id" property="userId"/>
            <result column="number" property="number"/>
        </collection>
    </resultMap>
    <select id="queryUserOrder" resultMap="user">
        SELECT
            o.id,
            o.user_id,
            o.number,
            o.createtime,
            u.username
        FROM user u
            left join orders o
                on o.user_id = u.id
    </select>

Mybatis整合Spring

整合思路

• SqlSessionFactory对象应该放到spring容器中作为单例存在。
• 传统dao的开发方式中，应该从spring容器中获得sqlsession对象。
• Mapper代理形式中，应该从spring容器中直接获得mapper的代理对象。
• 数据库的连接以及数据库连接池事务管理都交给spring容器来完成。

整合需要的jar包

spring的jar包
Mybatis的jar包
Spring+mybatis的整合包。
Mysql的数据库驱动jar包。
数据库连接池的jar包。

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>
    <!-- 设置别名 -->
    <typeAliases>
        <!-- 2. 指定扫描包，会把包内所有的类都设置别名，别名的名称就是类名，大小写不敏感 -->
        <package name="cn.probuing.mybatisspring.pojo"/>
    </typeAliases>

</configuration>

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:config/db.properties"/>
    <!--配置数据库连接池-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

    </bean>
    <!--配置sqlsessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--配置mybatis核心配置文件-->
        <property name="configLocation" value="classpath:config/SqlMapConfig.xml"/>
        <!--配置数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--配置UserMapper-->
    <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <!--配置mapper接口-->
        <property name="mapperInterface" value="cn.probuing.mybatisspring.mapper.UserMapper"/>
        <!--配置SqlSessionFactory工厂-->
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
</beans>

db.properties

Mapper接口

public interface UserMapper {
    public User findUserById(Integer id);
}

UserMapper.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="cn.probuing.mybatisspring.mapper.UserMapper">
    <select id="findUserById" parameterType="Integer" resultType="User">
        SELECT *
        FROM user
        where id = #{v}
    </select>
</mapper>

测试代码

  @Test
    public void testQueryById() {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("config/applicationContext.xml");
        UserMapper userMapper = (UserMapper) applicationContext.getBean("userMapper");
        User user = userMapper.findUserById(10);
        System.out.println(user);
    }

在存在多个mapper的时候 在spring中都需要制定具体的mapper 这种方式在我们开发中是很麻烦的，所以在这种时候我们引入扫描包形式配置mapper

扫描包形式配置mapper

在配置的时候需要制定 MapperScannerConfigurer 在property中指定扫描的基础包
由于工厂已经实例化 所以不需要指定工厂 MapperScannerConfigurer也能找到工厂

    <!--包扫描形式配置mapper-->
    <bean  class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="cn.probuing.mybatisspring.mapper"/>
    </bean>

Mybatis逆向工程

使用官方网站提供的Mapper自动生成工具 mybatis-generator-core来生成pojo类和Mapper映射文件

导入逆向工程

官方提供的逆向工程

修改配置文件

<?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>
    <context id="testTables" targetRuntime="MyBatis3">
        <commentGenerator>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
            connectionURL="jdbc:mysql://localhost:3306/mybatis" userId="root" password="root">
        </jdbcConnection>
        <!-- <jdbcConnection driverClass="oracle.jdbc.OracleDriver" connectionURL="jdbc:oracle:thin:@127.0.0.1:1521:yycg" 
            userId="yycg" password="yycg"> </jdbcConnection> -->

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

        <!-- targetProject:生成PO类的位置 -->
        <javaModelGenerator targetPackage="cn.itcast.ssm.po"
            targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- targetProject:mapper映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="cn.itcast.ssm.mapper"
            targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>
        <!-- targetPackage：mapper接口生成的位置 -->
        <javaClientGenerator type="XMLMAPPER"
            targetPackage="cn.itcast.ssm.mapper" targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>
        <!-- 指定数据库表 -->
        <table schema="" tableName="user"></table>
        <table schema="" tableName="order"></table>
    </context>
</generatorConfiguration>

生成逆向工程代码 执行工程main主函数

图片.png

图片.png

代码生成在工程目录下

图片.png

注意

• 逆向工程生成的代码只能做单表查询
• 不能在生成的代码上进行扩展，因为如果数据库变更，需要重新使用逆向工程生成代码，原来编写的代码就被覆盖了。
• 一张表会生成4个文件