【Mybaits源码】简单的手写一个Mybatis(V1.0)

已于 2022-11-24 11:19:50 修改
阅读量142 收藏
点赞数 1
文章标签： mybatis java
于 2022-11-24 10:44:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43600770/article/details/128013563
版权

Mybatis-Agitator V1.0 是什么？

  • 参考CSDN以及Mybatis-3源码加上自己的理解完成对Mybatis雏形的搭建，了解Mybatis封装JDBC的核心思路以及运用到的各种设计模式
  • 后续版本将继续尝试深入源码完成更多的内容，例如MapperRegistry的管理、缓存、事务、日志等内容

前言

我们要干什么？

(做一个东西，最重要的就是明白自己要做个什么东西)

  1. 我们希望可以通过XML配置来配置我们的数据源，Mapper.xml路径
  2. 我们希望我们的配置可以去读取我们配置的Mapper.xml文件并且解析他
  3. 我们希望只通过调用接口方法即可完成查询

开工

新建项目

pom.xml


<dependencies>
    <!--  xml解析-->
    <dependency>
        <groupId>org.dom4j</groupId>
        <artifactId>dom4j</artifactId>
        <version>2.1.3</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.30</version>
    </dependency>
    <!--  连接池-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.15</version>
    </dependency>
    <dependency>
        <groupId>jaxen</groupId>
        <artifactId>jaxen</artifactId>
        <version>1.1.1</version>
    </dependency>
</dependencies>

新建我们的配置文件

resources/configuration.xml

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <dataSource>
        <property name="driverClassName">com.mysql.cj.jdbc.Driver</property>
        <property name="url">jdbc:mysql://localhost:3306/agitator?serverTimezone=UTC&amp;characterEncoding=utf8&amp;useUnicode=true&amp;useSSL=false</property>
        <property name="username">root</property>
        <property name="password">root</property>
    </dataSource>
    <mapper resource="mapper/UserMapper.xml"/>
</configuration>

resources/mapper/UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<mapper namespace="pers.agitator.mybatis.demo.mapper.UserMapper">
    <select id="selectAll" resultType="pers.agitator.mybatis.demo.pojo.User">
        select * from tb_user
    </select>
    <select id="selectByUsername" resultType="pers.agitator.mybatis.demo.pojo.User"
            paramType="pers.agitator.mybatis.demo.pojo.User">
        select * from tb_user where username=#{username}
    </select>
</mapper>

新建pojo和mapper类

demo.mapper.UserMapper

package pers.agitator.mybatis.demo.mapper;

import pers.agitator.mybatis.demo.pojo.User;

import java.util.List;

public interface UserMapper {
    List<User> selectAll();

    List<User> selectByUsername(User user);
}

demo.pojo.User

package pers.agitator.mybatis.demo.pojo;

public class User {
    private Integer id;
    private String username;
    private String address;
    // ...getter setter toString
}

一些常量

package pers.agitator.mybatis.constant;

public class XmlConstant {
    public static final String ROOT_ELEMENT_NAME = "configuration";

    public static final String DATA_SOURCE = "dataSource";

    public static final String PROPERTY = "property";

    public static final String RESOURCE = "resource";

    public static final String PROPERTY_NAME = "name";

    public static final String MAPPER_ID = "id";

    public static final String NAMESPACE = "namespace";

    public static final String PARAM_TYPE = "paramType";

    public static final String RESULT_TYPE = "resultType";
}

新建我们的Configuration类 用于保存配置

public class Configuration {
    // 用于保存<mapper>
    Map<String, MapperBean> mapperMap = new HashMap<>();
    // 用于根据<dataSource> 生成数据源 
    public DataSource dataSource;
    // ...getter setter
}

其中MapperBean是用于保存mapper中每一个方法的一些属性，比如id,resultType,paramType等

public class MapperBean {
    private String id;
    private Class<?> resultType;
    private Class<?> paramType;
    private String sql;
    // ... getter setter
}

开始解析xml配置文件生成Configuration类

XmlConfigurationBuilder

没什么特别难的，就是解析了xml结构提取配置信息

public class XmlConfigurationBuilder {
    private Configuration configuration;
    private final InputStream in;

    public XmlConfigurationBuilder(InputStream in) {
        newConfig();
        this.in = in;
    }

    private void newConfig() {
        this.configuration = new Configuration();
    }

    public Configuration parse() {
        try {
            SAXReader reader = new SAXReader();
            Document document = reader.read(in);
            Element root = document.getRootElement();

            if (!Objects.equals(root.getName(), XmlConstant.ROOT_ELEMENT_NAME)) {
                throw new ConfigurationException("root must be <{}>", XmlConstant.ROOT_ELEMENT_NAME);
            }
            //获取属性节点
            Properties properties = XmlUtil.coverElementPropertyToProperties(root.element(XmlConstant.DATA_SOURCE));
            // 加载连接池
            DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
            this.configuration.setDataSource(dataSource);

            // 加载mapper
            List<Node> nodes = root.selectNodes("//mapper");
            XmlMapperBuilder xmlMapperBuilder = new XmlMapperBuilder(configuration);
            for (Node node : nodes) {
                Element mapperElement = (Element) node;
                String mapperResource = mapperElement.attributeValue(XmlConstant.RESOURCE);
                xmlMapperBuilder.loadXmlMapper(ResourceUtil.getResources(mapperResource));
            }
            return configuration;
        } catch (Exception e) {
            throw new ConfigurationException("加载配置出现错误", e);
        }
    }
}

其中的XmlMapperBuilder就是吧Mapper.xml解析成MapperBean并存在Configuration中的

public class XmlMapperBuilder {
    private final Configuration configuration;

    public XmlMapperBuilder(Configuration configuration) {
        this.configuration = configuration;
    }

    public void parse(InputStream in) throws DocumentException, ClassNotFoundException {
        Document document = new SAXReader().read(in);

        Element rootElement = document.getRootElement();
        String namespace = rootElement.attributeValue("namespace");
        // 解析 select 标签
        parseSelectElement(rootElement, namespace);
        // 其他1.0先不搞
    }

    private void parseSelectElement(Element rootElement, String namespace) throws ClassNotFoundException {
        List<Node> list = rootElement.selectNodes("//select");

        for (Node node : list) {
            MapperBean mapper = new MapperBean();
            Element element = (Element) node;
            String id = element.attributeValue(XmlConstant.MAPPER_ID);
            mapper.setId(id);
            String paramType = element.attributeValue(XmlConstant.PARAM_TYPE);
            if (StrUtil.isNotBlank(paramType)) {
                mapper.setParamType(Class.forName(paramType));
            }
            String resultType = element.attributeValue(XmlConstant.RESULT_TYPE);
            if (StrUtil.isNotBlank(resultType)) {
                mapper.setResultType(Class.forName(resultType));
            }
            mapper.setSql(element.getTextTrim());
            String key = namespace + "." + id;
            configuration.getMapperMap().put(key, mapper);
        }
    }
}

到这里，xml配置就都被我们抽象成对象保存在一个Configuration类中了

接下来是比较难的部分，核心接口

  • Executor(封装JDBC操作)
  • SqlSession(为Executor和Configuration搭建桥梁,也是框架对外操作数据库的主要接口)
  • SqlSessionFactory(SqlSession工厂接口)

在这里插入图片描述

以上时序图就是从入口到加载配置到获得SqlSession到调用Executor执行查询的时序，我们一个一个实现

SqlSessionFactory

public interface SqlSessionFactory {
    SqlSession openSession();
}

SqlSessionFactoryBuilder

public class SqlSessionFactoryBuilder {
    private final InputStream in;

    public SqlSessionFactoryBuilder(String classPath) {
        this(ResourceUtil.getResources(classPath));
    }

    public SqlSessionFactoryBuilder(InputStream in) {
        this.in = in;
    }

    public SqlSessionFactory build() {
        XmlConfigurationBuilder xmlConfigurationBuilder = new XmlConfigurationBuilder(in);
        Configuration configuration = xmlConfigurationBuilder.parse();
        return new DefaultSqlSessionFactory(configuration);
    }

}

这里面所构建出来的DefaultSqlSessionFactory 是SqlSessionFactory的默认实现 如果下

public class DefaultSqlSessionFactory implements SqlSessionFactory {
    private final Configuration configuration;

    public DefaultSqlSessionFactory(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public SqlSession openSession() {
        return new DefaultSqlSession(configuration);
    }
}

顺水推舟，看下SqlSession的默认实现

public interface SqlSession extends Closeable {
    <E> List<E> selectList(String statementId, Object... params);
// 暂时不看
//    <E> E getMapper(Class<E> clazz);
}

public class DefaultSqlSession implements SqlSession {
    private final Configuration configuration;

    private final Executor executor;

    public DefaultSqlSession(Configuration configuration) {
        this.configuration = configuration;
        this.executor = new SimpleExecutor(configuration);
    }

    @Override
    public void close() throws IOException {
        // 还没实现
    }

    @Override
    public <E> List<E> selectList(String statementId, Object... params) {
        MapperBean mapperBean = configuration.getMapperMap().get(statementId);
        return executor.query(mapperBean, params);
    }
}

可以看到 sqlSession执行查询的时候其实是委托Executor去完成了

public interface Executor {
    <E> List<E> query(MapperBean mapper, Object... params);
}

SimpleExecutor的过程就相对比较复杂繁多，让我们一个一个说

  1. getBoundSql涉及了GenericTokenParser(将参数通过自定义的前缀后缀解析例如前缀#{和后缀})
  2. GenericTokenParser做的呢就是吧#{username}读取出来并排除转义字符’\'，然后由ParameterMappingTokenHandler替换为?再把username存起来
  3. 再把解析后的带?的sql以及参数存放到BoundSql
  4. 使用PreparedStatement执行sql
  5. handleResultSet将结果集映射为指定的ResultType
public class SimpleExecutor implements Executor {
    private final Configuration configuration;

    public SimpleExecutor(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public <E> List<E> query(MapperBean mapper, Object... params) {
        try {
            Connection connection = configuration.getDataSource().getConnection();
            BoundSql boundSql = getBoundSql(mapper);
            PreparedStatement preparedStatement = getPreparedStatement(connection, boundSql, params);
            ResultSet resultSet = preparedStatement.executeQuery();
            return handleResultSet(mapper, resultSet);
        } catch (Exception e) {
            throw new ExecutorException(e);
        }
    }

    private static PreparedStatement getPreparedStatement(Connection connection, BoundSql boundSql, Object... params) throws SQLException {
        String sqlText = boundSql.getSqlText();
        List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();

        //获取preparedStatement，并传递参数值
        PreparedStatement preparedStatement = connection.prepareStatement(sqlText);

        for (int i = 0; i < parameterMappingList.size(); i++) {
            ParameterMapping parameterMapping = parameterMappingList.get(i);
            String content = parameterMapping.getContent();
            Object o = ReflectUtil.getFieldValue(params[0], content);
            preparedStatement.setObject(i + 1, o);
        }
        return preparedStatement;
    }

    private <E> List<E> handleResultSet(MapperBean mapper, ResultSet resultSet) throws SQLException, InstantiationException, IllegalAccessException, IntrospectionException, InvocationTargetException {
        List<E> result = new ArrayList<>();
        //封装结果集
        Class<?> resultType = mapper.getResultType();
        while (resultSet.next()) {
            Object obj = resultType.newInstance();
            ResultSetMetaData metaData = resultSet.getMetaData();
            int columnCount = metaData.getColumnCount();
            for (int i = 1; i <= columnCount; i++) {
                String columnName = metaData.getColumnName(i);
                Object value = resultSet.getObject(i);
                PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultType);
                Method writeMethod = propertyDescriptor.getWriteMethod();
                writeMethod.invoke(obj, value);
            }
            result.add((E) obj);
        }
        return result;
    }

    private static BoundSql getBoundSql(MapperBean mapper) {
        String sql = mapper.getSql();
        ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
        GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
        String parseSql = genericTokenParser.parse(sql);
        return new BoundSql(parseSql, parameterMappingTokenHandler.getParameterMappings());
    }
}

到这里我们就完成了我们的雏形，接下来demo一下

public class User {
    private Integer id;
    private String username;
    private String address;
    // ... getter setter toString
}

public interface UserMapper {
    List<User> selectAll();

    List<User> selectByUsername(User user);
}

public class Main {
    public static void main(String[] args) {
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder("configuration.xml");
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build();
        SqlSession sqlSession = sqlSessionFactory.openSession();
        List<User> list = sqlSession.selectList("pers.agitator.mybatis.demo.mapper.UserMapper.selectAll");
        System.out.println(list);
        User user = new User();
        user.setUsername("用户名");
        List<User> list2 = sqlSession.selectList("pers.agitator.mybatis.demo.mapper.UserMapper.selectByUsername", user);
        System.out.println(list2);
    }
}

可以自行执行以下，这个时候我们看到我们是通过statementId去执行对应的sql，不够优雅，这个时候动态代理就派上用场了！

  1. 在SqlSession添加getMapper方法

public interface SqlSession extends Closeable {
    <E> E getMapper(Class<E> clazz);
}
  1. 实现getMapper方法，读接口生成代理类去生成对应的statementId进而调用select方法
public class DefaultSqlSession implements SqlSession {

    @Override
    public <E> E getMapper(Class<E> clazz) {

        Object proxyInstance = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{clazz}, ((proxy, method, args) -> {
            String methodName = method.getName();
            String clazzName = method.getDeclaringClass().getName();
            String statementId = clazzName + "." + methodName;
            return selectList(statementId, args);
        }));
        return (E) proxyInstance;
    }
}

demo一下

public class Main {
    public static void main(String[] args) {
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder("configuration.xml");
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build();
        SqlSession sqlSession = sqlSessionFactory.openSession();
        User user = new User();
        user.setUsername("用户名");
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        System.out.println(mapper.selectAll());
        System.out.println(mapper.selectByUsername(user));
    }
}
AgitatorZ
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springBoot结合Mybatis的使用，其中包括了Mybaits的xml配置使用、Mybatis部分源码分析等内容
07-02
SpringBoot结合Mybatis的使用Demo，项目中通过SpringBoot配置Mybaits，配置mybatis的xml文件，以及程序启动类上通过MapperScan注解，实现包扫描。 通过controller层调用service层业务逻辑，再通过service层调用...
手写简易mybatis
03-06
参考mybaits解析配置文件，sqlsession调用，mapper注解扫描动态代理等
手写Mybatis
longzhutengyue的博客
03-11 669
配置来源于两个地方，一个是配置文件(主配置文件conf. xml, mapper文件*.xml),一个是java代码中的注解，将主配置文件内容解析封装到Configuration,将sql的配置信息加载成为一个mappedstatement对象，存储在内存之中。
手写一个简单的mybatis
岁月不饶人，我亦未曾饶过岁月
12-08 960
今天写个简单版V1.0版本的mybatis，可以其实就是在jdbc的基础上一步步去优化的，网上各种帖子都是照着源码写，各种抄袭，没有自己的一点想法，写代码前要先思考，如果是你，你该怎么写？怎么去实现，为什么要这样写？而不是照着源码依葫芦画瓢。
【零基础入门MyBatis系列】第五篇——手写MyBatis框架
欢迎来到我的世界
11-09 313
介绍了如何通过dom4j解析XML文件，手写了一个简单的MyBatis的框架，最后对我们的框架打包并进行测试
自定义 手写实现 Mybatis 框架
m0_46013789的博客
07-25 644
MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。...
手写mybatis
螃蟹士兵
07-15 289
分析jdbc操作问题 先抛出一段jdbc处理sql的代码 public static void main(String[] args) { Connection connection = null; PreparedStatement preparedStatement = null; ResultSet resultSet = null; try { //加载数据驱动 Class.forName("com.mys
mybatis源码学习——开篇
qq_41683000的博客
02-06 228
mybatis源码学习——开篇
mybatis第八话 - mybaits之ParameterHandler参数处理源码分析
生生不息，则源源不断
03-13 1011
本章主要记录了mybatis参数处理源码分析 上一篇：[mybatis第七话 - mybatis插件篇之pagehelper的源码分析](https://blog.csdn.net/qq_35551875/article/details/122990101) 下一篇：[mybatis第九话 - 手写实现一个简单的mybatis版本](https://blog.csdn.net/qq_35551875/article/details/123419753) 勿以恶小而为之，勿以善小而不为
Mybatis源码面试题汇总(持续更新中, 答案收集中)
过道
08-14 802
Mybatis知识图谱
mybaits plus使用教程,比mybatis强太多了.zip
01-07
mybaits plus使用教程,比mybatis强太多了.zip
IDEA搭建的一个简单的spring boot+mybatis工程demo
06-06
IDEA搭建的一个简单的spring boot+mybatis工程demo，适合初学者
创建springboot+mybatis+mysql项目的源码
04-30
创建springboot+mybatis+mysql项目的源码，有springboot+mybatis+mysql项目创建的详细过程
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 892
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 898
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1209
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 671
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 226
【代码】Java手动启动jar包。
mybaits xml循环遍历一个对象的集合
07-28
您可以使用MyBatis的foreach标签来循环遍历一个对象的集合。首先，您需要在您的Mapper XML文件中定义一个包含foreach标签的SQL语句。以下是一个示例： ```xml SELECT * FROM user WHERE id IN (" separator=",...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值