MyBatis源码解析（七）：手写实现简易MyBatis框架

最新推荐文章于 2022-04-26 23:16:14 发布
最新推荐文章于 2022-04-26 23:16:14 发布
阅读量258 收藏
点赞数
分类专栏： mybatis 文章标签： MyBatis 源码分析 手写
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011976388/article/details/88927897
版权

一，执行流程图

二，执行步骤分析

    1，初始化配置信息，其中包括Mapper初始化

    2，openSession()，初始化DefaultSqlSession和Executor执行器

    3，getMapper()，获取执行Mapper的代理对象，准备执行Statement

    4，执行Statement，通过动态代理执行方法，获取数据库结果集，并映射到JavaBean

三，代码示例

    1，整体代码结构

        * POM文件

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.2</version>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.6</version>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.16.22</version>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.4</version>
    </dependency>
    <dependency>
      <groupId>commons-beanutils</groupId>
      <artifactId>commons-beanutils</artifactId>
      <version>1.7.0</version>
    </dependency>

    2，Mapper接口

package com.gupao.self.text;

import com.gupao.self.pojo.UserVO;

import java.util.List;

/**
 * @author pj_zhang
 * @create 2019-03-31 11:10
 **/
public interface TestMapper {

    /**
     * 查询结果集
     * @return
     */
    List<UserVO> selectData();

}

    3，客户端执行类

package com.gupao.self.text;

import com.gupao.self.pojo.UserVO;
import com.gupao.self.sqlsession.SelfSqlSession;
import com.gupao.self.sqlsession.SelfSqlSessionFactory;
import com.gupao.self.sqlsession.SelfSqlSessionFactoryBuilder;

import java.util.List;

/**
 * @author pj_zhang
 * @create 2019-03-31 11:31
 **/
public class SelfMybatisTest {

    public static void main(String[] args) {
        // 获取sqlSessionFactory
        SelfSqlSessionFactory sqlSessionFactory = new SelfSqlSessionFactoryBuilder().build();
        // 获取sqlSession
        SelfSqlSession sqlSession = sqlSessionFactory.openSession();
        // 获取mapper
        TestMapper mapper = sqlSession.getMapper(TestMapper.class);
        // 执行Statement
        List<UserVO> lstData = mapper.selectData();
        // 输出结果
        System.out.println(lstData);
    }

}

        * VO类

package com.gupao.self.pojo;

import lombok.Data;

/**
 * @author pj_zhang
 * @create 2019-03-31 11:56
 **/
@Data
public class UserVO {

    private String name;

    private String word;

}

    4，初始化配置信息，获取SqlSessionFactory解析

        * 通过SqlSessionFactoryBuilder.builder()构建DefaultSqlSessionFactory，传递Configuration对象引用

package com.gupao.self.sqlsession;

import com.gupao.self.config.SelfConfiguration;
import com.gupao.self.config.SelfConfigurationBuilder;

/**
 * 自定义SelfSqlSessionFactoryBuilder, 用来构造SqlSessionFactory
 * @author pj_zhang
 * @create 2019-03-31 10:57
 **/
public class SelfSqlSessionFactoryBuilder {

    public SelfSqlSessionFactory build() {
        // 初始化配置信息, 生成全局配置文件
        SelfConfiguration configuration = SelfConfigurationBuilder.createConfiguration();
        return new SelfDefaultSqlSessionFactory(configuration);
    }


}

        * 初始化Configuration对象，并对配置文件进行解析（此处通过硬编码说明问题）

package com.gupao.self.config;

/**
 * 全局配置信息构建类
 * @author pj_zhang
 * @create 2019-03-31 11:02
 **/
public class SelfConfigurationBuilder {

    /**
     * 构建有效的配置信息
     * @return
     */
    public static SelfConfiguration createConfiguration() {
        SelfConfiguration configuration = new SelfConfiguration();
        // 解析mapper
        resolveMapper(configuration);
        return configuration;
    }

    /**
     * 解析Mapper
     * @param configuration
     */
    private static void resolveMapper(SelfConfiguration configuration) {
        try {
            configuration.addMapper();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

        * Configuration对象内部添加mapper

 // 添加mapper
    // SelfConfiguration.addMapper
    public void addMapper() throws ClassNotFoundException {
        selfMapperRegister.addMapper();
    }

        * 转发SelfMapperRegister添加，添加mapper到Map集合中，后续通过SelfMapperProxyFactory获取代理对象

package com.gupao.self.mapper;

import com.gupao.self.sqlsession.SelfSqlSession;

import java.lang.reflect.Proxy;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 自定义Mapper注册类
 * @author pj_zhang
 * @create 2019-03-31 11:08
 **/
public class SelfMapperRegister {

    private Map<Class<?>, SelfMapperProxyFactory<?>>  knowsMapper = new ConcurrentHashMap<>();

    // 添加mapper
    // SelfMapperRegister.addMapper
    public void addMapper() throws ClassNotFoundException {
        knowsMapper.put(Class.forName(SelfMapperMap.NAME_SPACE), new SelfMapperProxyFactory(Class.forName(SelfMapperMap.NAME_SPACE)));
    }

    public static class SelfMapperMap {
        public static final String NAME_SPACE = "com.gupao.self.text.TestMapper";

        public static final Map<String, String> statement2Sql = new ConcurrentHashMap<>();

        static {
            statement2Sql.put("selectData", "select username as name, password as word from user_t");
        }

    }

}

    5，获取SqlSession

        * SqlSession触发

// 获取sqlSession
        SelfSqlSession sqlSession = sqlSessionFactory.openSession();

        * 从SqlSessionFactory获取sqlSession；内部初始化Executor执行器，最终返回DefaultSqlSession

package com.gupao.self.sqlsession;

import com.gupao.self.config.SelfConfiguration;
import com.gupao.self.executor.SelfCachingExecutor;
import com.gupao.self.executor.SelfExecutor;
import com.gupao.self.executor.SelfSimpleExecutor;
import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;

import javax.sql.DataSource;

/**
 * @author pj_zhang
 * @create 2019-03-31 11:00
 **/
public class SelfDefaultSqlSessionFactory implements SelfSqlSessionFactory {

    private SelfConfiguration configuration;

    public SelfDefaultSqlSessionFactory(SelfConfiguration configuration) {
        this.configuration = configuration;
    }

    @Override
    // SelfDefaultSqlSessionFactory.openSession
    public SelfSqlSession openSession() {
        // 获取执行器, executor
        SelfExecutor executor = createExecutor();
        return new SelfDefaultSqlSession(configuration, executor);
    }

    private SelfExecutor createExecutor() {
        SelfExecutor executor = new SelfSimpleExecutor();
        executor = new SelfCachingExecutor(executor);
        return executor;
    }
}

        * 初始化DefaultSqlSession

package com.gupao.self.sqlsession;

import com.gupao.self.config.SelfConfiguration;
import com.gupao.self.executor.SelfExecutor;

import java.lang.reflect.Method;

/**
 * 默认的SqlSession
 * @author pj_zhang
 * @create 2019-03-31 11:04
 **/
public class SelfDefaultSqlSession implements SelfSqlSession {

    private SelfConfiguration configuration;

    private SelfExecutor executor;

    public SelfDefaultSqlSession(SelfConfiguration configuration, SelfExecutor executor) {
        this.configuration = configuration;
        this.executor = executor;
    }

}

    6，获取执行Mapper

        * 客户端触发

// 获取mapper
        TestMapper mapper = sqlSession.getMapper(TestMapper.class);

        * 转发SqlSession获取Mapper

@Override
    // SelfDefaultSqlSession.getMapper
    public <T> T getMapper(Class<?> clazz) {
        return configuration.getMapper(clazz, this);
    }

        * 转发Configuration获取Mapper

// 获取mapper
    // SelfConfiguration.getMapper
    public <T> T getMapper(Class<?> clazz, SelfSqlSession sqlSession) {
        return selfMapperRegister.getMapper(clazz, sqlSession);
    }

        * 转发SelfMapperRegister获取Mapper

// 获取mapper, 通过
    public <T> T getMapper(Class<?> clazz, SelfSqlSession sqlSession) {
        SelfMapperProxyFactory selfMapperProxyFactory = knowsMapper.get(clazz);
        if (null == selfMapperProxyFactory) {
            throw new RuntimeException("the execute mapper is not exists");
        }
        return (T) selfMapperProxyFactory.newInstace(sqlSession);
    }

        * 提交SelfMapperProxyFactory最终初始化为代理对象，代理对象执行类为SelfMapperProxy

package com.gupao.self.mapper;

import com.gupao.self.sqlsession.SelfSqlSession;

import java.lang.reflect.Proxy;

/**
 * @author pj_zhang
 * @create 2019-03-31 11:12
 **/
public class SelfMapperProxyFactory<T> {

    private Class<?> clazz;

    public SelfMapperProxyFactory(Class<?> clazz) {
        this.clazz = clazz;
    }

    public <T> T newInstace(SelfSqlSession sqlSession) {
        return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[] {clazz}, new SelfMapperProxy(sqlSession));
    }
}

    7，执行Statement

        * 客户端触发

// 执行Statement
        List<UserVO> lstData = mapper.selectData();

        * 转发代理对象执行类进行执行

package com.gupao.self.mapper;

import com.gupao.self.sqlsession.SelfSqlSession;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * @author pj_zhang
 * @create 2019-03-31 11:21
 **/
public class SelfMapperProxy implements InvocationHandler {

    private SelfSqlSession sqlSession;

    public SelfMapperProxy(SelfSqlSession sqlSession) {
        this.sqlSession = sqlSession;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 基层自Object类的方法执行
        if (Object.class.equals(method.getDeclaringClass().getClass())) {
            return method.invoke(this, args);
        }
        SelfMapperMethod mapperMethod = createMapperMethod(method);
        return mapperMethod.execute(sqlSession, method);
    }

    private SelfMapperMethod createMapperMethod(Method method) {
        return new SelfMapperMethod(method);
    }
}

        * 转发MapperMethod，进行执行Statement类型划分

package com.gupao.self.mapper;

import com.gupao.self.sqlsession.SelfSqlSession;
import org.apache.commons.lang3.StringUtils;

import java.lang.reflect.Method;
import java.util.List;

/**
 * 自定义MapperMethod, 根据查询方式选择不同的策略
 * @author pj_zhang
 * @create 2019-03-31 12:00
 **/
public class SelfMapperMethod {

    private Method method;

    public SelfMapperMethod(Method method) {
        this.method = method;
    }

    public Object execute(SelfSqlSession sqlSession, Method method) {
        // 获取方法名称
        String methodName = this.method.getName();
        // 区分执行方式, 简易区分
        // 数据查询处理, 源码内部根据Statement标签进行了处理
        if (StringUtils.isNotEmpty(methodName) && methodName.startsWith("select")) {
            Class<?> returnClazz = this.method.getReturnType();
            // 返回List集合
            if (List.class.getName().equals(returnClazz.getName())) {
                // 调用SqlSession查询
                return sqlSession.selectList(method);
            }
        }
        return null;
    }
}

        * 调用SqlSession的select执行语句执行

// SelfDefaultSqlSession.selectList
    public Object selectList(Method method) {
        // 通过Executor执行器获取结果集
        return executor.execute(method);
    }

        * 调用CachingExecutor，先从缓存中获取数据，获取不到，再从数据库获取

package com.gupao.self.executor;

import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 缓存执行器
 * @author pj_zhang
 * @create 2019-03-31 11:36
 **/
public class SelfCachingExecutor implements SelfExecutor {

    private Map<String, List> cacheMap = new ConcurrentHashMap<>();

    private SelfExecutor delegete;

    public SelfCachingExecutor(SelfExecutor executor) {
        this.delegete = executor;
    }

    @Override
    public <T> List<T> execute(Method method) {
        // 拼接缓存key值, 作为SqlSesion级别缓存
        String cacheKey = method.getDeclaringClass().getName() + "." + method.getName();
        if (cacheMap.containsKey(cacheKey)) {
            return cacheMap.get(cacheKey);
        }
        List<T> lstData = delegete.execute(method);
        // 添加结果集到缓存中
        cacheMap.put(cacheKey, lstData);
        return lstData;
    }
}

        * 调用SimpleExecutor，从数据库中获取结果集，并完成ORM映射，返回结果！

package com.gupao.self.executor;

import com.gupao.self.mapper.SelfMapperRegister;
import com.gupao.self.pojo.UserVO;
import org.apache.commons.beanutils.BeanUtils;

import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/**
 * 标准执行器
 * @author pj_zhang
 * @create 2019-03-31 11:36
 **/
public class SelfSimpleExecutor implements SelfExecutor {
    @Override
    public <T> List<T> execute(Method method) {
        List<UserVO> lstData = new ArrayList<>();
        try {
            // 获取数据库连接
            Connection connection = getConnection();
            // 连接数据库查询数据
            if (method.getDeclaringClass().getName().equals(SelfMapperRegister.SelfMapperMap.NAME_SPACE)) {
                String sql = SelfMapperRegister.SelfMapperMap.statement2Sql.get(method.getName());
                PreparedStatement statement = connection.prepareStatement(sql);
                ResultSet resultSet = statement.executeQuery();
                // 进行ORM映射
                while (resultSet.next()) {
                    UserVO userVO = new UserVO();
                    // 数据库元数据
                    ResultSetMetaData metaData = resultSet.getMetaData();
                    int columnCount = metaData.getColumnCount();
                    for (int i = 1; i <= columnCount; i++) {
                        // 映射到VO的属性名
                        String attrName = metaData.getColumnLabel(i);
                        // 数据类型
                        String className = metaData.getColumnClassName(i);
                        // 获取数据值
                        Object value = findValue(attrName, className, resultSet);
                        // 使用BeanUtils填充
                        BeanUtils.setProperty(userVO, attrName, value);
                    }
                    lstData.add(userVO);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (List<T>) lstData;
    }

    private Object findValue(String attrName, String className, ResultSet resultSet) {
        // 此处需要根据className, 对每一种情况进行识别,
        if (String.class.getName().equals(className)) {
            try {
                return resultSet.getString(attrName);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public Connection getConnection() {
        Connection connection = null;
        try {
            String URL="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8";
            String USER="root";
            String PASSWORD="123456";
            //1.加载驱动程序
            Class.forName("com.mysql.jdbc.Driver");
            //2.获得数据库链接
            connection = DriverManager.getConnection(URL, USER, PASSWORD);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }
}

四，结果集

五，代码链接

https://github.com/zpj0427/my_test/tree/master/com-gupao-mybatis

传说中的靖哥哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
纯手写，没有使用myBatis框架的代码
10-15
另外还有加入框架的写法，此是最基础 的登录十天免登陆的。
MyBatis源码解析
12-18
MyBatis源码解析
（三）自定义 mybatis 之手写一个简单的Mybatis
(.*?)的博客
04-21 480
自定义 Mybatis前言一、自定义Mybatis框架1.1、需求及目标：1.2、自定义Mybatis框架主线图1.3、自定义Mybatis步骤1：创建maven工程，packing为jar,引入依赖步骤2：定义框架对外API接口，接口中只定义一个selectList方法步骤3：使用工厂模式进行SqlSession的实例化步骤4：分析 SqlSession 中的需要优化问题步骤5：解决第一个TODO待办事项 （数据库信息的获取）步骤6：处理第二个和第三个待办事项（sql和resultType的获取）步骤7
开源框架解析，手写MyBatis细节思路
weixin_34295316的博客
12-20 220
Mybatis基本纲要 Mybatis组成 · 动态SQL · Config配置 · Mapper配置 核心源码分析 · Configuration源码解析 · SqlSessionFactory源码解析 · SqlSession源码解析 · SqlSessionManager源码解析 手写Mybatis框架 Mybatis是什么？My...
手写简易的Mybatis
Kerwin的博客
08-29 283
手写简易的Mybatis 此篇文章用来记录今天花个五个小时写出来的简易版mybatis，主要实现了基于注解方式的增删查改，目前支持List，Object类型的查找，参数都是基于Map集合的，可以先看一下接口： public interface StudentInterface { @Select(value = " select * from student where age &gt...
手写一个简易版mybatis
IT可乐
11-16 336
本篇文章，可乐将为大家介绍通过接口代理的方式去执行SQL操作。话不多说，直接上图： 其实无论哪种方式，我们最终是需要找到对应的 SQL 语句，接口代理的方式就是通过 【包名.方法名】 的方式，去找到 xxxMapper.xml 文件中的 SQL 语句。 很明显，通过动态代理的方式，我们能够实现该功能。下面，可乐将为大家手撸一个 Mybatis 的接口代理。 1、创建接口 package com.itcoke.mapperproxy; import com.itcoke.bean.Person; pu
手写mybatis框架源码由浅入深
01-03
手写mybatis框架源码 不借助其他任何框架，从最底层开始着手，用最简单的代码，将mybatis的底层框架，手写出来，让你对mybatis有一个更加深刻和直观的理解 详见：...
基于Java的Mybatis源码解析设计源码
最新发布
05-22
Mybatis源码解析设计源码：该项目基于Java开发，包含37个文件，主要使用Java语言。该项目旨在对Mybatis框架的源代码进行深入解析，以帮助开发者更好地理解和使用Mybatis，提高开发效率和质量。
Mybatis源码解析之流程解析：初始化阶段
12-22
源码解析地址 https://github.com/erlieStar/mybatis-3 debug源码用项目 https://github.com/erlieStar/mybatis-examples 介绍 Mybatis的核心流程主要分为两大阶段 初始化阶段：读取XML配置文件和注解中的配置信息，...
外卖点餐系统，后端：springboot+mybatis+mybatis-plus 前端：vue+elmen
05-08
后端使用Spring Boot和MyBatis作为开发框架，而前端使用Vue和ElementUI作为开发工具。 后端开发框架 后端使用Spring Boot作为开发框架，Spring Boot是一个轻量级的框架，易于学习和使用，可以快速搭建项目。它提供...
手写简易版ORM框架（仿mybatis）
08-21
自己手写的一个半自动框架，里面有运行例子，部分代码从mybatis中抽出
手写一个简化版Mybatis
YotWei
08-07 1067
1、引包 引入dom4j包以及数据库连接包，我用的是mysql数据库，因此引入mysql-connector包 2、数据库创建 数据库比较简单，创建sql如下 CREATE DATABASE db_test; use db_test; CREATE TABLE `tb_user` ( `id` int(11) NOT NULL, `name` varchar(20) NOT ...
mybatis 简单手写
逆风的蔷薇
01-29 463
一，定义实体 public class User {     private int id;     private String name;     private int age;     private String addr;     public int getId() {         return id;     }     public void setId(int id)...
带你手写一个 Mybatis 框架，全面了解 Mybatis 实现原理
GitChat
09-09 368
前几篇 Chat 我们手写过 RPC 框架，NettyMVC 框架，IOC 容器等等。这个 chat 我们来手写一个 Mybatis 框架，作为目前最为常用的持久层框架，我们不仅仅要会使用，更要了解它的底层实现原理。手写框架不仅仅能帮我们了解原理，更能让我们快速从初级程序员向高级程序员迈进。 在本 Chat 你将学会如下内容： JDBC 的实现原理 MyBatis 源码分析 动态代理在 MyBa...
手写迷你版本Mybatis
好习惯要坚持下去
10-25 929
动手写一个迷你版的MyBatis MyBatis原理架构图 其实对于MyBatis最为关键的就在于： XXXMapper mapper = sqlSession.getMapper(XXXMapper.class); 大家可以以这个为切入口，进行源码跟踪，容易得到上面的调用链。 我们先来看一下迷你版MyBatis的整体框架思路： 迷你版MyBatis 执行器MyExecu...
手写Mybatis
worn_xiao的博客
12-25 3984
一 分析mybatis的工作原理: 如上图所示是mybatis的工作原理 1 首先程序加载全局的配置文件，形成配置文件类 2 通过Mapper的接口形成一个mapper的代理 3 通过调用mapper的代理执行对应的方法，此时代理中会发现，method.getdeclareClass并不是一个类，而是一个接口 4 此时通过执行mapperMethod，也就是接口的方法
手写超简易版mybatis源码
GiantCrocodile的博客
04-26 390
mybatis手写简易版
mybatis原理之手写mybatis框架（一）架构和流程分析
语雀同名：犬豪 yuque.com/qhao
02-03 623
1. mybatis的架构和流程分析 先直接来一张mybatis的架构图，看下mybatis按照模块整体是怎么设计的： 接口层 接口层是MyBatis提供给开发人员的一套API，主要体现在SqlSession接口。通过SqlSession接口开发人员可以完成CRUD。这层主要考虑的就是使用人的需求，用起来怎么方便怎么设计，属于对外的接口。 数据处理层 数据处理层就是对内的，整个数据处理层...
MyBatis框架深度解析：从环境搭建到高级特性
"这篇学习笔记详细介绍了MyBatis框架，涵盖了环境搭建、数据库操作、配置文件解析、参数获取、查询功能、特殊SQL执行、自定义ResultMap、动态SQL、缓存机制、逆向工程和分页插件等内容，旨在帮助读者深入理解并掌握...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值