框架源码系列十二：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编程的代码示例

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;
        }
    }
}

用JdbcTemplate的代码示例：

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;
            }
        });
    }
}

参数设置代码、结果集处理代码、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

xml方式定义SQL语句定义方式 ：设计增删改查的元素：

<!ELEMENT insert(#PCDATA) >
<!ELEMENT update(#PCDATA) >
<!ELEMENT delete(#PCDATA) >
<!ELEMENT select (#PCDATA) > 

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

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

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

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

 1.2 SQL语句与接口方法对应

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

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

<insert id="com.study.leesmall.sample.UserDao.addUser">
         insert into t_user(id,name,sex,age) values(?,?,?,?)
</insert>

一个Dao接口中可能会定义很多个数据访问方法，id这么写很长，能不能便捷一点？
这是在做SQL与接口方法的映射，我们来加一个mapper元素，它可包含多个insert、update、delete、select元素，相当于分组，一个接口中定义的分到一组。
在mapper中定义一个属性namespace，指定里面元素的名称空间，namespace的值对应接口类名，里面元素的id对应方法名。

mybatis-mapper.dtd

<!ELEMENT mapper (insert* | update* | delete* | select*)+ >
<!ATTLIST mapper namespace CDATA #IMPLIED >
<!ELEMENT insert(#PCDATA) >
<!ELEMENT update(#PCDATA) >
<!ELEMENT delete(#PCDATA) >
<!ELEMENT select (#PCDATA) >

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

<mapper namespace="com.study.leesmall.sample.userDao">
    <insert id="addUser">
        insert into t_user(id,name,sex,age) values(?,?,?,?)
    </insert>
</mapper>

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:///

<configuration>
    <mappers>
        <mapper resource="com/leesmall/UserMapper.xml"/>
        <mapper url="file:///var/mappers/CourseMapper.xml"/>
    <mappers>
</configuration>

 定义 mybatis-config.dtd

<!ELEMENT configuration (mappers?)+ >
<!ELEMENT mappers (mapper*)>
<!ELEMENT mapper EMPTY>
<!ATTLIST mapper
resource CDATA #IMPLIED
url CDATA #IMPLIED
> 

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

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

 

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

 

7) 谁来使用MapperAnnotationBuilder？

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

 

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

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

<configuration>
    <mappers>
        <mapper resource="com/leesmall/UserMapper.xml"/>
        <mapper url="file:///var/mappers/CourseMapper.xml"/>
    <mappers>
</configuration>

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

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

<configuration>
    <mappers>
        <mapper resource="com/leesmall/UserMapper.xml"/>
        <mapper url="file:///var/mappers/CourseMapper.xml"/>
        <mapper class="com.study.leesmall.dao.UserDao" />
    <mappers>
</configuration>

 mybatis-config.dtd

<!ELEMENT configuration (mappers?)+ >
<!ELEMENT mappers (mapper*)>
<!ELEMENT mapper EMPTY>
<!ATTLIST mapper
resource CDATA #IMPLIED
url CDATA #IMPLIED
class CDATA #IMPLIED
>

问题：
1、这样一个一个类来指定，好繁琐？能不能指定一个包名，包含包下所有接口、子孙包下的接口类？
2、包含包下所有的接口，好像不是很灵活，能不能让用户指定包下所有某类型的接口？
如是什么类型的类，或带有某注解的接口。
好的，这很容易，在mappers元素中增加一个package元素，pacakge元素定义三个属性

mybatis-config.dtd

<!ELEMENT configuration (mappers?)+ >

<!ELEMENT mappers (mapper*,package*)>

<!ELEMENT mapper EMPTY>
<!ATTLIST mapper
resource CDATA #IMPLIED
url CDATA #IMPLIED
class CDATA #IMPLIED
>

<!ELEMENT package EMPTY>
<!ATTLIST package
name CDATA #IMPLIED
type CDATA #IMPLIED
annotation CDATA #IMPLIED
>

<configuration>
    <mappers>
        <mapper resource="com/leesmall/UserMapper.xml"/>
        <mapper url="file:///var/mappers/CourseMapper.xml"/>
        <mapper class="com.study.leesmall.dao.UserDao" />
        <package name="com.study.leesmall.mapper" />
        <package name="com.study.leesmall.mapper" type="com.study.leesmall.MapperInterface"/>
        <package name="com.study.leesmall.mapper"
                      annotation="com.study.leesmall.mybtis.annotation.Mapper"/>
        <package name="com.study.leesmall.mapper" type="com.study.leesmall.MapperInterface"
                      annotation="com.study.leesmall.mybtis.annotation.Mapper"/>
    <mappers>
</configuration>

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

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

 

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

2 需求2

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

2.1 语句参数指定

 看下面的Mapper示例

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

User对象的属性如何与 values(?)对应？
靠解析 t_user(id,name,sex,age) 可行吗？
难度太大！
万一User的name叫xname呢！
既然靠我们来解析不行，那就请用户指明吧。用户如何来指明呢？

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

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

 万一是这种情况呢？

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

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

 

@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);

 万一是这种情况呢？

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

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

 

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

@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);

一样也可以使用@Param

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

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

对应Map中的key

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

@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);

@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);

 再来看下下面的场景：

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

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

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

那怎么让用户指定呢？

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

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

 2.2 SQL中参数映射解析

 问题：

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

解析出真正的SQL语句

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

    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();
        }
    }

 怎么解析？

@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);

 方式有：

正则表达式
antlr

怎么表示？

 问号的index、值来源

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

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

3. 需求4

1）用户只需定义持久层接口（dao接口）、接口方法对应的SQL语句。
2）用户需指明接口方法的参数与语句参数的对应关系。
3）用户需指明查询结果集与对象属性的映射关系。
4）框架完成接口对象的生成，JDBC执行过程。

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

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

2、谁来执行SQL? Configuration ?

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

 

该为它定义什么方法呢？

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

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

 

使用示例：

UserDao userDao = sqlSession.getMapper(UserDao.class);
userDao.addUser(user);

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

 

它该持有什么属性吗？
用户给入一个接口类，DefaultSqlSession中就为它生成一个对象？
万一给入的不是一个Mapper接口呢？
也为其生成一个对象就不合理了？
那怎么判断给入的接口类是否是一个Mapper接口呢？
那就只有在配置阶段扫描、解析Mapper接口时做个存储了。
存哪，用什么存？
这也是配置信息，还是存在Configuration 中，就用个Set来存吧。

 

DefaultSqlSession中需要持有Configuration

 

3.2 对象生成

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

 　　很简单，JDK动态代理

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

 写一版DefaultSqlSession的实现：

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> T getMapper(Class<T> 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;
    }
}

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

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

3.3 执行SQL的InvocationHandler

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

public interface InvocationHandler {
    /**
    @param proxy 生成的代理对象
    @param method 被调用的方法
    @param args
    @return Object 方法执行的返回值
    */
    public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable;
}

来实现我们的InvocationHandler： MapperProxy

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;
}
}

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

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;
    }
}

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

 

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

public Object invoke(Object proxy, Method method, Object[] args)

method参数能得到方法名，但得到的类名不是Mapper接口类名。
那就直接让MapperProxy持有其增强的Mapper接口类吧！简单！

 

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

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

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

@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);

Parameter[] params = method.getParameters();

public Object invoke(Object proxy, Method method, Object[] args)

 

说明： 这里是要确定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来存储。
参数索引号，仅仅是个索引号吗？

@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);

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

 

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

 

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

 

把MapperProxy的invoke方法填填看：

@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;
}

4 JavaType、JdbcType转换

 1 认识它们

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

 

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

 

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

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(...)
}

我们来看一下这种情况：

 

看PreparedStatment的set方法：

 

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

#{user.id，jdbcType=TIME}

 

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

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

完成Object p 的pst.setXXX（）。

2 TypeHandler

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

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(...)
}

定义一些常用数据类型的TypeHandler.
先不急着去定义，我们来考虑一下下面的问题。
这个怎么使用它呢？
在MapperProxy.invoke()中？

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

 还需要JDBCType。

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

 

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

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

 

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

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

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

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

Map<Type,Map<JDBCType,TypeHandler>> typeHandlerMap;

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

 

 同时我们完善一下TypeHandler

 

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

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

<!ELEMENT configuration (mappers?, typeHandlers?)+ >

<!ELEMENT mappers (mapper*,package*)>

<!ELEMENT mapper EMPTY>
<!ATTLIST mapper
resource CDATA #IMPLIED
url CDATA #IMPLIED
class CDATA #IMPLIED
>

<!ELEMENT package EMPTY>
<!ATTLIST package
name CDATA #IMPLIED
type CDATA #IMPLIED
annotation CDATA #IMPLIED
>

<!ELEMENT typeHandlers (typeHandler*,package*)>

<!ELEMENT typeHandler EMPTY>
<!ATTLIST typeHandler
class CDATA #REQUIRED
>

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

 mybatis-config.xml

<configuration>
    <mappers>
        <mapper resource="com/leesmall/UserMapper.xml"/>
        <mapper url="file:///var/mappers/CourseMapper.xml"/>
        <mapper class="com.study.leesmall.dao.UserDao" />
        <package name="com.study.leesmall.mapper" />
    <mappers>
    <typeHandlers>
        <typeHandler class="com.study.leesmall.type.XoTypeHandler" />
        <package name="com.study.leesmall.type" />
    </typeHandlers>
</configuration>

 解析注册的工作就交给XMLConfigBuilder

 

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

 

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

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

 

用户在SQL语句参数中必须要指定JDBCType吗？
　　常用的数据类型可以不指定，我们可以提供默认的TypeHandler。

public class StringTypeHandler implements TypeHandler {
    @Override
    public Type getType() {
        return String.class;
    }
    @Override
    public JDBCType getJDBCType() {
        return JDBCType.VARCHAR;
    }
    @Override
    public void setParameter(PreparedStatement pst, int index, Object
    paramValue) throws SQLException {
        pst.setString(index, (String) paramValue);
    }
}

用户在SQL中参数定义没有指定JDBCType，则我们可以直接使用我们默认的TypeHandler
如 #{user.name}
我们判断它的参数类型为String，就可以指定它的TypeHandler为 StringTypeHandler。可能它的数据库类型不为VACHAR，而是一个CHAR定长字符，没关系！因为pst.setString对VARCHAR、CHAR是通用的。

5 执行结果处理

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

pst.executeUpate()的返回结果是int，影响的行数。
pst.executeQuery()的返回结果是ResultSet。
在得到SQL语句执行的结果后，要转为方法的返回结果进行返回。这就是执行结果处理要干的事
根据方法的返回值类型来进行相应的处理。
这里我们根据SQL语句执行结果的不同，分开处理：

@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;
}

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

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

private Object handleUpdateReturn(int rows, MappedStatement ms, Method
method) {
    Class<?> returnType = method.getReturnType();
    if (returnType == Void.TYPE) {
        return null;
    } 
    else if (returnType == int.class || returnType == Integer.class)
    {
        return rows;
    } 
    else if (returnType == long.class || returnType == Long.class) {
        return (long) rows;
    }
    throw new IllegalArgumentException("update类方法的返回值只能是：void/int/Integer/long/Long");
}

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

pst.executeQuery()的返回结果是ResultSet
方法的返回值可以是什么？
　　可以是void、单个值、集合。
单个值可以是什么类型的值？
　　任意值、（map)

@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);

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

@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<Map> query1(String sex, String orderColumn);

集合的元素可以是什么类型的？
　　任意类型的，集合只是单个值多做几遍。
结果集中的列如何与结果、结果的属性对应？
　　根据结果集列名与属性名对应
如果属性名与列名不一样呢？
　　则需用户显式说明映射规则。
需要考虑JDBCType --- JavaType的处理吗？

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

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

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

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

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

从MappedStatement 中获取，每个语句对象（查询类型的）中都持有它对应的结果处理器。
在解析准备MappedStatement对象时根据方法的返回值类型选定对应的ResultHandler。

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

private Object handleResultSetReturn(ResultSet rs, MappedStatement ms, Object[] args) throws Throwable {
    return ms.getResultHandler().handle(rs, args);
}

5.3.1 方法返回单个值

@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);

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

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

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

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

问题1：该调用rs的哪个get方法？
得根据返回值来，返回值类型从哪来？
从SimpleTypeResultHandler中取，在创建MappedStatement时，根据反射获得的返回值类型给入到SimpleTypeResultHandler中。

 

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

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;

问题2：该取结果集中的哪一列？
如果结果集中只有一列：那就取第1列。
如果结果集中是有多列呢？

问题：结果集中应不应该有多列？
两种方案：
　　1、该返回值情况下不允许结果集多列。
　　2、不限制，用户指定列名。

 

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

　　　　不合适，咋办？策略模式
　　       
　　　　该定义怎样的策略？
这是要做什么事情？
　　从结果集中获取值，跟pst.setXXX一样。
　　可不可以在TypeHandler中加方法？

public interface TypeHandler<T> {
    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;
}

public class StringTypeHandler implements TypeHandler<String> {

    @Override
    public Type getType() {
    return String.class;
    }
    
    @Override
    public JDBCType getJDBCType() {
    return JDBCType.VARCHAR;
    }
    
    @Override
    public void setParameter(PreparedStatement pst, int index, Object
    paramValue) throws SQLException {
        pst.setString(index, (String) paramValue);
    }
    
    @Override
    public String getResult(ResultSet rs, String columnName) throws
    SQLException {
        return rs.getString(columnName);
    }
    
    @Override
    public String getResult(ResultSet rs, int columnIndex) throws
    SQLException {
        return rs.getString(columnIndex);
    }
}

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

 

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

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

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

很好，那就可以在SimpleTypeResultHandler中持有对应的TypeHandler。
问：在SimpleTypeResultHandler中还有必要持有Class<?> returnType吗？
　　不需要，在TypeHandler中有了。

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

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

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

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

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

问题：

1、如何创建对象？

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

1 未显式定义构造方法

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;
    }
    ...
}

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

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

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;
    }
    ...
}

此种情况下，要创建对象，则需要对应的构造参数值。
问题1：构造参数值从哪来？
　　ResultSet

问题2：怎么知道该从ResultSet中取哪个列的值，取什么类型的值？
得定义构造参数与ResultSet中列的对应规则，下面的规则是否可以？
1、优先采用指定列名的方式：用参数名称当列名、或用户为参数指定列名（参数名与列名不
一致时、取不到参数名时）；
2、如不能取得参数名，则按参数顺序来取对应顺序的列。

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

注解、xml配置

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;
}

@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;
}

<resultMap id="User" type="com.study.leesmall.mybatis.sample.model.User">
    <constructor>
        <arg name="" column="" JdbcType="" javaType="" typeHandler=""/>
    </constructor>
</resultMap>

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

<!ELEMENT resultMap (constructor?)>
<!ATTLIST resultMap
id CDATA #REQUIRED
type CDATA #REQUIRED
>

<!ELEMENT constructor (arg*)>

<!ELEMENT arg EMPTY>
<!ATTLIST arg
javaType CDATA #IMPLIED
column CDATA #IMPLIED
jdbcType CDATA #IMPLIED
typeHandler CDATA #IMPLIED
name CDATA #IMPLIED
>

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

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

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

扩充一下ResultMap即可：

 

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

 如果ResultMap中有TypeHandler，则该结果直接通过调用TypeHandler来获得。没有TypeHandler时则看有constructorResultMaps没，有则根据此取结果集中的值来调用对应的构造方法创建对象。

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

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 User(String id, String name, String sex, int age) {
        super();
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    
    public String getId() {
        return id;
    }
    
    public void setId(String id) {
        this.id = id;
    }
    ...
}

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

@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;
}

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

}

xml：根据constructor元素中 arg元素的数量、javaType来确定构造函数。注意arg有顺序规则、必须指定构造方法的全部参数。

<resultMap id="User" type="com.study.leesmall.mybatis.sample.model.User">
    <constructor>
        <arg column="id" javaType="String"/>
        <arg column="name" javaType="String"/>
        <arg column="sex" javaType="String"/>
    </constructor>
</resultMap>

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

创建出对象后，可以从结果集中取值来填充对象的属性。
问题1：该给哪些属性赋值？
可以有两种规则：
1、用户指定要给哪些属性赋值。
2、自动映射赋值：取列的值赋给同名的属性。

两者可以一起使用。
那么这里就涉及两个事情：
1、用户如何指定？
注解方式： 我们给定义一个注解 @Result

public class User {
    @Result
    private String id;
    @Result(column="xname")
    private String name;
    ...
}

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

xml方式：

<resultMap id="User" type="com.study.leesmall.mybatis.sample.model.User">
    <constructor>
        <arg column="id" javaType="String"/>
        <arg column="name" javaType="String"/>
        <arg column="sex" javaType="String"/>
    </constructor>
    
    <result property="age" column="age" />
</resultMap>

mybatis-mapper.dtd

<!ELEMENT resultMap (constructor?,result*)>
<!ATTLIST resultMap
id CDATA #REQUIRED
type CDATA #REQUIRED
>

<!ELEMENT constructor (arg*)>

<!ELEMENT arg EMPTY>
<!ATTLIST arg
javaType CDATA #IMPLIED
column CDATA #IMPLIED
jdbcType CDATA #IMPLIED
typeHandler CDATA #IMPLIED
name CDATA #IMPLIED
>

<!ELEMENT result EMPTY>
<!ATTLIST result
property CDATA #IMPLIED
javaType CDATA #IMPLIED
column CDATA #IMPLIED
jdbcType CDATA #IMPLIED
typeHandler CDATA #IMPLIED
>

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

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

autoMapping="true"

<resultMap id="User" type="com.study.leesmall.mybatis.sample.model.User" autoMapping="true">
    <result property="age" column="age" />
</resultMap>

<!ELEMENT resultMap (constructor?,result*)>
<!ATTLIST resultMap
id CDATA #REQUIRED
type CDATA #REQUIRED
autoMapping (true|false) #IMPLIED
>

注解方式：

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

}

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

 

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

 

在哪可配置它？

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

<configuration>
    <settings>
        <setting name="autoMappingBehavior" value="PARTIAL"/>
    </settings>
</configuration>

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

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

<!-- Very Complex Statement -->
<select id="selectBlogDetails" resultMap="detailedBlogResultMap">
        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>

 再看类

public class Blog {
    private String id;
    
    private String title;
    
    private Author author;
    
    private List<Post> posts;
    ....
}


public class Author {
    private String id;
    
    private String username;
    ...
}


public class Post {
    private String id;
    
    private String subject;
    ...
}

这就是对象中包含对象，要从查询结果中得到Blog，Blog的Author posts数据。
这就是ORM中的关系映射问题。
结果的映射是简单的，因为就是指定里面的属性取哪个列的值。

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;
    ...
}

 我们的ResultMap类也是支持的：

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

 

while(rs.next()){

}

复杂点：不是一行一个Blog对象，处理行时要判断该行的blog是否已取过了。
问题核心点在哪？
当我操作一行，如何判断该行的Blog已经取过没？
这就要求要知道区分Blog的唯一标识、区分Author的唯一标识。怎么知道？
用户得告诉我们他们的id属性是哪个，对应的列是哪个。

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

@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;
}

@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;
}

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

<resultMap id="detailedBlogResultMap" type="Blog">
    <constructor>
        <idArg column="blog_id" javaType="int"/>
    </constructor>
    ....
</resultMap>


<resultMap id="AuthorMap" type="Author">
    <id property="id" column="author_id"/>
    <result property="username" column="author_username"/>
    <result property="password" column="author_password"/>
</resultMap>

 在ResultMap中增加ID信息

 

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

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

<!-- 超复杂的 Result Map -->
<resultMap id="detailedBlogResultMap" type="Blog">
    <constructor>
    <idArg column="blog_id" javaType="int"/>
    </constructor>
    
    <result property="title" column="blog_title"/>
    
    <association property="author" javaType="Author">
        <id property="id" column="author_id"/>
        <result property="username" column="author_username"/>
        <result property="password" column="author_password"/>
        <result property="email" column="author_email"/>
        <result property="bio" column="author_bio"/>
        <result property="favouriteSection" column="author_favourite_section"/>
    </association>
    
    <collection property="posts" ofType="Post">
        <id property="id" column="post_id"/>
        <result property="subject" column="post_subject"/>
        <association property="author" javaType="Author"/>
        <collection property="comments" ofType="Comment">
            <id property="id" column="comment_id"/>
        </collection>
    </collection>
</resultMap>

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

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

3 Map

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

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

 

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

 

问题：

1、key 用什么？
　　用列名
2、取成什么java类型的值？
　　JDBCType中根据整型类型值获得对应的JDBCType

/**
* Returns the {@code JDBCType} that corresponds to the specified
* {@code Types} value
* @param type {@code Types} value
* @return The {@code JDBCType} constant
* @throws IllegalArgumentException if this enum type has no
constant with
* the specified {@code Types} value
* @see Types
*/
public static JDBCType valueOf(int type) {
    for( JDBCType sqlType : JDBCType.class.getEnumConstants()) {
        if(type == sqlType.type)
        return sqlType;
    }
    
    throw new IllegalArgumentException("Type:" + type + " is not a
    valid "+ "Types.java value.");
}

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

 

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

 5.3.2 方法返回集合

返回集合就是单个的重复

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];
    }
}

----------