Mybatis源码之手写Mybatis

一、需求分析

1、Mybatis是什么？

一个半自动化的orm框架（Object Relation Mapping)。

2、Mybatis完成什么工作？

在面向对象编程中，我们操作的都是对象，Mybatis框架是一个数据访问层的框架，帮我们完成对象在数据库中的存、取工作。

为什么称为半自动化？

关系型数据库的操作是通过SQL语句来完成的，Mybatis在帮我们做对象的存取时，需要我们提供对应的SQL语句，它不自动帮我们生成SQL语句，而只帮我们完成：

1）对象属性到SQL语句参数的自动填充；2）SQL语句执行结果集到对象的自动提取；所以称为半自动的。而我们了解的另一个ORM框架Hibernate则是全自动的。

半自动化的不足：我们得辛苦一点编写SQL语句。半自动化的优点：我们可以完全把控执行的SQL语句，可以随时灵活调整、优化。

3、为什么要用Mybatis?

1）mybatis学习、使用简单2）半自动化的优点

4、为什么要学好Mybatis?

一线互联网公司出于性能、调优、使用简单、完全可控的需要，在数据库访问层都是采用Mybatis。

5 、为什么要用orm框架？

都是为了提高生产效率，少写代码，少写重复代码！不用orm框架，能用什么来完成数据的存取？jdbc看看jdbc编程的代码示例

<code>package com.study.leesmall.sample.mybatis.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import com.study.leesmall.sample.mybatis.model.User;

@Component
public class UserDao {

    @Autowired 

    private DataSource dataSource;

    public void addUser(User user) throws SQLException {

        try (
                // 1、获取连接
                Connection conn = DataSourceUtils.getConnection(dataSource);
                // 2、创建预编译语句对象
                PreparedStatement pst = conn.prepareStatement(
                        "insert into t_user(id,name,sex,age,address,phone,wechat,email,account,password) "
                                + " values(?,?,?,?,?,?,?,?,?,?)");) {
            // 3、设置参数值
            int i = 1;
            pst.setString(i++, user.getId());
            pst.setString(i++, user.getName());
            pst.setString(i++, user.getSex());
            pst.setInt(i++, user.getAge());
            pst.setString(i++, user.getAddress());
            pst.setString(i++, user.getPhone());
            pst.setString(i++, user.getWechat());
            pst.setString(i++, user.getEmail());
            pst.setString(i++, user.getAccount());
            pst.setString(i++, user.getPassword());

            // 4、执行语句
            int changeRows = pst.executeUpdate();
        }
    }

    public List<user> queryUsers(String likeName, int minAge, int maxAge, String sex) throws SQLException {
        // 1、根据查询条件动态拼接SQL语句
        StringBuffer sql = new StringBuffer(
                "select id,name,sex,age,address,phone,wechat,email,account,password from t_user where 1 = 1 ");
        if (!StringUtils.isEmpty(likeName)) {
            sql.append(" and name like ? ");
        }

        if (minAge >= 0) {
            sql.append(" and age >= ? ");
        }

        if (maxAge >= 0) {
            sql.append(" and age <= ? ");
        }

        if (!StringUtils.isEmpty(sex)) {
            sql.append(" and sex = ? "); 

        }

        try (Connection conn = DataSourceUtils.getConnection(dataSource);
                PreparedStatement pst = conn.prepareStatement(sql.toString());) {
            // 2 设置查询语句参数值
            int i = 1;
            if (!StringUtils.isEmpty(likeName)) {
                pst.setString(i++, "%" + likeName + "%");
            }

            if (minAge >= 0) {
                pst.setInt(i++, minAge);
            }

            if (maxAge >= 0) {
                pst.setInt(i++, maxAge);
            }

            if (!StringUtils.isEmpty(sex)) {
                pst.setString(i++, sex);
            }

            // 3 执行查询
            ResultSet rs = pst.executeQuery();

            // 4、提取结果集
            List<user> list = new ArrayList<>();
            User u;
            while (rs.next()) {
                u = new User();
                list.add(u);
                u.setId(rs.getString("id"));
                u.setName(rs.getString("name"));
                u.setSex(rs.getString("sex"));
                u.setAge(rs.getInt("age"));
                u.setPhone(rs.getString("phone"));
                u.setEmail(rs.getString("email"));
                u.setWechat(rs.getString("wechat"));
                u.setAccount(rs.getString("account"));
                u.setPassword(rs.getString("password"));
            }

            rs.close();

            return list;
        }
    }
}/<user>/<user>/<code>

用JdbcTemplate的代码示例：

<code>package com.study.leesmall.sample.mybatis.jdbc;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.util.StringUtils;

import com.study.leesmall.sample.mybatis.model.User;

//@Component
public class UserDaoUseJdbcTemplate {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void addUser(User user) throws SQLException {
        String sql = "insert into t_user(id,name,sex,age,address,phone,wechat,email,account,password) "
                + " values(?,?,?,?,?,?,?,?,?,?)";
        jdbcTemplate.update(sql, user.getId(), user.getName(), user.getSex(), user.getAge(), user.getAddress(),
                user.getPhone(), user.getWechat(), user.getEmail(), user.getAccount(), user.getPassword());
    }

    public List<user> queryUsers(String likeName, int minAge, int maxAge, String sex) throws SQLException {
        // 1、根据查询条件动态拼接SQL语句
        StringBuffer sql = new StringBuffer(
                "select id,name,sex,age,address,phone,wechat,email,account,password from t_user where 1 = 1 ");
        List<object> argList = new ArrayList<>();
        if (!StringUtils.isEmpty(likeName)) {
            sql.append(" and name like ? ");
            argList.add("%" + likeName + "%");
        }

        if (minAge >= 0) {
            sql.append(" and age >= ? ");
            argList.add(minAge);
        }

        if (maxAge >= 0) {
            sql.append(" and age <= ? ");
            argList.add(maxAge);
        } 


        if (!StringUtils.isEmpty(sex)) {
            sql.append(" and sex = ? ");
            argList.add(sex);
        }

        return jdbcTemplate.query(sql.toString(), argList.toArray(), new RowMapper<user>() {
            public User mapRow(ResultSet rs, int rowNum) throws SQLException {
                User u = new User();
                u.setId(rs.getString("id"));
                u.setName(rs.getString("name"));
                u.setSex(rs.getString("sex"));
                u.setAge(rs.getInt("age"));
                u.setPhone(rs.getString("phone"));
                u.setEmail(rs.getString("email"));
                u.setWechat(rs.getString("wechat"));
                u.setAccount(rs.getString("account"));
                u.setPassword(rs.getString("password"));

                return u;
            }
        });
    }
}/<user>/<object>/<user>/<code>

参数设置代码、结果集处理代码、JDBC过程代码都会大量重复，毫无技术含量！

那就写个框架做了它！显示我们的牛B!

6、框架确切需求

1）用户只需定义持久层接口（dao接口）、接口方法对应的SQL语句。

2）用户需指明接口方法的参数与SQL语句参数的对应关系。

3）用户需指明SQL查询结果集与对象属性的映射关系。

4）框架完成接口对象的生成，JDBC执行过程

二、设计

1、需求 1

1）用户只需定义持久层接口（dao接口）、接口方法对应的SQL语句。

设计问题：

1）我们该提供什么样的方式来让用户定义SQL语句？

2）SQL语句怎么与接口方法对应？

3）这些SQL语句、对应关系我们框架需要获取到，谁来获取？又该如何表示存储

1.1 SQL定义方式

XML方式：独立于代码，修改很方便（不需改代码）注解方式：直接加在方法上，零xml配置

问题：SQL语句可做增、删、改、查操作，我们是否要对SQL做个区分？答：要，因为jdbc中对应有不同的方法 executeQuery executeUpdate

<code>


 /<code>

<code><insert>insert into t_user(id,name,sex,age) values(?,?,?,?)/<insert>/<code>

注解方式定义SQL语句定义方式 ：设计增删改查的注解：@Insert @Update @Delete @Select ，注解项定义SQL

<code>@Documented
@Retention(RUNTIME)
@Target({ METHOD })
public @interface Insert {
    String value();
}/<code>

<code>@Insert("insert into t_user(id,name,sex,age) values(?,?,?,?)")
public void addUser(User user);/<code>

1.2 SQL语句与接口方法对应

xml方式时，如何来映射SQL语句对应的接口方法？

为元素定义一个id，id的值为对应的类名.方法名，如何？

<code><insert>
         insert into t_user(id,name,sex,age) values(?,?,?,?)
/<insert>/<code>

一个Dao接口中可能会定义很多个数据访问方法，id这么写很长，能不能便捷一点？

这是在做SQL与接口方法的映射，我们来加一个mapper元素，它可包含多个insert、update、delete、select元素，相当于分组，一个接口中定义的分到一组。

在mapper中定义一个属性namespace，指定里面元素的名称空间，namespace的值对应接口类名，里面元素的id对应方法名。

mybatis-mapper.dtd.

<code>




/<code>

这个xml文件命名为 userDaoMapper.xml，内容如下：

<code><mapper>
    <insert>
        insert into t_user(id,name,sex,age) values(?,?,?,?)
    /<insert>
/<mapper>/<code>

1.3 映射关系的获取与表示、存储

xml方式：解析xml来获取注解方式： 读取注解信息

问题：

1) 怎么表示？得设计一个类来表示从xml、注解获得的SQL映射信息。

注意：

id为唯一id:xml方式：id=namespace.id属性值注解方式：id=完整类名.方法名

2) 怎么存储得到的MappedStatement?这些其实就是一个配置信息，我们定义一个Configuration类：

注意：key 为MappedStatement的id

3) 得有类来负责解析xml

XmlMapperBuilder负责解析xml文档（parse方法的resource参数用来指定inputStream的来源），parse方法它调用XMLStatementBuilder来解析里面的parse方法，解析完成以后，把获得的信息存储到Configuration里面

4）mapper中可以让用户如何来指定文件位置？

文件可以是在类目录下，也可是在文件系统目录下。如何区分？

规定：类目录下的方式通过 resource属性指定；文件系统文件通过 url属性指定，值采用URL 本地文件格式指定：file:///

<code><configuration> 

    <mappers>
        <mapper>
        <mapper>
    <mappers>
/<mappers>/<mappers>/<configuration>/<code>

定义 mybatis-config.dtd.

5) 增加了一个config xml文件，就的有类来解析它。

增加解析mybatis-config.xml配置文件的类.

6) 注解的方式需要获取SQL映射信息，也得有个类来做这件事.

7) 谁来使用MapperAnnotationBuilder？

Configuration吧，在它里面持有MapperAnnotationBuilder，增加添加Mapper接口类的方法。

8) 用户如何来指定他们的Mapper接口类？

1、在mybatis-config.xml的mappers中通过mapper指定？

<code><configuration>
    <mappers>
        <mapper>
        <mapper>
    <mappers>
/<mappers>/<mappers>/<configuration>/<code>

如何来区分它是个Mapper接口呢？

给mapper加一个属性class来专门指定Mapper类名.

<code><configuration>
    <mappers>
        <mapper>
        <mapper>
        <mapper>
    <mappers>
/<mappers>/<mappers>/<configuration>/<code>

mybatis-config.dtd

<code>


resource CDATA #IMPLIED
url CDATA #IMPLIED
class CDATA #IMPLIED
>/<code>

问题：

1、这样一个一个类来指定，好繁琐？能不能指定一个包名，包含包下所有接口、子孙包下的接口类？2、包含包下所有的接口，好像不是很灵活，能不能让用户指定包下所有某类型的接口？

如是什么类型的类，或带有某注解的接口。好的，这很容易，在mappers元素中增加一个package元素，pacakge元素定义三个属性：

mybatis-config.dtd.

<code>




resource CDATA #IMPLIED 

url CDATA #IMPLIED
class CDATA #IMPLIED
>


name CDATA #IMPLIED
type CDATA #IMPLIED
annotation CDATA #IMPLIED
>/<code>

为了用户使用方便，我们给定义一个@Mapper注解，默认规则：指定包下加了@Mapper注解的接口，如何？

加了package元素，又得在Configuration中增加对应的方法了：

约定俗成的规则：指定包下扫到的@Mapper接口，例如UserDao，还可以在包下定义 UserDao.xml，会被加载解析。

2 需求2

需求2、用户需指明接口方法的参数与语句参数的对应关系。

2.1 语句参数指定

看下面的Mapper示例

<code>@Mapper
public interface UserDao {
    @Insert("insert into t_user(id,name,sex,age) values(?,?,?,?)")
    void addUser(User user);
}/<code>

User对象的属性如何与 values(?)对应？靠解析 t_user(id,name,sex,age) 可行吗？

难度太大！万一User的name叫xname呢！既然靠我们来解析不行，那就请用户指明吧。

用户如何来指明呢？

我们来给定个规则： ？ 用 #{属性名} 代替，我们来解析SQL语句中的 #{属性名} 来决定参数对应。

<code>@Insert("insert into t_user(id,name,sex,age) values(#{id},#{name},#{sex},#{age})")
void addUser(User user);/<code>

万一是这种情况呢？

<code>@Insert("insert into t_user(id,name,sex,age) values(#{id},#{name},#{sex},#{age})")
void addUser(String id,String xname,String sex,int age);/<code>

完全可以要求用户必须与参数名对应 ：#{xname}。为了提高点自由度（及后面方便SQL复用），可以定义一个注解让用户使用，该注解只可用在参数上.

<code>@Insert("insert into t_user(id,name,sex,age) values(#{id},#{name},#{sex},#{age})")
void addUser(String id,@Param("name")String xname,String sex,int age);/<code>

万一是这种情况呢？

<code>@Insert("insert into t_user(id,name,sex,age,org_id) values(#{id},#{name},#{sex},#{age},#{id})")
void addUser(User user,Org org);/<code>

User和Org中都有id属性，name属性.

好办，如果方法参数是对象，则以 参数名.属性 的方式指定SQL参数：

<code>@Insert("insert into t_user(id,name,sex,age,org_id) values(#{user.id},#{user.name},#{user.sex},#{user.age},#{org.id})")
void addUser(User user,Org org);/<code>

一样也可以使用@Param

如果方法参数是这种情况呢?

<code>@Insert("insert into t_user(id,name,sex,age) values(#{id},#{name},#{sex},#{age})")
void addUser(Map map);/<code>

对应Map中的key

如果方法参数是这种情况呢?

<code>@Insert("insert into t_user(id,name,sex,age,org_id) values(#{user.id},#{user.name},#{user.sex},#{user.age},#{org.id})")
void addUser(Map map,Org org);/<code>

<code>@Insert("insert into t_user(id,name,sex,age,org_id) values(#{user.id},#{user.name},#{user.sex},#{user.age},#{org.id})")
void addUser(@Param("user")Map map,Org org);/<code>

再来看下下面的场景：

<code>@Select("select id,name,sex from t_user where sex = #{sex} order by #{orderColumn}")
List<user> query(String sex, String orderColumn);/<user>/<code>

order by #{orderColumn} order by ？ 可以吗？

不可以，也就是说 方法参数不全是用来做SQL语句的预编译参数值的，有些是来构成SQL语句的一部分的。

那怎么让用户指定呢？

一样，定义个规则： ${属性名} 表示这里是字符串替换

<code>@Select("select id,name,sex from t_user where sex = #{sex} order by ${orderColumn}")
List<user> query(String sex, String orderColumn);/<user>/<code>

2.2 SQL中参数映射解析

问题：

1) SQL中参数映射解析要完成的是什么工作？

解析出真正的SQL语句

获得方法参数与语句参数的对应关系 ： 问号N---哪个参

<code>    public void addUser(User user) throws SQLException {

        try (
                // 1、获取连接
                Connection conn = DataSourceUtils.getConnection(dataSource);
                // 2、创建预编译语句对象
                PreparedStatement pst = conn.prepareStatement(
                        "insert into t_user(id,name,sex,age,address,phone,wechat,email,account,password) "
                                + " values(?,?,?,?,?,?,?,?,?,?)");) {
            // 3、设置参数值
            int i = 1;
            pst.setString(i++, user.getId());
            pst.setString(i++, user.getName()); 

            pst.setString(i++, user.getSex());
            pst.setInt(i++, user.getAge());
            pst.setString(i++, user.getAddress());
            pst.setString(i++, user.getPhone());
            pst.setString(i++, user.getWechat());
            pst.setString(i++, user.getEmail());
            pst.setString(i++, user.getAccount());
            pst.setString(i++, user.getPassword());

            // 4、执行语句
            int changeRows = pst.executeUpdate();
        }
    }/<code>

怎么解析？

<code>@Insert("insert into t_user(id,name,sex,age,org_id) values(#{user.id},#{user.name},#{user.sex},#{user.age},#{org.id})")
void addUser(@Param("user")Map map,Org org);/<code>

方式有：

正则表达式antlr

怎么表示？

问号的index、值来源

2) 这个解析的工作在何时做好？谁来做好？

设计怎么来执行一个Mapper接口了SqlSessionSqlSessionFactory

3. 需求4

1）用户只需定义持久层接口（dao接口）、接口方法对应的SQL语句。

2）用户需指明接口方法的参数与语句参数的对应关系。

3）用户需指明查询结果集与对象属性的映射关系。

4）框架完成接口对象的生成，JDBC执行过程。

3.1 SQL语句有了，参数对应关系也有了，我们想想怎么执行SQL吧。

问题：1、要执行SQL，我们得要有DataSource，谁来持有DataSource?

2、谁来执行SQL? Configuration ?

不合适，它是配置对象，持有所有配置信息！既然是来做事的，那就先定义一个接口吧：SqlSession

该为它定义什么方法呢？

需求4：框架完成接口对象的生成，JDBC执行过程。

用户给定Mapper接口类，要为它生成对象，用户再使用这个对象完成对应的数据库操作。

使用示例：

<code>UserDao userDao = sqlSession.getMapper(UserDao.class);
userDao.addUser(user);/<code>

来为它定义一个实现类：DefaultSqlSession

它该持有什么属性吗？用户给入一个接口类，DefaultSqlSession中就为它生成一个对象？万一给入的不是一个Mapper接口呢？也为其生成一个对象就不合理了？

那怎么判断给入的接口类是否是一个Mapper接口呢？那就只有在配置阶段扫描、解析Mapper接口时做个存储了。存哪，用什么存？这也是配置信息，还是存在Configuration 中，就用个Set来存吧。

DefaultSqlSession中需要持有Configuration.

3.2 对象生成

1、如何为用户给入的Mapper接口生成对象？

　　很简单，JDK动态代理

<code>Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] {
mapperInterface }, invocationHandler);/<code>

写一版DefaultSqlSession的实现：

<code>package com.study.leesmall.mybatis.session;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import com.study.leesmall.mybatis.config.Configuration;
public class DefaultSqlSession implements SqlSession {
    private Configuration configuration; 

    
    public DefaultSqlSession(Configuration configuration) {
        super();
        this.configuration = configuration;
    }
    
    @Override
    public  T getMapper(Class type) {
        //检查给入的接口
        if (!this.configuration.getMappers().contains(type)) {
        throw new RuntimeException(type + " 不在Mapper接口列表中！");
        }
        //得到 InvocationHandler
        InvocationHandler ih = null; // TODO 必须要有一个
        // 创建代理对象
        T t = (T)Proxy.newProxyInstance(type.getClassLoader(), new
        Class>[] {type}, ih);
        return t;
    }
}/<code>

问题：每次调用getMapper(Class type)都需要生成一个新的实例吗？

代理对象中持有InvocationHandler，如果InvocationHandler能做到线程安全，就只需要一个实例。还得看InvocationHandler，先放这吧，把InvocationHandler搞定先

3.3 执行SQL的InvocationHandler

了解 InvocationHandlerInvocationHandler 是在代理对象中完成增强。我们这里通过它来执行SQL。

<code>public interface InvocationHandler {
    /**
    @param proxy 生成的代理对象 

    @param method 被调用的方法
    @param args
    @return Object 方法执行的返回值
    */
    public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable;
}/<code>

来实现我们的InvocationHandler： MapperProxy

<code>package com.study.leesmall.mybatis.session;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MapperProxy implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable {
    // TODO 这里需要完成哪些事？
    return null;
}
}/<code>

思考： 在 MapperProxy.invoke方法中需要完成哪些事？

<code>package com.study.leesmall.mybatis.session;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MapperProxy implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable {
        // TODO 这里需要完成哪些事？
        // 1、获得方法对应的SQL语句
        
        // 2、解析SQL参数与方法参数的对应关系，得到真正的SQL与语句参数值
        
        // 3、获得数据库连接
         

        // 4、执行语句
        
        // 5、处理结果
        
        return null;
    }
}/<code>

1、获得方法对应的SQL语句　　要获得SQL语句，需要用到Configuration，MapperProxy中需持有Configuration.

问题：id怎么得来？id是类名.方法名。从invoke方法的参数中能得来吗？

<code>public Object invoke(Object proxy, Method method, Object[] args)/<code>

method参数能得到方法名，但得到的类名不是Mapper接口类名。

那就直接让MapperProxy持有其增强的Mapper接口类吧！简单！

2、解析SQL参数与方法参数的对应关系，得到真正的SQL与语句参数值

逻辑：1）查找SQL语句中的 #{属性} ，确定是第几个参数，再在方法参数中找到对应的值，存储下来，替换 #{属性} 为？ 。2）查找SQL语句中的 ${属性} ，确定是哪个参数，再在方法参数中找到对应的值，替换 ${属性} 。3）返回最终的SQL与参数数组。

解析过程涉及的数据：SQL语句、方法的参数定义、方法的参数值

<code>@Insert("insert into t_user(id,name,sex,age) values(#{id},#{name},#
{sex},#{age})")
void addUser(String id,@Param("name")String xname,String sex,int age);/<code>

<code>Parameter[] params = method.getParameters();/<code>

<code>public Object invoke(Object proxy, Method method, Object[] args)/<code>

说明： 这里是要确定SQL中的？N是哪个参数值。

这里要分三种情况： 方法参数是0参数，单个参数、多个参数。

0参数：不需要考虑参数了。

单个参数：SQL中的参数取值参数的属性或就是参数本身。

多个参数：则需要确定SQL中的参数值取第几个参数的值。

多个参数的情况，可以有两种做法：

方式一： 查找#{属性}，根据Parameter[]中的名称（注解名、序号）匹配确定是第几个参数，再到 Object[] args中取到对应的值。

方式二：先将Parameter[] 和 Object[] args转为Map，参数名（注解名、序号）为key，Object参数值为值；然后再查找SQL语句中的 #{}${}，根据里面的名称到map中取对应的值。

哪种方式更好呢？我们来看下两者查找过程的输出：

方式一相较于方式二，看起来复杂的地方是要遍历Parameter[] 来确定索引号。

思考一下：这种查找对应关系的事，需要每次调用方法时都做吗？方法的参数会有很多个吗？

这个对应关系可以在扫描解析Mapper接口时做一次即可。在调用Mapper代理对象的方法时，就可以直接根据索引号去Object[] args中取参数值了。

方式2则每次调用Mapper代理对象的方法时，都需要创建转换Map。

而且方式一，单个参数与多个参数我们可以同样处理。

要在扫描解析Mapper接口时做参数解析我们就需要定义对应的存储结构，及修改MappedStatement了

？N--- 参数索引号 的对应关系如何表示？？N 就是一个数值，而且是一个顺序数（只是jdbc中的？是从1开始）。我们完全可以用List来存储。

参数索引号，仅仅是个索引号吗？

<code>@Insert("insert into t_user(id,name,sex,age,org_id) values(#{user.id},#
{user.name},#{user.sex},#{user.age},#{org.id})")
void addUser(User user,Org org);/<code>

它应该是索引号、和里面的属性两部分。

解析阶段由它们俩完成这件事：

我们在MappedStatement中再增加一个方法来完成根据参数映射关系得到真正参数值的方法：

把MapperProxy的invoke方法填填看：

<code>@Override
public Object invoke(Object proxy, Method method, Object[] args) throws
Throwable {
    // TODO 这里需要完成哪些事？
    // 1、获得方法对应的SQL语句
    String id = this.mapper.getName() + "." + method.getName();
    MappedStatement ms = this.configuration.getMappedStatement(id);
    
    // 2、解析SQL参数与方法参数的对应关系，得到真正的SQL与语句参数值
    RealSqlAndParamValues rsp = ms.getRealSqlAndParamValues(args);
    
    // 3、获得数据库连接
    Connection conn =
    this.configuration.getDataSource().getConnection();
    
    // 4、执行语句。
    PreparedStatement pst = conn.prepareStatement(rsp.getSql()); 

    // 疑问：语句一定是PreparedStatement？
    // 设置参数
    if (rsp.getParamValues() != null) {
        int i = 1;
        for (Object p : rsp.getParamValues()) {
            pst.setxxx(i++, p); //这里写不下去了.......如何决定该调用pst的哪
            个set方法？
        }
        
    }
    
    // 5、处理结果
    
    return null;
}/<code>

4 JavaType、JdbcType转换

1 认识它们

JavaType：java中的数据类型。JdbcType：Jdbc规范中根据数据库sql数据类型定义的一套数据类型规范，各数据库厂商遵照这套规范来提供jdbc驱动中数据类型支持。

疑问：为什么我们在这里需要考虑它呢？pst.setxxx(i++, p)，我们不能根据p的类型选择set方法吗？

看pst的set方法中与对应的：

我们判断p的类型，然后选择不可吗? 像下面这样

<code>int i = 1;
for (Object p : rsp.getParamValues()) { 

    if (p instanceof Byte) {
        pst.setByte(i++, (Byte) p);
    } 
    else if (p instanceof Integer) {
        pst.setInt(i++, (int) p);
    }
    else if (p instanceof String) {
        pst.setString(i++, (String) p);
    }
    ...
    else if(...)
}/<code>

我们来看一下这种情况：

看PreparedStatment的set方法：

上面前两种情况怎么处理？这个需要用户说明其要使用的JDBCType，不然鬼知道他想要什么。

让用户怎么指定呢？

<code>#{user.id，jdbcType=TIME}/<code>

javaType有需要指定不呢？　　好像不需要，那就暂放下。

第3种情况怎么处理？这是一个未知的问题，鬼知道将来使用我的框架的人会需要怎么处理他们的对象呢！如何以不变应万变呢？面向接口编程定义一个什么样的接口呢？该接口的用途是什么？

完成Object p 的pst.setXXX（）。

2 TypeHandler

下面这个if-else-if的代码是否可以通过TypeHandler，换成策略模式？

<code>int i = 1;
for (Object p : rsp.getParamValues()) {
    if (p instanceof Byte) {
        pst.setByte(i++, (Byte) p);
    } 
    else if (p instanceof Integer) {
        pst.setInt(i++, (int) p);
    }
    else if (p instanceof String) {
        pst.setString(i++, (String) p);
    }
    ...
    else if(...)
}/<code>

定义一些常用数据类型的TypeHandler.先不急着去定义，我们来考虑一下下面的问题。

这个怎么使用它呢？在MapperProxy.invoke()中？

<code>int i = 1;
for (Object p : rsp.getParamValues()) {
    TypeHandler th = getTypeHandler(p.getClass);//还需要别的参数吗？
    th.setParameter(pst,i++,p);
}/<code>

还需要JDBCType。

<code>int i = 1;
for (Object p : rsp.getParamValues()) {
    TypeHandler th = getTypeHandler(p.getClass,jdbcType);//jdbcType 从哪来？
    th.setParameter(pst,i++,p);
}/<code>

问题：1、是在invoke方法中来判断TypeHandler呢？还是在MappedStatement的getRealSqlAndParamValues时就返回值对应的TypeHandler？

选择后者更合适！那SqlAndParamValues中的参数值就不能是Object[]。它是值和TypeHandler两部分构成。

MapperProxy中的代码就变成下面这样了：

<code>int i = 1;
for (ParamValue p : rsp.getParamValues()) {
    TypeHandler th = p.getTypeHandler()
    th.setParameter(pst,i++,p.getValue());
}/<code>

2、MappedStatement又从哪里去获取TypeHandler呢？

我们会定义一些常用的，用户可能会提供一些。用户怎么提供？存储到哪里？Configuration 吧，它最合适了。以什么结构来存储呢？这里涉及到查找，需要根据 参数的javaType、jdbcTyp来查找。那就定义一个map吧，如下这样如何？

<code>Map<type>> typeHandlerMap;/<type>/<code>

我们定义一个TypeHandlerRegistry类来持有所有的TypeHandler,Configuration 中则持有TypeHandlerRegistry.

同时我们完善一下TypeHandler.

3、用户如何来指定它们的TypeHandler?

在mybatis-config.xml中增加一个元素来让用户指定吧。mybatis-config.dtd

<code>




resource CDATA #IMPLIED
url CDATA #IMPLIED
class CDATA #IMPLIED
>


name CDATA #IMPLIED
type CDATA #IMPLIED
annotation CDATA #IMPLIED
>




class CDATA #REQUIRED
>/<code>

既可以用typeHandler指定单个，也可用package指定扫描的包，扫描包下实现了TypeHandler接口的类.

解析注册的工作就交给XMLConfigBuilder.

4、MappedStatement中来决定TypeHandler,它就需要Configuration.

5、可不可以在解析语句参数关系时，就决定好TypeHandler?

可以。我们在ParameterMap中增加typeHandler属性。

5 执行结果处理

5.1 执行结果处理要干的是什么事

pst.executeUpate()的返回结果是int，影响的行数。

pst.executeQuery()的返回结果是ResultSet。

在得到SQL语句执行的结果后，要转为方法的返回结果进行返回。这就是执行结果处理要干的事根据方法的返回值类型来进行相应的处理。

这里我们根据SQL语句执行结果的不同，分开处理：

<code>@Override
public Object invoke(Object proxy, Method method, Object[] args) throws
Throwable {
        // TODO 这里需要完成哪些事？
        // 1、获得方法对应的SQL语句
        String id = this.mapper.getName() + "." + method.getName();
        MappedStatement ms = this.configuration.getMappedStatement(id);
        
        // 2、解析SQL参数与方法参数的对应关系，得到真正的SQL与语句参数值
        RealSqlAndParamValues rsp = ms.getRealSqlAndParamValues(args);
         

        // 3、获得数据库连接
        Connection conn =
        this.configuration.getDataSource().getConnection();
        
        // 4、创建语句对象。
        PreparedStatement pst = conn.prepareStatement(rsp.getSql());
        
        // 5、设置语句参数
        int i = 1;
        for (ParamValue p : rsp.getParamValues()) {
            TypeHandler th = p.getTypeHandler()
            th.setParameter(pst,i++,p.getValue());
        }
        
        // 6、执行语句并处理结果
        switch (ms.getSqlCommandType()) {
            case INSERT:
            case UPDATE:
            case DELETE:
                int rows = pst.executeUpdate();
                return handleUpdateReturn(rows, ms, method);
            case SELECT:
                ResultSet rs = pst.executeQuery();
                return handleResultSetReturn(rs, ms, method);
        }
}

private Object handleUpdateReturn(int rows, MappedStatement ms, Method
method) {
    // TODO Auto-generated method stub
    return null;
}

private Object handleResultSetReturn(ResultSet rs, MappedStatement ms,
Method method) {
    // TODO Auto-generated method stub
    return null;
}/<code>

5.2 pst.executeUpate()的返回结果处理

pst.executeUpate()的返回结果是int方法的返回值可以是什么？void、int、long 、 其他的不可以！

5.3 pst.executeQuery()的返回结果处理

pst.executeQuery()的返回结果是ResultSet方法的返回值可以是什么？

可以是void、单个值、集合。单个值可以是什么类型的值？任意值、（map)

<code>@Select("select count(1) from t_user where sex = #{sex}")
int query(String sex);

@Select("select id,name,sex,age,address from t_user where id = #{id}")
User queryUser(String id);

@Select("select id,name,sex,age,address from t_user where id = #{id}")
Map queryUser1(String id);/<code>

集合可以是什么类型？　　List、Set、数组、Vector

<code>@Select("select id,name,sex,age,address from t_user where sex = #{sex}
order by #{orderColumn}")
List<user> query(String sex, String orderColumn);

@Select("select id,name,sex,age,address from t_user where sex = #{sex}
order by #{orderColumn}")
List/<user>/<code>

集合的元素可以是什么类型的？

任意类型的，集合只是单个值多做几遍。结果集中的列如何与结果、结果的属性对应？

根据结果集列名与属性名对应如果属性名与列名不一样呢？

则需用户显式说明映射规则。需要考虑JDBCType --- JavaType的处理吗？

无论结果是什么类型的，在这里我们都是要完成一件事：从查询结果中获得数据返回，只是返回类型不同，有不同的获取数据的方式。

请思考：如何让下面这个方法的代码的写好后不再改变？

<code>private Object handleResultSetReturn(ResultSet rs, MappedStatement ms, Object[] args) {
    // TODO Auto-generated method stub
    return null;
}/<code>

我需要在此做个抽象，应用策略模式，不同的处理实现这个抽象接口。

那么在handleResultSetReturn()方法中我们从哪得到ResultHandler呢？

从MappedStatement 中获取，每个语句对象（查询类型的）中都持有它对应的结果处理器。

在解析准备MappedStatement对象时根据方法的返回值类型选定对应的ResultHandler。

在handleResultSetReturn方法中只需调用ms中的ResultHandler：

5.3.1 方法返回单个值.

<code>@Select("select count(1) from t_user where sex = #{sex}")
int query(String sex);

@Select("select id,name,sex,age,address from t_user where id = #{id}")
User queryUser(String id);

@Select("select id,name,sex,age,address from t_user where id = #{id}")
Map queryUser1(String id);/<code>

1、基本数据类型、String 如何处理？

针对这种情况，提供对应的ResultHandler实现：

SimpleTypeResultHandler中需要定义什么属性？handle方法中的逻辑该是怎样的？

<code>public Object handle(ResultSet rs, Object[] args) throws Throwable {
    //从rs中取对应值
    return rs.getXXX(OOO);
}/<code>

问题1：该调用rs的哪个get方法？得根据返回值来，返回值类型从哪来？

从SimpleTypeResultHandler中取，在创建MappedStatement时，根据反射获得的返回值类型给入到SimpleTypeResultHandler中。

SimpleTypeResultHandler的handle方法中的代码逻辑如下：

<code>private Object  handle(ResultSet rs, Object[] args) throws Throwable {
    Class> returnType = method.getReturnType();
    if (returnType == short.class || returnType == Short.class) 
    {
        return rs.getShort(xxx);
    } 
    else if (returnType == int.class || returnType == Integer.class)
    {
        return rs.getInt(xxx);
    } 
    else if (returnType == long.class || returnType == Long.class) 
    {
        return rs.getLong(xxx);
    }
    ...
    return null;/<code>

问题：结果集中应不应该有多列？两种方案：

1、该返回值情况下不允许结果集多列。2、不限制，用户指定列名。

问题3：这么多if else 合适吗？

不合适，咋办？策略模式该定义怎样的策略？这是要做什么事情？

从结果集中获取值，跟pst.setXXX一样。可不可以在TypeHandler中加方法？

<code>public interface TypeHandler {
    Type getType();
    
    JDBCType getJDBCType();
    
    void setParameter(PreparedStatement pst, int index, Object paramValue) throws SQLException;
    
    T getResult(ResultSet rs, String columnName) throws SQLException;
    
    T getResult(ResultSet rs, int columnIndex) throws SQLException;
}/<code>

一样的，在启动解析阶段完成结果的TypeHandler选定。

根据返回值类型，从TypeHandlerRegistry中取，要取，还得有JDBCType，用户可以指定，也可不指定，不指定则使用默认的该类型的TypeHandler。

默认TypeHandler如何注册，修改registerTypeHandler方法的定义：

<code>registerTypeHandler(TypeHandler th，boolean defalut){
    Map<jdbctype> cmap = typeHandlerMap.get(th.getType);
    
    if(cmap == null)
    {
        cmap = new HashMap<jdbctype>();
        typeHandlerMap.put(th.getType,cmap);
    }
    camp.put(th.getJDBCType(),th);
    
    if(default)
    {
        cmap.put(DefaultJDBCType.class/null,th);
    }
}/<jdbctype>/<jdbctype>/<code>

很好，那就可以在SimpleTypeResultHandler中持有对应的TypeHandler。

不需要，在TypeHandler中有了。

SimpleTypeResultHandler 的handle方法代码就简单了：

<code>public Object handle(ResultSet rs, Object[] args) throws Throwable {
    if (StringUtils.isNotEmpty(columnName)) {
        return typeHandler.getResult(rs, columnName);
    } 
    else {
        return typeHandler.getResult(rs, columnIndex);
    }
}/<code>

2 对象类型返回结果的处理

<code>@Select("select id,name,sex,age,address from t_user where id = #{id}")
User queryUser(String id);/<code>

分析：1、要完成的事情是什么？创建对象从结果集中取数据给到对象

问题：

1、如何创建对象？

反射调用构造方法。构造方法有多种情况：

1 未显式定义构造方法

<code>public class User {
    private String id;
    private String name;
    private String sex;
    ...
    public String getId() {
    return id;
    }
    public void setId(String id) {
    this.id = id;
    }
    ...
}/<code>

这种情况不需要考虑什么，直接创建对象！

2 显式定义了一个构造方法

<code>public class User {
    private String id;
    private String name;
    private String sex;
    ...
    
    public User(String id, String name, String sex) {
        super();
        this.id = id;
        this.name = name;
        this.sex = sex;
    }
    
    public String getId() {
        return id;
    }
    
    public void setId(String id) {
        this.id = id;
    }
    ...
}/<code>

此种情况下，要创建对象，则需要对应的构造参数值。

问题1：构造参数值从哪来？ResultSet

问题2：怎么知道该从ResultSet中取哪个列的值，取什么类型的值？

得定义构造参数与ResultSet中列的对应规则，下面的规则是否可以？

1、优先采用指定列名的方式：用参数名称当列名、或用户为参数指定列名（参数名与列名不一致时、取不到参数名时）；

2、如不能取得参数名，则按参数顺序来取对应顺序的列。

问题3：用户如何来指定列名？

注解、xml配置

<code>public User(@Arg(column="id")String id, @Arg(column="xname")String
name, @Arg(column="sex")String sex) {
    super();
    this.id = id;
    this.name = name;
    this.sex = sex;
}/<code>

<code>@Documented
@Retention(RUNTIME)
@Target(PARAMETER)
public @interface Arg {
    String name() default "";
 

    String column() default "";

    Class> javaType() default void.class;

    JdbcType jdbcType() default JdbcType.UNDEFINED;

    Class extends TypeHandler> typeHandler() default
    UndefinedTypeHandler.class;
}/<code>

<code><resultmap>
    <constructor>
        
    /<constructor>
/<resultmap>/<code>

mybatis-mapper.dtd 中增加如下定义.

<code>
id CDATA #REQUIRED
type CDATA #REQUIRED
>




javaType CDATA #IMPLIED
column CDATA #IMPLIED
jdbcType CDATA #IMPLIED
typeHandler CDATA #IMPLIED
name CDATA #IMPLIED
>/<code>

问题4：这些映射信息得到后如何表示、存储？定义一个结果映射实体：ResultMap

注意，在创建ResultMap时，当用户没有指定TypeHandler或是UndefinedTypeHandler时，要根据type、jdbcType取对应的typeHandler，没有则为null;

问题5、ResultMap 元素怎么表示？ResultMap类定义本身就是表示一种java类型与JDBCType类型的映射，基本数据类型与复合类型（类）都是java类型。

扩充一下ResultMap即可：

注意：这里有个使用规则需要注意一下：

如果ResultMap中有TypeHandler，则该结果直接通过调用TypeHandler来获得。

没有TypeHandler时则看有constructorResultMaps没，有则根据此取结果集中的值来调用对应的构造方法创建对象。

3 定义了多个构造方法，怎么办？

用户指定构造方法，没有指定时则用默认构造方法（没有则报错）。用户怎么指定：注解 ：

<code>@MapConstructor
public User(@Arg("id")String id, @Arg("xname")String name,
@Arg("sex")String sex) { 

    super();
    this.id = id;
    this.name = name;
    this.sex = sex;
}/<code>

<code>/**
* 标识选用的构造方法
*/
@Documented
@Retention(RUNTIME)
@Target(CONSTRUCTOR)
public @interface MapConstructor {

}/<code>

xml：

根据constructor元素中 arg元素的数量、javaType来确定构造函数。

注意arg有顺序规则、必须指定构造方法的全部参数。

2、该给对象哪些属性值？

创建出对象后，可以从结果集中取值来填充对象的属性。

问题1：该给哪些属性赋值？可以有两种规则：

1、用户指定要给哪些属性赋值。2、自动映射赋值：取列的值赋给同名的属性。

两者可以一起使用。那么这里就涉及两个事情：

1、用户如何指定？注解方式： 我们给定义一个注解 @Result

xml方式：

<code><resultmap>
    <constructor>
        
        
        
    /<constructor>
    
    <result>
/<resultmap>/<code>

mybatis-mapper.dtd

问题：这些信息如何表示、存储？

2、是否自动映射如何指定？增加一个属性即可：

autoMapping="true"

<code>
id CDATA #REQUIRED
type CDATA #REQUIRED
autoMapping (true|false) #IMPLIED
>/<code>

注解方式：

<code>/**
标识类对象要进行自动映射
*/
@Documented
@Retention(RUNTIME)
@Target({ TYPE, FIELD })
public @interface AutoMapping {

}/<code>

<code>@AutoMapping
public class User {
    @Result
    private String id;
    
    @Result(column="xname")
    private String name;
    ...
}/<code>

为方便统一开启自动映射，我们可以在Configuration中设计一个全局配置参数，具体的可以覆盖全局的。

在哪可配置它？

在mybatis-config.xml中增加一个配置项即可。

3、对象中包含对象该如何映射及处理

对象中包对象是个问题，先把问题搞清楚，看下面的语句示例：

<code>
<select>
        select
            B.id as blog_id, 

            B.title as blog_title,
            B.author_id as blog_author_id,
            A.id as author_id,
            A.username as author_username,
            A.password as author_password,
            A.email as author_email,
            A.bio as author_bio,
            A.favourite_section as author_favourite_section,
            P.id as post_id,
            P.blog_id as post_blog_id,
            P.author_id as post_author_id,
            P.created_on as post_created_on,
            P.section as post_section,
            P.subject as post_subject,
            P.draft as draft,
            P.body as post_body
        from Blog B
            left outer join Author A on B.author_id = A.id
            left outer join Post P on B.id = P.blog_id
        where B.id = #{id}
/<select>/<code>

再看类.

这就是对象中包含对象，要从查询结果中得到Blog，Blog的Author posts数据。

这就是ORM中的关系映射问题。

结果的映射是简单的，因为就是指定里面的属性取哪个列的值。

<code>public class Blog {
    @Result(column="blog_id")
    private String id;
    
    @Result(column="blog_title")
    private String title;
    
    @Result
    private Author author;
    
    @Result
    private List<post> posts;
    ....
} 



public class Author {
    @Result(column="author_id")
    private String id;
    
    @Result(column="author_username")
    private String username;
    ...
}

public class Post {
    @Result(column="post_id")
    private String id;
    
    @Result(column="post_subject")
    private String subject;
    ...
}/<post>/<code>

我们的ResultMap类也是支持的：

但是从结果集中取值来填装对象则是复杂的！请先看查询的结果示例：

<code>while(rs.next()){

}/<code>

复杂点：不是一行一个Blog对象，处理行时要判断该行的blog是否已取过了。

问题核心点在哪？当我操作一行，如何判断该行的Blog已经取过没？这就要求要知道区分Blog的唯一标识、区分Author的唯一标识。

怎么知道？用户得告诉我们他们的id属性是哪个，对应的列是哪个。

让用户怎么来指定id属性呢？注解方式：在@Arg 、@Rersult注解中增加id指定项。

<code>@Documented
@Retention(RUNTIME)
@Target(PARAMETER)
public @interface Arg {
    boolean id() default false;
    
    String name() default "";
    
    String column() default "";
    
    Class> javaType() default void.class;
    
    JdbcType jdbcType() default JdbcType.UNDEFINED;
    
    Class extends TypeHandler> typeHandler() default
    UndefinedTypeHandler.class;
}/<code>

<code>@Documented
@Retention(RUNTIME)
@Target({ TYPE, FIELD })
public @interface Result {
    boolean id() default false;
    
    String column() default "";
    
    Class> javaType() default void.class;
    
    JdbcType jdbcType() default JdbcType.UNDEFINED;
    
    Class extends TypeHandler> typeHandler() default
    UndefinedTypeHandler.class;
}/<code>

xml方式增加：增加argId、id元素

<code><resultmap>
    <constructor>
        <idarg>
    /<constructor>
    ....
/<resultmap> 



<resultmap>
    
    <result>
    <result>
/<resultmap>/<code>

在ResultMap中增加ID信息：

问题：要体现出一对一，一对多关系吗？我们会在哪里需要知道这个关系？

看一个mybatis中的复杂xml ResultMap示例：

<code>
<resultmap>
    <constructor>
    <idarg>
    /<constructor>
    
    <result>
    
    <association>
        
        <result>
        <result>
        <result>
        <result>
        <result>
    /<association>
    
    <collection>
        
        <result>
        <association>
        <collection>
             

        /<collection>
    /<collection>
/<resultmap>/<code>

知道唯一标识了，要判断前面是否取过了，则还需要有个上下文持有取到的对象，并能根据id列值取到对应的对象。

为对象类型返回结果定义一个ResultHandler实现ClassTypeResultHandler：

3 Map

<code>@Select("select id,name,sex,age,address from t_user where id = #{id}")
Map queryUser1(String id);/<code>

不能在解析阶段获得ResultMap当执行完第一次查询就可以确定下来.

我们从结果集中能得到的是JDBCType.

问题：

1、key 用什么？用列名

2、取成什么java类型的值？JDBCType中根据整型类型值获得对应的JDBCType.

TypeHandler ---> javaType在TypehandlerRegistry中定义一个JDBCType类型对应的默认的TypeHandler集合，来完成取java值放入到Map中

第一次处理结果时，要把这个ResultMaps填充好，后需查询结果的处理就是直接使用resultMaps

5.3.2 方法返回集合

返回集合就是单个的重复.

<code>if(method.getReturnType() == List.class) {
    Type genericType = method.getGenericReturnType();
    if(genericType == null) {
        // 当集合中放Map
    }
    else if (genericType instanceof ParameterizedType) {
        ParameterizedType t = (ParameterizedType) genericType;
        Class> elementType = (Class>)t.getActualTypeArguments()[0];
    }
}/<code>

以上就是Mybatis源码之手写Mybatis，希望可以帮助到你，下面展示了部分资料，也希望也能帮助到大家，对编程感兴趣想进阶的朋友，如果能帮到你请点赞、点赞、点赞：

整理的 pdf 文档：

源码分析专题部分课程：

获取方式

点赞，收藏并转发文章后点击小编头像或昵称，关注后私信回复：【11】 即可

举手之劳，非常感谢！！！

来源：https://www.cnblogs.com/leeSmall/p/10426629.html

閱讀更多 java架構師小旭 的文章

關鍵字: 手写 需求分析 源码