自己实现 MyBatis 底层机制--＞（吃透MyBatis ）

<?xml version="1.0" encoding="UTF-8" ?>
<database>
    <!--配置连接数据库的信息-->
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/hong_mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
    <property name="username" value="root"/>
    <property name="password" value="hong"/>
</database>

2.2HspConfiguration.java读取xml文件, 建立连接

public class HongConfiguration {

    //属性-类的加载器
    private static ClassLoader loader =
            ClassLoader.getSystemClassLoader();

    //读取xml文件信息，并处理
    public Connection build(String resource) {

        Connection connection = null;

        try {
            //加载配置hong_mybatis.xml 获取到对应的InputStream
            InputStream stream =
                    loader.getResourceAsStream(resource);
            //解析hong_mybatis.xml  => dom4j
            SAXReader reader = new SAXReader();
            Document document = reader.read(stream);
            //获取到hong_mybatis.xml 的根元素 <database>
            Element root = document.getRootElement();
            System.out.println("root=" + root);
            //解析root元素，返回Connection => 准备单独的编写一个方法
            connection = evalDataSource(root);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }

    //方法会解析hong_config.xml 信息,并返回Connection
    //eval: 评估/解析
    private Connection evalDataSource(Element node) {
        if (!"database".equals(node.getName())) {
            throw new RuntimeException("root 节点应该是<database>");
        }
        //连接DB的必要参数
        String driverClassName = null;
        String url = null;
        String username = null;
        String password = null;

        //遍历node下的子节点，获取属性值
        for (Object item : node.elements("property")) {
            Element i = (Element) item;//i 就是 对应property节点
            String name = i.attributeValue("name");
            String value = i.attributeValue("value");

            //判断是否得到name 和 value
            if (name == null || value == null) {
                throw new RuntimeException("property 节点没有设置name或者value属性");
            }
            switch (name) {
                case "url":
                    url = value;
                    break;
                case "username":
                    username = value;
                    break;
                case "driverClassName":
                    driverClassName = value;
                    break;
                case "password":
                    password = value;
                    break;
                default:
                    throw new RuntimeException("属性名没有匹配到...");
            }
        }

        Connection connection = null;

        try {
            Class.forName(driverClassName);
            connection = DriverManager.getConnection(url,username,password);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return connection; //返回Connection
    }
}

该类现在的作用是读取xml中的数据并将其赋值给connection，并得到返回

2- 编写执行器，输入 SQL 语句，完成操作

1.说明：

通过实现执行器机制，对数据表操作

2.分析+代码实现

● 分析示意图

说明：我们把对数据库的操作，会封装到一套 Executor 机制中，程序具有更好的扩展性 ,

结构更加清晰 .

● 代码实现

2.1Monster.java Monster 和 monster表有映射关系


/**
 * @author 海绵hong
 * @version 1.0
 * Monster 和 monster表有映射关系
 *
 * 解读
 * 要导入lombok--jar包
 * @Getter 就会给所有属性 生成对应的getter
 * @Setter 就会给所有属性 生成对应的setter
 * @ToString 生成 toString...
 * @NoArgsConstructor 生成无参构造器
 * @AllArgsConstructor 生成要给全参构造器
 * @Data 注解---->一个注解包含javabean所需要getter和settingand参数等
 * 如何选择主要还是看自己需要
 */
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
@ToString
public class Monster {

    private Integer id;
    private Integer age;
    private String name;
    private String email;
    private Date birthday;
    private double salary;
    private Integer gender;

}

2.2Executor.java接口

public interface Executor {
    //泛型方法
    public <T> T query(String statement, Object parameter);
}

2.3HongExecutor-->JDBC方式的操作数据库


public class HongExecutor implements Executor {

    //属性
    private HongConfiguration hongConfiguration =
            new HongConfiguration();


    /**
     * 根据 sql 查找结果
     *
     * @param sql
     * @param parameter
     * @param <T>
     * @return
     */
    @Override
    public <T> T query(String sql, Object parameter) {
        //得到连接Connection
        Connection connection = getConnection();
        //查询返回的结果集
        ResultSet set = null;
        PreparedStatement pre = null;

        try {
            pre = connection.prepareStatement(sql);
            //设置参数, 如果参数多, 可以使用数组处理.
            pre.setString(1, parameter.toString());
            set = pre.executeQuery();
            //把set数据封装到对象-monster
            //说明: 这里做了简化处理
            //认为返回的结果就是一个monster记录
            //完善的写法是一套反射机制.-jdbc
            Monster monster = new Monster();

            //遍历结果集, 把数据封装到monster对象
            while (set.next()) {
                monster.setId(set.getInt("id"));
                monster.setName(set.getString("name"));
                monster.setEmail(set.getString("email"));
                monster.setAge(set.getInt("age"));
                monster.setGender(set.getInt("gender"));
                monster.setBirthday(set.getDate("birthday"));
                monster.setSalary(set.getDouble("salary"));
            }
            return (T) monster;

        } catch (Exception throwables) {
            throwables.printStackTrace();
        } finally {
            try {
                if (set != null) {
                    set.close();
                }
                if (pre != null) {
                    pre.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (Exception throwables) {
                throwables.printStackTrace();
            }
        }

        return null;
    }

    //编写方法,通过hongConfiguration对象，返回连接
    private Connection getConnection() {
        Connection connection =
                hongConfiguration.build("hong_mybatis.xml");
        return connection;
    }
}

3- 将 Sqlsession 封装到执行器-->搭建Configuration（连接）和Executor之间桥梁

1.分析+代码实现

● 分析示意图 , 先观察原生 MyBatis 的 SqlSession 接口和默认实现

● 代码实现

2.1.HongSqlSession.java


/**
 * @author 海绵hong
 * @version 1.0
 * HongSqlSession: 搭建Configuration（连接）和Executor之间桥梁
 * 这里有操作DB的方法-
 */
public class HongSqlSession {
    //属性
    //执行器
    private Executor executor = new HongExecutor();
    //配置
    private HongConfiguration hongConfiguration =
            new HongConfiguration();

    //编写方法SelectOne 返回一条记录-对象 [做了简化]
    //说明: 在原生的Mybatis中 statement 不是sql ，而是要执行的接口方法
    //这里是做简化
    public <T> T selectOne(String statement, Object parameter) {
        return executor.query(statement, parameter);
    }

    //SelectList - Update - Delete - Insert ..


    /**
     * 1. 返回mapper的动态代理对象
     * 2. 这里clazz 到时传入的是 MonsterMapper.class
     * 3. 返回的就是MonsterMapper接口代理对象
     * 4. 当执行接口方法时(通过代理对象调用), 根据动态代理机制会执行到HongMapperProxy-invoke
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> T getMapper(Class<T> clazz) {

        //返回动态代理对象
        return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz},
                new HongMapperProxy(hongConfiguration,this,clazz));
    }
}

4- 开发 Mapper 接口和 Mapper.xml

● 分析【示意图】

1.1MonsterMapper接口

/**
 * @author 海绵hong
 * @version 1.0
 * MonsterMapper: 声明对db的crud方法
 */
public interface MonsterMapper {

    //查询方法
    public Monster getMonsterById(Integer id);


}

1.2MonsterMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<mapper namespace="com.hong.mapper.MonsterMapper">
    <!--实现配置接口方法getMonsterById-->
    <select id="getMonsterById" resultType="com.hong.entity.Monster">
        select * from monster where id = ?
    </select>
</mapper>

5- 开发和 Mapper 接口相映射的 MapperBean

1.分析+代码实现

● 分析示意图

● 代码实现

1.1Function类

/**
 * @author 海绵hong
 * @version 1.0
 * Function: 记录对应的Mapper的方法信息
 */
public class Function {
    //属性
    private String sqlType; //sql类型，比如select,insert,update, delete
    private String funcName; //方法名
    private String sql;//执行的sql语句
    private Object resultType;//返回类型
    private String parameterType;//参数类型

    public String getSqlType() {
        return sqlType;
    }

    public void setSqlType(String sqlType) {
        this.sqlType = sqlType;
    }

    public String getFuncName() {
        return funcName;
    }

    public void setFuncName(String funcName) {
        this.funcName = funcName;
    }

    public String getSql() {
        return sql;
    }

    public void setSql(String sql) {
        this.sql = sql;
    }

    public Object getResultType() {
        return resultType;
    }

    public void setResultType(Object resultType) {
        this.resultType = resultType;
    }

    public String getParameterType() {
        return parameterType;
    }

    public void setParameterType(String parameterType) {
        this.parameterType = parameterType;
    }

    @Override
    public String toString() {
        return "Function{" +
                "sqlType='" + sqlType + '\'' +
                ", funcName='" + funcName + '\'' +
                ", sql='" + sql + '\'' +
                ", resultType=" + resultType +
                ", parameterType='" + parameterType + '\'' +
                '}';
    }
}

1.2MapperBean类


/**
 * @author 海绵hong
 * @version 1.0
 * MapperBean: 将Mapper信息，进行封装
 */
public class MapperBean {
    private String interfaceName;//接口名

    //接口下的所有方法-集合
    private List<Function> functions;

    public String getInterfaceName() {
        return interfaceName;
    }

    public void setInterfaceName(String interfaceName) {
        this.interfaceName = interfaceName;
    }

    public List<Function> getFunctions() {
        return functions;
    }

    public void setFunctions(List<Function> functions) {
        this.functions = functions;
    }

    @Override
    public String toString() {
        return "MapperBean{" +
                "interfaceName='" + interfaceName + '\'' +
                ", functions=" + functions +
                '}';
    }
}

6- 在 HongConfiguration, 读取 XxxMapper.xml，能够创建MappperBean 对象

1.运行结果示意

mapperBean--MapperBean{interfaceName='com.hong.mapper.MonsterMapper',

list=[Function{sqlType='select', funcName='getMonsterById', sql='select * from monster

where id=?', resultType=com.hong.mapper.MonsterMapper, parameterType='null'}]}

2.HongConfiguration.java

    //读取XxxMapper.xml，能够创建MapperBean对象
    //path 就是xml的路径+文件名  是从类的加载路径计算的
    //说明：如果XxxMapper.xml 文件是防在resources目录下，直接传入xml文件名即可

    public MapperBean readMapper(String path) {

        MapperBean mapperBean = new MapperBean();

        try {
            //获取到xml文件对应的InputStream
            InputStream stream = loader.getResourceAsStream(path);
            SAXReader reader = new SAXReader();
            //获取到xml文件对应的document-dom4j
            Document document = reader.read(stream);
            //得到xml文件的根元素/根节点
            /*
            <mapper namespace="com.hong.mapper.MonsterMapper">
                <!--实现配置接口方法getMonsterById-->
                <select id="getMonsterById" resultType="com.hong.entity.Monster">
                    select * from monster where id = ?
                </select>


            </mapper>
             */
            Element root = document.getRootElement();

            //获取到namespace
            String namespace = root.attributeValue("namespace").trim();
            //设置mapperBean的属性interfaceName
            mapperBean.setInterfaceName(namespace);
            //得到root的迭代器-可以遍历它的子节点/子元素-生成Function
            Iterator rootIterator = root.elementIterator();
            //保存接口下所有的方法信息
            List<Function> list = new ArrayList<>();
            //遍历它的子节点/子元素-生成Function
            while (rootIterator.hasNext()) {
                //取出一个子元素- dom4j Element
                /**
                 * <select id="getMonsterById" resultType="com.hong.entity.Monster">
                 *                     select * from monster where id = ?
                 *  </select>
                 */
                Element e = (Element) rootIterator.next();
                Function function = new Function();
                String sqlType = e.getName().trim();
                String funcName = e.attributeValue("id").trim();
                //resultType是返回类型的全路径-即全类名
                String resultType = e.attributeValue("resultType").trim();
                String sql = e.getText().trim();
                //开始封装
                function.setSql(sql);
                function.setFuncName(funcName);
                function.setSqlType(sqlType);
                //这里多说一句 function-private Object resultType; 是resultType实例
                //使用反射生成一个对象, setResultType

                Object newInstance = Class.forName(resultType).newInstance();
                function.setResultType(newInstance);

                //将封装好的function对象加入到 list
                list.add(function);

            }
            //while循环结束后, 将function的list设置
            mapperBean.setFunctions(list);

        } catch (Exception e) {
            e.printStackTrace();
        }

        return mapperBean;
    }

7- 实现动态代理 Mapper 的方法

1.分析+代码实现

● 分析示意图【看下示意图】

● 代码实现

1.1HongMapperProxy: 动态代理生成Mapper对象,调用HongExecutor方法


/**
 * @author 海绵hong
 * @version 1.0
 * HongMapperProxy: 动态代理生成Mapper对象,调用HongExecutor方法
 */
public class HongMapperProxy implements InvocationHandler {
    //属性
    private HongSqlSession hongSqlSession;
    private String mapperFile;
    private HongConfiguration hongConfiguration;

    //构造器
    public HongMapperProxy(HongConfiguration hongConfiguration,
                          HongSqlSession hongSqlSession,
                          Class clazz) {

        this.hongConfiguration = hongConfiguration;
        this.hongSqlSession = hongSqlSession;
        this.mapperFile = clazz.getSimpleName() + ".xml";
    }

    //提示：当执行Mapper接口的代理对象方法时，会执行到invoke方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        MapperBean mapperBean =
                hongConfiguration.readMapper(this.mapperFile);

        //判断是否是xml文件对应的接口
        if (!method.getDeclaringClass().getName().equals(mapperBean.getInterfaceName())) {
            return null;
        }

        //取出mapperBean的functions
        List<Function> functions = mapperBean.getFunctions();
        //判断当前mapperBean解析对应MappperXML后 , 有方法
        if (null != functions && 0 != functions.size()) {

            for (Function function : functions) {
                //当前要执行的方法和function.getFuncName()一样
                //说明我们可以从当前遍历的function对象中,取出相应的信息sql, 并执行方法
                if(method.getName().equals(function.getFuncName())) {
                    //如果我们当前的function 要执行的sqlType是select
                    //我们就去执行selectOne
                    /**
                     *
                     * 说明:
                     * 1. 如果要执行的方法是select , 就对应执行selectOne
                     * 2. 因为在HongSqlSession就写了一个 selectOne
                     * 3. 实际上HongSqlSession 应该对应不同的方法(多个方法)
                     * , 根据不同的匹配情况调用不同方法, 并且还需要进行参数解析处理, 还有比较复杂的字符串处理,拼接sql ,处理返回类型等等工作
                     * 4. 因为主要是讲解mybatis 生成mapper动态代理对象, 调用方法的机制，所以我做了简化
                     */
                    if("select".equalsIgnoreCase(function.getSqlType())) {
                        return hongSqlSession.selectOne(function.getSql(),String.valueOf(args[0]));
                    }
                }
            }
        }

        return null;
    }


}

1.2HongSqlSession返回动态代理对象

    /**
     * 1. 返回mapper的动态代理对象
     * 2. 这里clazz 到时传入的是 MonsterMapper.class
     * 3. 返回的就是MonsterMapper接口代理对象
     * 4. 当执行接口方法时(通过代理对象调用), 根据动态代理机制会执行到HongMapperProxy-invoke
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> T getMapper(Class<T> clazz) {

        //返回动态代理对象
        return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz},
                new HongMapperProxy(hongConfiguration,this,clazz));
    }

三.执行流程简述

1.读取MyBatis的配置文件。mybatis-config.xml为MyBatis的全局配置文件，用于配置数据库连接信息。
2.加载映射文件。映射文件即SQL映射文件，该文件中配置了操作数据库的SQL语句，需要在MyBatis配置文件mybatis-config.xml中加载。mybatis-config.xml 文件可以加载多个映射文件，每个文件对应数据库中的一张表。
3.构造会话工厂。通过MyBatis的环境配置信息构建会话工厂SqlSessionFactory。
4.创建会话对象。由会话工厂创建SqlSession对象，该对象中包含了执行SQL语句的所有方法。
5.Executor执行器。MyBatis底层定义了一个Executor接口来操作数据库，它将根据SqlSession传递的参数动态地生成需要执行的SQL语句，同时负责查询缓存的维护。
6.MappedStatement对象。在Executor接口的执行方法中有一个MappedStatement类型的参数，该参数是对映射信息的封装，用于存储要映射的SQL语句的id、参数等信息。
7.输入参数映射。输入参数类型可以是Map、List等集合类型，也可以是基本数据类型和POJO类型。输入参数映射过程类似于JDBC对preparedStatement对象设置参数的过程。
8.输出结果映射。输出结果类型可以是Map、List等集合类型，也可以是基本数据类型和POJO类型。输出结果映射过程类似于JDBC对结果集的解析过程