mybatis-mrt-2.2

框架课程

1Mybatis入门

1.1单独使用jdbc编程问题总结

1.1.1jdbc程序

Public static void main(String[] args) {

            Connection connection = null;

            PreparedStatement preparedStatement = null;

            ResultSet resultSet = null;

            try {

                //加载数据库驱动

                Class.forName("com.mysql.jdbc.Driver");

                //通过驱动管理类获取数据库链接

                connection =  DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "mysql");

                //定义sql语句 ?表示占位符

            String sql = "select * from user where username = ?";

                //获取预处理statement

                preparedStatement = connection.prepareStatement(sql);

                //设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值

                preparedStatement.setString(1, "王五");

                //向数据库发出sql执行查询，查询出结果集

                resultSet =  preparedStatement.executeQuery();

                //遍历查询结果集

                while(resultSet.next()){

                    System.out.println(resultSet.getString("id")+"  "+resultSet.getString("username"));

                }

            } catch (Exception e) {

                e.printStackTrace();

            }finally{

                //释放资源

                if(resultSet!=null){

                    try {

                        resultSet.close();

                    } catch (SQLException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                    }

                }

                if(preparedStatement!=null){

                    try {

                        preparedStatement.close();

                    } catch (SQLException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                    }

                }

                if(connection!=null){

                    try {

                        connection.close();

                    } catch (SQLException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                    }

                }

            }

        }

上边使用jdbc的原始方法（未经封装）实现了查询数据库表记录的操作。

1.1.2jdbc编程步骤：

1、加载数据库驱动

2、创建并获取数据库链接

3、创建jdbc statement对象

4、设置sql语句

5、设置sql语句中的参数(使用preparedStatement)

6、通过statement执行sql并获取结果

7、对sql执行结果进行解析处理

8、释放资源(resultSet、preparedstatement、connection)

1.1.3jdbc问题总结如下：

1、数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。

2、Sql语句在代码中硬编码，造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。

3、使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护。

4、对结果集解析存在硬编码（查询列名），sql变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成pojo对象解析比较方便。

1.2MyBatis介绍

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis，实质上Mybatis对ibatis进行一些改进。 

MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。

Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。

1.3Mybatis架构

1、mybatis配置

SqlMapConfig.xml，此文件作为mybatis的全局配置文件，配置了mybatis的运行环境等信息。

mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。

2、通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂

3、由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession进行。

4、mybatis底层自定义了Executor执行器接口操作数据库，Executor接口有两个实现，一个是基本执行器、一个是缓存执行器。

5、Mapped Statement也是mybatis一个底层封装对象，它包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象，sql的id即是Mapped statement的id。

6、Mapped Statement对sql执行输入参数进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql前将输入的java对象映射至sql中，输入参数映射就是jdbc编程中对preparedStatement设置参数。

7、Mapped Statement对sql执行输出结果进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中，输出结果映射过程相当于jdbc编程中对结果的解析处理过程。

1.4mybatis下载

mybaits的代码由github.com管理，地址：https://github.com/mybatis/mybatis-3/releases

mybatis-3.2.7.jar----mybatis的核心包

lib----mybatis的依赖包

mybatis-3.2.7.pdf----mybatis使用手册

1.5创建mysql数据库

先导入sql_table.sql，再导入 sql_data.sql脚本：

如下：

1.6Mybatis入门程序

1.6.1需求

实现以下功能：

根据用户id查询一个用户信息

根据用户名称模糊查询用户信息列表

添加用户

更新用户

删除用户

1.6.2第一步：创建java工程

使用eclipse创建java工程，jdk使用1.7.0_72。

1.6.3第二步：加入jar包

加入mybatis核心包、依赖包、数据驱动包。

1.6.4第三步：log4j.properties

在classpath下创建log4j.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

mybatis默认使用log4j作为输出日志信息。

1.6.5第四步：SqlMapConfig.xml

在classpath下创建SqlMapConfig.xml，如下：

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-config.dtd">

SqlMapConfig.xml是mybatis核心配置文件，上边文件的配置内容为数据源、事务管理。

1.6.6第五步：po类

Po类作为mybatis进行sql映射使用，po类通常与数据库表对应，User.java如下：

Public class User {

    private int id;

    private String username;// 用户姓名

    private String sex;// 性别

    private Date birthday;// 生日

    private String address;// 地址

get/set……

1.6.7第六步：程序编写

1.6.7.1查询

1.6.7.1.1映射文件：

在classpath下的sqlmap目录下创建sql映射文件Users.xml：

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

namespace ：命名空间，用于隔离sql语句，后面会讲另一层非常重要的作用。

在SqlMapConfig.xml中添加：

        select * from user where id = #{id}

                resultType="cn.itcast.mybatis.po.User">

       select * from user where username like '%${value}%' 

parameterType：定义输入到sql中的映射类型，#{id}表示使用preparedstatement设置占位符号并将输入变量id传到sql。

resultType：定义结果映射类型。

1.6.7.1.2加载映射文件

mybatis框架需要加载映射文件，将Users.xml添加在SqlMapConfig.xml，如下：

1.6.7.1.3测试程序：

public class Mybatis_first {

    //会话工厂

    private SqlSessionFactory sqlSessionFactory;

    @Before

    public void createSqlSessionFactory() throws IOException {

        // 配置文件

        String resource = "SqlMapConfig.xml";

        InputStream inputStream = Resources.getResourceAsStream(resource);

        // 使用SqlSessionFactoryBuilder从xml配置文件中创建SqlSessionFactory

        sqlSessionFactory = new SqlSessionFactoryBuilder()

                .build(inputStream);

    }

    // 根据 id查询用户信息

    @Test

    public void testFindUserById() {

        // 数据库会话实例

        SqlSession sqlSession = null;

        try {

            // 创建数据库会话实例sqlSession

            sqlSession = sqlSessionFactory.openSession();

            // 查询单个记录，根据用户id查询用户信息

            User user = sqlSession.selectOne("test.findUserById", 10);

            // 输出用户信息

            System.out.println(user);

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (sqlSession != null) {

                sqlSession.close();

            }

        }

    }

    // 根据用户名称模糊查询用户信息

    @Test

    public void testFindUserByUsername() {

        // 数据库会话实例

        SqlSession sqlSession = null;

        try {

            // 创建数据库会话实例sqlSession

            sqlSession = sqlSessionFactory.openSession();

            // 查询单个记录，根据用户id查询用户信息

            List list = sqlSession.selectList("test.findUserByUsername", "张");

            System.out.println(list.size());

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (sqlSession != null) {

                sqlSession.close();

            }

        }

    }

}

1.6.7.1.4#{}和${}

#{}表示一个占位符号，通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。

${}表示拼接sql串，通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换， ${}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，${}括号中只能是value。

1.6.7.1.5parameterType和resultType

parameterType：指定输入参数类型，mybatis通过ognl从输入对象中获取参数值拼接在sql中。

resultType：指定输出结果类型，mybatis将sql查询结果的一行记录数据映射为resultType指定类型的对象。

1.6.7.1.6selectOne和selectList

selectOne查询一条记录，如果使用selectOne查询多条记录则抛出异常：

org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 3

    at org.apache.ibatis.session.defaults.DefaultSqlSession.selectOne(DefaultSqlSession.java:70)

selectList可以查询一条或多条记录。

1.6.7.2添加

1.6.7.2.1映射文件：

在SqlMapConfig.xml中添加：

        select LAST_INSERT_ID() 

      insert into user(username,birthday,sex,address) 

      values(#{username},#{birthday},#{sex},#{address})

1.6.7.2.2测试程序：

// 添加用户信息

    @Test

    public void testInsert() {

        // 数据库会话实例

        SqlSession sqlSession = null;

        try {

            // 创建数据库会话实例sqlSession

            sqlSession = sqlSessionFactory.openSession();

            // 添加用户信息

            User user = new User();

            user.setUsername("张小明");

            user.setAddress("河南郑州");

            user.setSex("1");

            user.setPrice(1999.9f);

            sqlSession.insert("test.insertUser", user);

            //提交事务

            sqlSession.commit();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (sqlSession != null) {

                sqlSession.close();

            }

        }

    }

1.6.7.2.3mysql自增主键返回

通过修改sql映射文件，可以将mysql自增主键返回：

            select LAST_INSERT_ID()

       insert into user(username,birthday,sex,address)

        values(#{username},#{birthday},#{sex},#{address});

添加selectKey实现将主键返回

keyProperty:返回的主键存储在pojo中的哪个属性

order：selectKey的执行顺序，是相对与insert语句来说，由于mysql的自增原理执行完insert语句之后才将主键生成，所以这里selectKey的执行顺序为after

resultType:返回的主键是什么类型

LAST_INSERT_ID():是mysql的函数，返回auto_increment自增列新记录id值。

1.6.7.2.4Mysql使用 uuid实现主键

需要增加通过select uuid()得到uuid值

keyProperty="id">

select uuid()

insert into user(id,username,birthday,sex,address) 

         values(#{id},#{username},#{birthday},#{sex},#{address})

注意这里使用的order是“BEFORE”

1.6.7.2.5Oracle使用序列生成主键

首先自定义一个序列且用于生成主键，selectKey使用如下：

keyProperty="id">

SELECT 自定义序列.NEXTVAL FROM DUAL

insert into user(id,username,birthday,sex,address) 

         values(#{id},#{username},#{birthday},#{sex},#{address})

注意这里使用的order是“BEFORE”

1.6.7.3删除

1.6.7.3.1映射文件：

        delete from user where id=#{id}

1.6.7.3.2测试程序：

// 根据id删除用户

    @Test

    public void testDelete() {

        // 数据库会话实例

        SqlSession sqlSession = null;

        try {

            // 创建数据库会话实例sqlSession

            sqlSession = sqlSessionFactory.openSession();

            // 删除用户

            sqlSession.delete("test.deleteUserById",18);

            // 提交事务

            sqlSession.commit();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (sqlSession != null) {

                sqlSession.close();

            }

        }

    }

1.6.7.4修改

1.6.7.4.1映射文件

        update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address}

        where id=#{id}

1.6.7.4.2测试程序

// 更新用户信息

    @Test

    public void testUpdate() {

        // 数据库会话实例

        SqlSession sqlSession = null;

        try {

            // 创建数据库会话实例sqlSession

            sqlSession = sqlSessionFactory.openSession();

            // 添加用户信息

            User user = new User();

            user.setId(16);

            user.setUsername("张小明");

            user.setAddress("河南郑州");

            user.setSex("1");

            user.setPrice(1999.9f);

            sqlSession.update("test.updateUser", user);

            // 提交事务

            sqlSession.commit();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (sqlSession != null) {

                sqlSession.close();

            }

        }

    }

1.6.8Mybatis解决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定义输出结果的类型。

1.6.9与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需要具有很强的经验和能力才行。

总之，按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构都是好架构，所以框架只有适合才是最好。 

2Dao开发方法

 使用Mybatis开发Dao，通常有两个方法，即原始Dao开发方法和Mapper接口开发方法。

2.1需求

将下边的功能实现Dao：

根据用户id查询一个用户信息

根据用户名称模糊查询用户信息列表

添加用户信息

2.2SqlSession的使用范围

 SqlSession中封装了对数据库的操作，如：查询、插入、更新、删除等。

通过SqlSessionFactory创建SqlSession，而SqlSessionFactory是通过SqlSessionFactoryBuilder进行创建。

2.2.1SqlSessionFactoryBuilder

SqlSessionFactoryBuilder用于创建SqlSessionFacoty，SqlSessionFacoty一旦创建完成就不需要SqlSessionFactoryBuilder了，因为SqlSession是通过SqlSessionFactory生产，所以可以将SqlSessionFactoryBuilder当成一个工具类使用，最佳使用范围是方法范围即方法体内局部变量。

2.2.2SqlSessionFactory

 SqlSessionFactory是一个接口，接口中定义了openSession的不同重载方法，SqlSessionFactory的最佳使用范围是整个应用运行期间，一旦创建后可以重复使用，通常以单例模式管理SqlSessionFactory。

2.2.3SqlSession

 SqlSession是一个面向用户的接口， sqlSession中定义了数据库操作，默认使用DefaultSqlSession实现类。

执行过程如下：

1、加载数据源等配置信息

Environment environment = configuration.getEnvironment();

2、创建数据库链接

3、创建事务对象

4、创建Executor，SqlSession所有操作都是通过Executor完成，mybatis源码如下：

if (ExecutorType.BATCH == executorType) {

      executor = new BatchExecutor(this, transaction);

    } elseif (ExecutorType.REUSE == executorType) {

      executor = new ReuseExecutor(this, transaction);

    } else {

      executor = new SimpleExecutor(this, transaction);

    }

if (cacheEnabled) {

      executor = new CachingExecutor(executor, autoCommit);

    }

5、SqlSession的实现类即DefaultSqlSession，此对象中对操作数据库实质上用的是Executor

结论：

 每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能共享使用，它也是线程不安全的。因此最佳的范围是请求或方法范围。绝对不能将SqlSession实例的引用放在一个类的静态字段或实例字段中。

 打开一个 SqlSession；使用完毕就要关闭它。通常把这个关闭操作放到 finally 块中以确保每次都能执行关闭。如下：

 SqlSession session = sqlSessionFactory.openSession();

 try {

    // do work

 } finally {

    session.close();

 }

2.3原始Dao开发方式

 原始Dao开发方法需要程序员编写Dao接口和Dao实现类。

2.3.1映射文件

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

        select * from user where id = #{id}

        select LAST_INSERT_ID() 

      insert into user(username,birthday,sex,address) 

      values(#{username},#{birthday},#{sex},#{address})

2.3.2Dao接口

Public interface UserDao {

    public User getUserById(int id) throws Exception;

    public void insertUser(User user) throws Exception;

}

Public class UserDaoImpl implements UserDao {

    //注入SqlSessionFactory

    public UserDaoImpl(SqlSessionFactory sqlSessionFactory){

        this.setSqlSessionFactory(sqlSessionFactory);

    }

    private SqlSessionFactory sqlSessionFactory;

    @Override

    public User getUserById(int id) throws Exception {

        SqlSession session = sqlSessionFactory.openSession();

        User user = null;

        try {

            //通过sqlsession调用selectOne方法获取一条结果集

            //参数1：指定定义的statement的id,参数2：指定向statement中传递的参数

            user = session.selectOne("test.findUserById", 1);

            System.out.println(user);

        } finally{

            session.close();

        }

        return user;

    }

    @Override

    Public void insertUser(User user) throws Exception {

        SqlSession sqlSession = sqlSessionFactory.openSession();

        try {

            sqlSession.insert("insertUser", user);

            sqlSession.commit();

        } finally{

            session.close();

        }

    }

}

2.3.3问题

原始Dao开发中存在以下问题：

◆Dao方法体存在重复代码：通过SqlSessionFactory创建SqlSession，调用SqlSession的数据库操作方法

◆调用sqlSession的数据库操作方法需要指定statement的id，这里存在硬编码，不得于开发维护。

2.4Mapper动态代理方式    

2.4.1实现原理

 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的类型相同

2.4.2Mapper.xml(映射文件)

 定义mapper映射文件UserMapper.xml（内容同Users.xml），需要修改namespace的值为 UserMapper接口路径。将UserMapper.xml放在classpath 下mapper目录 下。

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

        select * from user where id = #{id}

                resultType="cn.itcast.mybatis.po.User">

       select * from user where username like '%${value}%' 

        select LAST_INSERT_ID() 

      insert into user(username,birthday,sex,address) 

      values(#{username},#{birthday},#{sex},#{address})

2.4.3Mapper.java(接口文件)

/**

 * 用户管理mapper

 */

Public interface UserMapper {

    //根据用户id查询用户信息

    public User findUserById(int id) throws Exception;

    //查询用户列表

    public List findUserByUsername(String username) throws Exception;

    //添加用户信息

    public void insertUser(User user)throws Exception; 

}

接口定义有如下特点：

1、Mapper接口方法名和Mapper.xml中定义的statement的id相同

2、Mapper接口方法的输入参数类型和mapper.xml中定义的statement的parameterType的类型相同

3、Mapper接口方法的输出参数类型和mapper.xml中定义的statement的resultType的类型相同

2.4.4加载UserMapper.xml文件

修改SqlMapConfig.xml文件：

2.4.5测试

Public class UserMapperTest extends TestCase {

    private SqlSessionFactory sqlSessionFactory;

    protected void setUp() throws Exception {

        //mybatis配置文件

        String resource = "sqlMapConfig.xml";

        InputStream inputStream = Resources.getResourceAsStream(resource);

        //使用SqlSessionFactoryBuilder创建sessionFactory

        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    }

    Public void testFindUserById() throws Exception {

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获取mapper接口的代理对象

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //调用代理对象方法

        User user = userMapper.findUserById(1);

        System.out.println(user);

        //关闭session

        session.close();

    }

    @Test

    public void testFindUserByUsername() throws Exception {

        SqlSession sqlSession = sqlSessionFactory.openSession();

        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        List list = userMapper.findUserByUsername("张");

        System.out.println(list.size());

    }

Public void testInsertUser() throws Exception {

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获取mapper接口的代理对象

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //要添加的数据

        User user = new User();

        user.setUsername("张三");

        user.setBirthday(new Date());

        user.setSex("1");

        user.setAddress("北京市");

        //通过mapper接口添加用户

        userMapper.insertUser(user);

        //提交

        session.commit();

        //关闭session

        session.close();

    }

}

2.4.6总结

◆selectOne和selectList

动态代理对象调用sqlSession.selectOne()和sqlSession.selectList()是根据mapper接口方法的返回值决定，如果返回list则调用selectList方法，如果返回单个对象则调用selectOne方法。

◆namespace

mybatis官方推荐使用mapper代理方法开发mapper接口，程序员不用编写mapper接口实现类，使用mapper代理方法时，输入参数可以使用pojo包装对象或map对象，保证dao的通用性。

3SqlMapConfig.xml配置文件

3.1配置内容

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

properties（属性）

settings（全局配置参数）

typeAliases（类型别名）

typeHandlers（类型处理器）

objectFactory（对象工厂）

plugins（插件）

environments（环境集合属性对象）

environment（环境子属性对象）

transactionManager（事务管理）

dataSource（数据源）

mappers（映射器）

3.2properties（属性）

SqlMapConfig.xml可以引用java属性文件中的配置信息如下：

在classpath下定义db.properties文件，

jdbc.driver=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/mybatis

jdbc.username=root

jdbc.password=mysql

SqlMapConfig.xml引用如下：

注意： MyBatis 将按照下面的顺序来加载属性：

◆在 properties 元素体内定义的属性首先被读取。 

◆然后会读取properties 元素中resource或 url 加载的属性，它会覆盖已读取的同名属性。 

◆最后读取parameterType传递的属性，它会覆盖已读取的同名属性。

因此，通过parameterType传递的属性具有最高优先级，resource或 url 加载的属性次之，最低优先级的是 properties 元素体内定义的属性。

3.3settings（配置）

mybatis全局配置参数，全局参数将会影响mybatis的运行行为。

详细参见“学习资料/mybatis-settings.xlsx”文件

3.4typeAliases（类型别名）

3.4.1mybatis支持别名：

在SqlMapConfig.xml中配置：

3.5typeHandlers（类型处理器）

类型处理器用于java类型和jdbc类型映射，如下：

        select * from user where id = #{id}

mybatis自带的类型处理器基本上满足日常需求，不需要单独定义。

mybatis支持类型处理器：

Mapper配置的几种方法：

3.6.1

使用相对于类路径的资源

如：

3.6.2

使用完全限定路径

如：

3.6.3

使用mapper接口类路径

如：

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

3.6.4

注册指定包下的所有mapper接口

如：

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

4Mapper.xml映射文件

Mapper.xml映射文件中定义了操作数据库的sql，每个sql是一个statement，映射文件是mybatis的核心。

4.1parameterType(输入类型)

4.1.1#{}与${}

#{}实现的是向prepareStatement中的预处理语句中设置参数值，sql语句中#{}表示一个占位符即?。

        select * from user where id = #{id}

使用占位符#{}可以有效防止sql注入，在使用时不需要关心参数值的类型，mybatis会自动进行java类型和jdbc类型的转换。#{}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。

${}和#{}不同，通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换， ${}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，${}括号中只能是value。使用${}不能防止sql注入，但是有时用${}会非常方便，如下的例子：

       select * from user where username like '%${value}%'

如果本例子使用#{}则传入的字符串中必须有%号，而%是人为拼接在参数中，显然有点麻烦，如果采用${}在sql中拼接为%的方式则在调用mapper接口传递参数就方便很多。

//如果使用占位符号则必须人为在传参数中加%

List list = userMapper.selectUserByName("%管理员%");

//如果使用${}原始符号则不用人为在参数中加%

Listlist = userMapper.selectUserByName("管理员");

再比如order by排序，如果将列名通过参数传入sql，根据传的列名进行排序，应该写为：

ORDER BY ${columnName}

如果使用#{}将无法实现此功能。

4.1.2传递简单类型

参考上边的例子。

4.1.3传递pojo对象

Mybatis使用ognl表达式解析对象字段的值，如下例子：

       select * from user where id=#{id} and username like '%${username}%'

上边红色标注的是user对象中的字段名称。

测试：

Public void testFindUserByUser()throws Exception{

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获限mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //构造查询条件user对象

        User user = new User();

        user.setId(1);

        user.setUsername("管理员");

        //传递user对象查询用户列表

        Listlist = userMapper.findUserByUser(user);

        //关闭session

        session.close();

    }

异常测试：

Sql中字段名输入错误后测试，username输入dusername测试结果报错：

org.apache.ibatis.exceptions.PersistenceException: 

### Error querying database.  Cause: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'dusername' in 'class cn.itcast.mybatis.po.User'

### Cause: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'dusername' in 'class cn.itcast.mybatis.po.User'

4.1.4传递pojo包装对象

 开发中通过pojo传递查询条件 ，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。

4.1.4.1定义包装对象

定义包装对象将查询条件(pojo)以类组合的方式包装起来。

public class QueryVo {

    private User user;

    //自定义用户扩展类

    private UserCustom userCustom;

4.1.4.2mapper.xml映射文件

说明：mybatis底层通过ognl从pojo中获取属性值：#{user.username}，user即是传入的包装对象的属性。queryVo是别名，即上边定义的包装对象类型。

4.1.5传递hashmap

Sql映射文件定义如下：

       select * from user where id=#{id} and username like '%${username}%'

上边红色标注的是hashmap的key。

测试：

Public void testFindUserByHashmap()throws Exception{

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获限mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //构造查询条件Hashmap对象

        HashMap map = new HashMap();

        map.put("id", 1);

        map.put("username", "管理员");

        //传递Hashmap对象查询用户列表

        Listlist = userMapper.findUserByHashmap(map);

        //关闭session

        session.close();

    }

异常测试：

传递的map中的key和sql中解析的key不一致。

测试结果没有报错，只是通过key获取值为空。

4.2resultType(输出类型)

4.2.1输出简单类型

参考getnow输出日期类型，看下边的例子输出整型：

Mapper.xml文件

       select count(1) from user

Mapper接口

public int findUserCount(User user) throws Exception;

调用：

Public void testFindUserCount() throws Exception{

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获取mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        User user = new User();

        user.setUsername("管理员");

        //传递Hashmap对象查询用户列表

        int count = userMapper.findUserCount(user);

        //关闭session

        session.close();

    }

总结：

输出简单类型必须查询出来的结果集有一条记录，最终将第一个字段的值转换为输出类型。

使用session的selectOne可查询单条记录。

4.2.2输出pojo对象

参考findUserById的定义：

Mapper.xml

        select * from user where id = #{id}

Mapper接口：

public User findUserById(int id) throws Exception;

测试：

Public void testFindUserById() throws Exception {

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获限mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //通过mapper接口调用statement

        User user = userMapper.findUserById(1);

        System.out.println(user);

        //关闭session

        session.close();

    }

使用session调用selectOne查询单条记录。

4.2.3输出pojo列表

参考selectUserByName的定义：

Mapper.xml

       select * from user where username like '%${value}%'

Mapper接口：

public List findUserByUsername(String username) throws Exception;

测试：

Public void testFindUserByUsername()throws Exception{

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获限mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //如果使用占位符号则必须人为在传参数中加%

        //List list = userMapper.selectUserByName("%管理员%");

        //如果使用${}原始符号则不用人为在参数中加%

        List list = userMapper.findUserByUsername("管理员");

        //关闭session

        session.close();

    }

使用session的selectList方法获取pojo列表。

4.2.4resultType总结：

输出pojo对象和输出pojo列表在sql中定义的resultType是一样的。

返回单个pojo对象要保证sql查询出来的结果集为单条，内部使用session.selectOne方法调用，mapper接口使用pojo对象作为方法返回值。

返回pojo列表表示查询出来的结果集可能为多条，内部使用session.selectList方法，mapper接口使用List对象作为方法返回值。

4.2.5输出hashmap

输出pojo对象可以改用hashmap输出类型，将输出的字段名称作为map的key，value为字段值。

4.3resultMap

 可以指定pojo将查询结果映射为pojo，但需要pojo的属性名和sql查询的列名一致方可映射成功。

 如果sql查询字段名和pojo的属性名不一致，可以通过resultMap将字段名和属性名作一个对应关系 ，resultMap实质上还需要将查询结果映射到pojo对象中。

 可以实现将查询结果映射为复杂类型的pojo，比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。

4.3.1Mapper.xml定义

使用resultMap指定上边定义的personmap。

4.3.2定义resultMap

由于上边的mapper.xml中sql查询列和Users.java类属性不一致，需要定义resultMap：userListResultMap将sql查询列和Users.java类属性对应起来

：此属性表示查询结果集的唯一标识，非常重要。如果是多个字段为复合唯一约束则定义多个。

Property：表示person类的属性。

Column：表示sql查询出来的字段名。

Column和property放在一块儿表示将sql查询出来的字段映射到指定的pojo类属性上。

：普通结果，即pojo的属性。

4.3.3Mapper接口定义

public List findUserListResultMap() throws Exception;

4.4动态sql(重点)

通过mybatis提供的各种标签方法实现动态拼接sql。

4.4.1If

        select * from user 

        where 1=1 

        and id=#{id}

        and username like '%${username}%'

注意要做不等于空字符串校验。

4.4.2Where

上边的sql也可以改为：

        select * from user 

        and id=#{id}

        and username like '%${username}%'

可以自动处理第一个and。

4.4.3foreach

向sql传递数组或List，mybatis使用foreach解析，如下：

4.4.3.1通过pojo传递list

◆需求

传入多个id查询用户信息，用下边两个sql实现：

SELECT * FROM USERS WHERE username LIKE '%张%' AND (id =10 OR id = OR id=16)

SELECT * FROM USERS WHERE username LIKE '%张%'  id IN (10,,16)

◆在pojo中定义list属性ids存储多个用户id，并添加getter/setter方法

◆mapper.xml

0">

                #{id}

◆测试代码：

List ids = new ArrayList();

        ids.add(1);//查询id为1的用户

        ids.add(10); //查询id为10的用户

        queryVo.setIds(ids);

        List list = userMapper.findUserList(queryVo);

4.4.3.2传递单个List

传递List类型在编写mapper.xml没有区别，唯一不同的是只有一个List参数时它的参数名为list。

如下：

◆Mapper.xml

        select * from user 

            #{item.id} 

◆Mapper接口

public List selectUserByList(List userlist) throws Exception;

◆测试：

Public void testselectUserByList()throws Exception{

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获限mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //构造查询条件List

        List userlist = new ArrayList();

        User user = new User();

        user.setId(1);

        userlist.add(user);

        user = new User();

        user.setId(2);

        userlist.add(user); 

        //传递userlist列表查询用户列表

        Listlist = userMapper.selectUserByList(userlist);

        //关闭session

        session.close();

    }

4.4.3.3传递单个数组（数组中是pojo）：

请阅读文档学习。

◆Mapper.xml

        select * from user 

            #{item.id} 

sql只接收一个数组参数，这时sql解析参数的名称mybatis固定为array，如果数组是通过一个pojo传递到sql则参数的名称为pojo中的属性名。

index：为数组的下标。

item：为数组每个元素的名称，名称随意定义

open：循环开始

close：循环结束

separator：中间分隔输出

◆Mapper接口：

public List selectUserByArray(Object[] userlist) throws Exception;

◆测试：

Public void testselectUserByArray()throws Exception{

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获限mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //构造查询条件List

        Object[] userlist = new Object[2];

        User user = new User();

        user.setId(1);

        userlist[0]=user;

        user = new User();

        user.setId(2);

        userlist[1]=user;

        //传递user对象查询用户列表

        Listlist = userMapper.selectUserByArray(userlist);

        //关闭session

        session.close();

    }

4.4.3.4传递单个数组（数组中是字符串类型）：

请阅读文档学习。

◆Mapper.xml

        select * from user 

            #{item} 

如果数组中是简单类型则写为#{item}，不用再通过ognl获取对象属性值了。

◆Mapper接口：

public List selectUserByArray(Object[] userlist) throws Exception;

◆测试：

Public void testselectUserByArray()throws Exception{

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获限mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //构造查询条件List

        Object[] userlist = new Object[2];

        userlist[0]=”1”;

        userlist[1]=”2”;

        //传递user对象查询用户列表

        Listlist = userMapper.selectUserByArray(userlist);

        //关闭session

        session.close();

    }

4.4.4Sql片段

Sql中可将重复的sql提取出来，使用时用include引用即可，最终达到sql重用的目的，如下：

        select * from user 

        and id=#{id}

        and username like '%${username}%'

◆将where条件抽取出来：

        and id=#{id}

        and username like '%${username}%'

◆使用include引用：

        select * from user 

注意：如果引用其它mapper.xml的sql片段，则在引用时需要加上namespace，如下：

5关联查询

5.1商品订单数据模型

5.2一对一查询

案例：查询所有订单信息，关联查询下单用户信息。

注意：因为一个订单信息只会是一个人下的订单，所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则为一对多查询，因为一个用户可以下多个订单。

5.2.1方法一：

使用resultType，定义订单信息po类，此po类中包括了订单信息和用户信息：

5.2.1.1Sql语句：

SELECT 

  orders.*,

  user.username,

  userss.address

FROM

  orders,

  user 

WHERE orders.user_id = user.id

5.2.1.2定义po类

Po类中应该包括上边sql查询出来的所有字段，如下：

public class OrdersCustom extends Orders {

    private String username;// 用户名称

    private String address;// 用户地址

get/set。。。

OrdersCustom类继承Orders类后OrdersCustom类包括了Orders类的所有字段，只需要定义用户的信息字段即可。

5.2.1.3Mapper.xml

    SELECT

    orders.*,

    user.username,

    user.address

    FROM

    orders,    user

    WHERE orders.user_id = user.id 

5.2.1.4Mapper接口：

public List findOrdersList() throws Exception;

5.2.1.5测试：

Public void testfindOrdersList()throws Exception{

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获限mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //查询订单信息

        List list = userMapper.findOrdersList();

        System.out.println(list);

        //关闭session

        session.close();

    }

5.2.1.6总结：

 定义专门的po类作为输出类型，其中定义了sql查询结果集所有的字段。此方法较为简单，企业中使用普遍。

5.2.2方法二：

使用resultMap，定义专门的resultMap用于映射一对一查询结果。

5.2.2.1Sql语句：

SELECT 

  orders.*,

  user.username,

  user.address

FROM

  orders,

  user 

WHERE orders.user_id = user.id

5.2.2.2定义po类

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

5.2.2.3Mapper.xml

    SELECT

    orders.*,

    user.username,

    user.address

    FROM

    orders,    user

    WHERE orders.user_id = user.id 

这里resultMap指定userordermap。

5.2.2.4定义resultMap

需要关联查询映射的是用户信息，使用association将用户信息映射到订单对象的用户属性中。

association：表示进行关联查询单条记录

property：表示关联查询的结果存储在cn.itcast.mybatis.po.Orders的user属性中

javaType：表示关联查询的结果类型

：查询结果的user_id列对应关联对象的id属性，这里是表示user_id是关联查询对象的唯一标识。

：查询结果的username列对应关联对象的username属性。

5.2.2.5Mapper接口：

public List findOrdersListResultMap() throws Exception;

5.2.2.6测试：

Public void testfindOrdersListResultMap()throws Exception{

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获限mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //查询订单信息

        List list = userMapper.findOrdersList2();

        System.out.println(list);

        //关闭session

        session.close();

    }

5.2.2.7小结：

使用association完成关联查询，将关联查询信息映射到pojo对象中。

5.3一对多查询

案例：查询所有订单信息及订单下的订单明细信息。

订单信息与订单明细为一对多关系。

使用resultMap实现如下：

5.3.1Sql语句：

SELECT 

  orders.*,

  user.username,

  user.address,

  orderdetail.id orderdetail_id,

  orderdetail.items_id,

  orderdetail.items_num

FROM

  orders,user,orderdetail

WHERE orders.user_id = user.id 

AND orders.id = orderdetail.orders_id

5.3.2定义po类

在Orders类中加入User属性。

在Orders类中加入List orderdetails属性

5.3.3Mapper.xml

    SELECT

    orders.*,

    user.username,

    user.address,

    orderdetail.id orderdetail_id,

    orderdetail.items_id,

    orderdetail.items_num

    FROM orders,user,orderdetail

    WHERE orders.user_id = user.id

    AND orders.id = orderdetail.orders_id

5.3.4定义resultMap

黄色部分和上边一对一查询订单及用户信息定义的resultMap相同，

collection部分定义了查询订单明细信息。

collection：表示关联查询结果集

property="orderdetails"：关联查询的结果集存储在cn.itcast.mybatis.po.Orders上哪个属性。

ofType="cn.itcast.mybatis.po.Orderdetail"：指定关联查询的结果集中的对象类型即List中的对象类型。

及的意义同一对一查询。

5.3.4.1resultMap使用继承

上边定义的resultMap中黄色部分和一对一查询订单信息的resultMap相同，这里使用继承可以不再填写重复的内容，如下：

使用extends继承订单信息userordermap。

5.3.5Mapper接口：

public ListfindOrdersDetailList () throws Exception;

5.3.6测试：

Public void testfindOrdersDetailList()throws Exception{

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获限mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //查询订单信息

        List list = userMapper.findOrdersDetailList();

        System.out.println(list);

        //关闭session

        session.close();

    }

5.3.7小结

使用collection完成关联查询，将关联查询信息映射到集合对象。

5.4多对多查询

5.4.1查询用户购买的商品信息

5.4.1.1需求

查询用户购买的商品信息。

5.4.1.2sql

需要查询所有用户信息，关联查询订单及订单明细信息，订单明细信息中关联查询商品信息

SELECT

FROM

WHERE

AND orders.id = orderdetail.orders_id

AND orderdetail.items_id = items.id

5.4.1.3po定义

 在User中添加List orders 属性，在Orders类中加入List orderdetails属性

5.4.1.4resultMap

需要关联查询映射的信息是：订单、订单明细、商品信息

订单：一个用户对应多个订单，使用collection映射到用户对象的订单列表属性中

订单明细：一个订单对应多个明细，使用collection映射到订单对象中的明细属性中

商品信息：一个订单明细对应一个商品，使用association映射到订单明细对象的商品属性中。

5.4.2小结

一对多是多对多的特例，如下需求：

查询用户购买的商品信息，用户和商品的关系是多对多关系。

需求1：

查询字段：用户账号、用户名称、用户性别、商品名称、商品价格(最常见)

企业开发中常见明细列表，用户购买商品明细列表，

使用resultType将上边查询列映射到pojo输出。

需求2：

查询字段：用户账号、用户名称、购买商品数量、商品明细（鼠标移上显示明细）

使用resultMap将用户购买的商品明细列表映射到user对象中。

5.5resultMap小结

resultType：

作用：

 将查询结果按照sql列名pojo属性名一致性映射到pojo中。

场合：

 常见一些明细记录的展示，比如用户购买商品明细，将关联查询信息全部展示在页面时，此时可直接使用resultType将每一条记录映射到pojo中，在前端页面遍历list（list中是pojo）即可。

resultMap：

 使用association和collection完成一对一和一对多高级映射（对结果有特殊的映射要求）。

association：

作用：

 将关联查询信息映射到一个pojo对象中。

场合：

 为了方便查询关联信息可以使用association将关联订单信息映射为用户对象的pojo属性中，比如：查询订单及关联用户信息。

 使用resultType无法将查询结果映射到pojo对象的pojo属性中，根据对结果集查询遍历的需要选择使用resultType还是resultMap。

collection：

作用：

 将关联查询信息映射到一个list集合中。

场合：

 为了方便查询遍历关联信息可以使用collection将关联信息映射到list集合中，比如：查询用户权限范围模块及模块下的菜单，可使用collection将模块映射到模块list中，将菜单列表映射到模块对象的菜单list属性中，这样的作的目的也是方便对查询结果集进行遍历查询。

 如果使用resultType无法将查询结果映射到list集合中。

5.6延迟加载

 需要查询关联信息时，使用mybatis延迟加载特性可有效的减少数据库压力，首次查询只查询主要信息，关联信息等用户获取时再加载。

5.6.1打开延迟加载开关

在mybatis核心配置文件中配置：

lazyLoadingEnabled、aggressiveLazyLoading