二、手写MyBatis简易版框架

最新推荐文章于 2024-08-21 15:21:48 发布
最新推荐文章于 2024-08-21 15:21:48 发布
阅读量1.3k 收藏 3
点赞数
分类专栏： MyBatis 文章标签： mybatis 数据库 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36091079/article/details/129798863
版权

文章目录

前言

今天准备自己动手写一个简易的MyBatis用来实现对数据库的操作。其实，Mybatis本质上是对JDBC进行了封装，然后使用各种优化来解决针对使用JDBC的一些痛点问题。温故而知新，先简单的回顾一下JDBC操作数据库的流程，然后思考一下JDBC这样使用的缺点。

回顾JDBC操作数据库

JDBC操作数据库流程

JDBC API 允许应用程序访问任何形式的表格数据，特别是存储在关系数据库中的数据。
image-20210812103601952.png

代码示例：

@Test
public void testJDBC() {
    Connection connection = null;
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;

    try {
        // 1、加载数据库驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        // 2、通过驱动管理类获取数据库连接
        connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis", "root", "root");
        // 3、定义sql语句?表示占位符
        String sql = "select * from t_user where username = ?";
        // 4、获取预处理statement
        preparedStatement = connection.prepareStatement(sql);
        // 5、 设置参数，第一个参数为sql语句中参数的序号(从1开始)，第二个参数为设置的参数值
        preparedStatement.setString(1, "夜不收");
        // 6、向数据库发出sql执行查询，查询出结果集
        resultSet = preparedStatement.executeQuery();
        // 7、遍历查询结果集
        User user = new User();
        while (resultSet.next()) {
            int id = resultSet.getInt("id");
            String username = resultSet.getString("username");
            String password = resultSet.getString("password");
            int age = resultSet.getInt("age");
            String sex = resultSet.getString("sex");
            String email = resultSet.getString("email");
            // 封装User
            user.setId(id);
            user.setUsername(username);
            user.setPassword(password);
            user.setAge(age);
            user.setSex(sex);
            user.setEmail(email);
        }
        System.out.println(user);

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        // 8、释放资源
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (preparedStatement != null) {
            try {
                preparedStatement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

JDBC问题分析&解决思路

针对上述JDBC操作数据的步骤，我们逐个分析。

  • 加载驱动，获取链接

image.png
存在问题1：数据库配置信息存在硬编码问题。优化思路：使用配置文件。
存在问题2：频繁创建、释放数据库连接问题。优化思路：使用数据连接池

  • 定义sql、设置参数、执行查询

image.png
存在问题3：SQL语句、设置参数、获取结果集参数均存在硬编码问题。优化思路：使用配置文件。

  • 遍历查询结果集

image.png
存在问题4：手动封装返回结果集，较为繁琐。优化思路：手动封装返回结果集，较为繁琐。

  • 问题总结

针对JDBC各个环节中存在的不足，我们整理出对应的优化思路，统一汇总：

存在问题优化思路
数据库配置信息存在硬编码问题使用配置文件
频繁创建、释放数据库连接问题使用数据连接池
SQL语句、设置参数、获取结果集参数均存在硬编码问题使用配置文件
手动封装返回结果集，较为繁琐使用Java反射

自定义持久层框架

思路分析

JDBC是个人作战，凡事亲力亲为，低效而高险，自己加载驱动，自己建连接，自己 …
而持久层框架好比是多工种协作，分工明确，执行高效，有专门负责解析注册驱动建立连接的，有专门管理数据连接池的，有专门执行sql语句的，有专门做预处理参数的，有专门装配结果集的 …

优化思路：框架的作用，就是为了帮助我们减去繁重开发细节与冗余代码，使我们能更加专注于业务应用开发。

使用JDBC和使用持久层框架区别

对比.jpg
是不是发现，拥有这么一套持久层框架是如此舒适，我们仅仅需要干两件事：

  • 配置数据源（地址/数据名/用户名/密码）
  • 编写SQL与参数准备（SQL语句/参数类型/返回值类型）

框架，除了思考本身的工程设计，还需要考虑到实际项目端的使用场景，干系方涉及两端：

  • 使用端（实际项目）
  • 持久层框架本身

以上两步，我们通过一张架构图《 手写持久层框架基本思路 》来梳理清楚：
3.jpg

核心接口/类重点说明

分工协作角色定位类名定义
负责读取配置文件资源辅助类Resources
负责存储数据库连接信息数据库资源类Configuration
负责存储SQL映射定义、存储结果集映射定义SQL与结果集资源类MappedStatement
负责解析配置文件，创建会话工厂SqlSessionFactory会话工厂构建者SqlSessionFactoryBuilder
负责创建会话SqlSession会话工厂SqlSessionFactory
指派执行器Executor会话SqlSession
负责执行SQL （配合指定资源Mapped Statement）执行器Executor

正常来说项目只对应一套数据库环境，一般对应一个SqlSessionFactory实例对象，我们使用单例模式只创建一个SqlSessionFactory实例。
如果需要配置多套数据库环境，那需要做一些拓展，例如Mybatis中通过environments等配置就可以支持多套测试/生产数据库环境进行切换。

项目使用端

  1. 调用框架API，除了引入自定义持久层框架的jar包。
  2. 提供两部分配置信息。
    1. mybatis-config.xml：数据库配置信息(地址/数据名/用户名/密码)，以及mapper.xml的全路经。
    2. mapper.xml : SQL配置信息，存放SQL语句、参数类型、返回值类型相关信息。

自定义框架本身

  1. 加载配置文件：根据配置文件的路径，加载配置文件成字节输入流，存储在内存中。

image-20210811180809813.png

  1. 创建两个javaBean（容器对象）：存放配置文件解析出来的内容。

image-20210811180923884.png

  1. 解析配置文件（使用dom4j），并创建SqlSession会话对象。

image-20210811180948093.png

  1. 创建SqlSessionFactory接口以及实现类DefaultSqlSessionFactory。

image-20210811181025728.png

  1. 创建SqlSession接口以及实现类DefaultSqlSession。

image-20210811181045390.png

  1. 创建Executor接口以及实现类SimpleExecutor。

image-20210811181106435.png

基本过程我们已经清晰，我们再细化一下类图，更好的助于我们实际编码：
4.jpg

最终手写的持久层框架结构参考

自定义框架部分：
image.png
项目使用端：
image.png

编码

在使用端项目中创建配置配置文件
创建 mybatis-config.xml

<configuration>

  <!--1.配置数据库信息-->
  <dataSource>
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
    <property name="url"
      value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8&amp;allowPublicKeyRetrieval=true&amp;useSSL=false&amp;serverTimezone=Asia/Shanghai"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
  </dataSource>

  <!--2.引入映射配置文件-->
  <mappers>
    <mapper resource="com/aiz/mapper/UserMapper.xml"></mapper>
  </mappers>

</configuration>

mapper.xml

<mapper namespace="com.aiz.dao.IUserDao">

  <!--根据条件查询单个-->
  <select id="selectOne" resultType="com.aiz.pojo.User" parameterType="com.aiz.pojo.User">
    select * from t_user where id = #{id} and username = #{username}
  </select>

  <!--查询所有-->
  <select id="selectList" resultType="com.aiz.pojo.User">
    select * from t_user
  </select>
</mapper>

User实体

package com.aiz.pojo;

public class User {
    private Integer id;

    private String username;

    private String password;

    private Integer age;

    private String sex;

    private String email;

    public User() {
    }

    public User(Integer id, String username, String password, Integer age, String sex, String email) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
        this.sex = sex;
        this.email = email;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

再创建一个Maven子工程并且导入需要用到的依赖坐标。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.aiz.mybatis</groupId>
    <artifactId>mini-mybatis-xml</artifactId>
    <version>1.0-SNAPSHOT</version>
    <description>手写精简mybatis，解析XML版</description>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- mysql 依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>

        <!--junit 依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <!--作用域测试范围-->
            <scope>test</scope>
        </dependency>

        <!--dom4j 依赖-->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>

        <!--xpath 依赖-->
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>2.0.0</version>
        </dependency>


        <!--druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.16</version>
        </dependency>

        <!-- log日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>

</project>

Resources

package com.aiz.io;

import java.io.InputStream;

public class Resources {
    /**
     * 根据配置文件的路径，加载配置文件成字节输入流，存到内存中
     */
    public static InputStream getResourceAsStream(String path) {
        InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path);
        return resourceAsStream;
    }
}

Configuration

package com.aiz.pojo;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 * 全局配置类：存放核心配置文件解析出来的内容
 */
public class Configuration {

    /**
     * 数据源对象
     */
    private DataSource dataSource;
    /**
     * key:statementId:namespace.id   MappedStatement:封装好的MappedStatement对象
     */
    private Map<String, MappedStatement> mappedStatementMap = new HashMap();

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public Map<String, MappedStatement> getMappedStatementMap() {
        return mappedStatementMap;
    }

    public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) {
        this.mappedStatementMap = mappedStatementMap;
    }
}

MappedStatement

package com.aiz.pojo;

/**
 * 映射配置类：存放mapper.xml解析内容
 */
public class MappedStatement {

    /**
     * 唯一标识 statementId:namespace.id
     */
    private String statementId;
    /**
     * 返回值类型
     */
    private String resultType;
    /**
     * 参数值类型
     */
    private String parameterType;
    /**
     * sql语句
     */
    private String sql;
    /**
     * sqlCommandType ：判断当前是什么操作的一个属性
     */
    private String sqlCommandType;

    public String getSqlCommandType() {
        return sqlCommandType;
    }

    public void setSqlCommandType(String sqlCommandType) {
        this.sqlCommandType = sqlCommandType;
    }

    public String getStatementId() {
        return statementId;
    }

    public void setStatementId(String statementId) {
        this.statementId = statementId;
    }

    public String getResultType() {
        return resultType;
    }

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

    public String getParameterType() {
        return parameterType;
    }

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

    public String getSql() {
        return sql;
    }

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

SqlSessionFactoryBuilder

package com.aiz.session;

import com.aiz.config.XMLConfigBuilder;
import com.aiz.pojo.Configuration;
import org.dom4j.DocumentException;

import java.io.InputStream;

public class SqlSessionFactoryBuilder {
    /**
     * 1.解析配置文件，封装容器对象。
     * 2.创建SqlSessionFactory工厂对象
     */
    public SqlSessionFactory build(InputStream inputStream) throws DocumentException {

        // 1.解析配置文件，封装容器对象 XMLConfigBuilder:专门解析核心配置文件的解析类
        XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
        Configuration configuration =  xmlConfigBuilder.parse(inputStream);

        // 2.创建SqlSessionFactory工厂对象
        return new DefaultSqlSessionFactory(configuration);
    }
}

XMLConfigerBuilder

package com.aiz.config;

import com.aiz.io.Resources;
import com.aiz.pojo.Configuration;
import com.alibaba.druid.pool.DruidDataSource;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.List;
import java.util.Properties;

public class XMLConfigBuilder {

    private Configuration configuration;

    public XMLConfigBuilder() {
        this.configuration = new Configuration();
    }

    /**
     * 使用dom4j+xpath解析配置文件，封装Configuration对象
     *
     * @param inputStream
     * @return
     */
    public Configuration parse(InputStream inputStream) throws DocumentException {

        Document document = new SAXReader().read(inputStream);
        Element rootElement = document.getRootElement();

        List<Element> list = rootElement.selectNodes("//property");

        // <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        Properties properties = new Properties();
        for (Element element : list) {
            String name = element.attributeValue("name");
            String value = element.attributeValue("value");
            properties.setProperty(name, value);
        }

        // 创建数据源对象
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(properties.getProperty("driverClassName"));
        druidDataSource.setUrl(properties.getProperty("url"));
        druidDataSource.setUsername(properties.getProperty("username"));
        druidDataSource.setPassword(properties.getProperty("password"));

        // 创建好的数据源对象封装到Configuration对象中
        configuration.setDataSource(druidDataSource);

        //-----------解析映射配置文件----
        // 1.获取映射配置文件的路径 2.根据路径进行映射配置文件的加载解析 3.封装到MappedStatement--》configuration里面的map集合中
        // <mapper resource="com/aiz/mapper/UserMapper.xml"></mapper>
        List<Element> mapperList = rootElement.selectNodes("//mapper");
        for (Element element : mapperList) {
            String mapperPath = element.attributeValue("resource");
            InputStream resourceAsSteam = Resources.getResourceAsStream(mapperPath);
            // XMLMapperBuilder:专门解析映射配置文件的对象
            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
            xmlMapperBuilder.parse(resourceAsSteam);
        }
        return configuration;

    }
}

XMLMapperBuilder

package com.aiz.config;

import com.aiz.pojo.Configuration;
import com.aiz.pojo.MappedStatement;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.List;

/**
 * parse : 解析映射配置文件 --> mappedStatement --> configuration里面的map集合中
 */
public class XMLMapperBuilder {

    private Configuration configuration;

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

    public void parse(InputStream resourceAsSteam) throws DocumentException {

        Document document = new SAXReader().read(resourceAsSteam);
        Element rootElement = document.getRootElement();

        /**
         *  <select id="selectOne" resultType="com.aiz.pojo.User" parameterType="com.aiz.pojo.User">
         *         select * from user where id = #{id} and username = #{username}
         *    </select>
         */
        List<Element> selectList = rootElement.selectNodes("//select");
        String namespace = rootElement.attributeValue("namespace");
        for (Element element : selectList) {

            String id = element.attributeValue("id");
            String resultType = element.attributeValue("resultType");
            String parameterType = element.attributeValue("parameterType");
            String sql = element.getTextTrim();

            // 封装mappedStatement对象
            MappedStatement mappedStatement = new MappedStatement();

            // StatementId:namespace.id
            String statementId = namespace + "." + id;
            mappedStatement.setStatementId(statementId);
            mappedStatement.setResultType(resultType);
            mappedStatement.setParameterType(parameterType);
            mappedStatement.setSql(sql);
            mappedStatement.setSqlCommandType("select");

            // 将封装好的mappedStatement封装到configuration中的map集合中
            configuration.getMappedStatementMap().put(statementId, mappedStatement);

        }

    }
}

sqlSessionFactory 接口及DefaultSqlSessionFactory 实现类

package com.aiz.session;


public interface SqlSessionFactory {

    /**
     * 1.生产sqlSession对象。
     * 2.创建执行器对象。
     */
    SqlSession openSession();
}


package com.aiz.session;

import com.aiz.executor.Executor;
import com.aiz.executor.SimpleExecutor;
import com.aiz.pojo.Configuration;

public class DefaultSqlSessionFactory implements SqlSessionFactory {

    private Configuration configuration;

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

    @Override
    public SqlSession openSession() {
        // 1.创建执行器对象
        Executor simpleExecutor = new SimpleExecutor();

        // 2.生产sqlSession对象
        DefaultSqlSession defaultSqlSession = new DefaultSqlSession(configuration, simpleExecutor);

        return defaultSqlSession;
    }
}

sqlSession 接口及 DefaultSqlSession 实现类

package com.aiz.session;

import java.util.List;

public interface SqlSession {
    /**
     * 查询多个结果
     * sqlSession.selectList(); :定位到要执行的sql语句，从而执行
     * select * from user where username like '% ? %'
     */
    <E> List<E> selectList(String statementId, Object param) throws Exception;

    /**
     * 查询单个结果
     */
    <T> T selectOne(String statementId, Object param) throws Exception;

    /**
     * 清除资源
     */
    void close();

    /**
     * 生成代理对象
     */
    <T> T getMapper(Class<?> mapperClass);
}


package com.aiz.session;

import com.aiz.executor.Executor;
import com.aiz.pojo.Configuration;
import com.aiz.pojo.MappedStatement;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.util.List;

public class DefaultSqlSession implements SqlSession {

    private Configuration configuration;
    private Executor executor;

    public DefaultSqlSession(Configuration configuration, Executor executor) {
        this.configuration = configuration;
        this.executor = executor;
    }

    @Override                                        // user
    public <E> List<E> selectList(String statementId, Object param) throws Exception {
        // 将查询操作委派给底层的执行器
        // query(): 执行底层的JDBC 1.数据库配置信息 2.sql配置信息
        MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
        List<E> list = executor.query(configuration, mappedStatement, param);

        return list;
    }

    @Override
    public <T> T selectOne(String statementId, Object param) throws Exception {
        // 去调用selectList();
        List<Object> list = this.selectList(statementId, param);
        if (list.size() == 1) {
            return (T) list.get(0);
        } else if (list.size() > 1) {
            throw new RuntimeException("返回结果过多");
        } else {
            return null;
        }

    }
}

Executor

package com.aiz.executor;

import com.aiz.pojo.Configuration;
import com.aiz.pojo.MappedStatement;

import java.util.List;

public interface Executor {

    <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object param) throws Exception;

    void close();
}

SimpleExecutor

package com.aiz.executor;

import com.aiz.config.BoundSql;
import com.aiz.pojo.Configuration;
import com.aiz.pojo.MappedStatement;
import com.aiz.utils.GenericTokenParser;
import com.aiz.utils.ParameterMapping;
import com.aiz.utils.ParameterMappingTokenHandler;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class SimpleExecutor implements Executor {

    private Connection connection = null;
    private PreparedStatement preparedStatement = null;
    private ResultSet resultSet = null;

    @Override                                                                               // user
    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object param) throws Exception {

        // 1.加载驱动，获取数据库连接
        connection = configuration.getDataSource().getConnection();

        // 2.获取preparedStatement预编译对象
        // 获取要执行的sql语句
        /*      自定义的占位符
                select * from user where id = #{id} and username = #{username}
         替换：  select * from user where id = ? and username = ?
                解析替换的过程中：#{id}里面的值保存下来
         */
        String sql = mappedStatement.getSql();
        BoundSql boundSql = getBoundSql(sql);
        String finalSql = boundSql.getFinalSql();
        preparedStatement = connection.prepareStatement(finalSql);

        // 3.设置参数
        // com.aiz.pojo.User
        String parameterType = mappedStatement.getParameterType();

        if (parameterType != null) {
            Class<?> parameterTypeClass = Class.forName(parameterType);

            List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
            for (int i = 0; i < parameterMappingList.size(); i++) {

                ParameterMapping parameterMapping = parameterMappingList.get(i);
                // id || username
                String paramName = parameterMapping.getContent();
                // 反射
                Field declaredField = parameterTypeClass.getDeclaredField(paramName);
                // 暴力访问
                declaredField.setAccessible(true);

                Object value = declaredField.get(param);
                // 赋值占位符
                preparedStatement.setObject(i + 1, value);
            }

        }

        // 4.执行sql,发起查询
        resultSet = preparedStatement.executeQuery();

        // 5.处理返回结果集
        ArrayList<E> list = new ArrayList<>();
        while (resultSet.next()) {
            // 元数据信息 包含了 字段名  字段的值
            ResultSetMetaData metaData = resultSet.getMetaData();

            // com.aiz.pojo.User
            String resultType = mappedStatement.getResultType();
            Class<?> resultTypeClass = Class.forName(resultType);
            Object o = resultTypeClass.newInstance();

            for (int i = 1; i <= metaData.getColumnCount(); i++) {

                // 字段名 id  username
                String columnName = metaData.getColumnName(i);
                // 字段的值
                Object value = resultSet.getObject(columnName);

                // 问题：现在要封装到哪一个实体中
                // 封装
                // 属性描述器：通过API方法获取某个属性的读写方法
                PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass);
                Method writeMethod = propertyDescriptor.getWriteMethod();
                // 参数1：实例对象 参数2：要设置的值
                writeMethod.invoke(o, value);
            }
            list.add((E) o);

        }

        return list;
    }

    /**
     * 1.#{}占位符替换成？  2.解析替换的过程中 将#{}里面的值保存下来
     */
    private BoundSql getBoundSql(String sql) {

        // 1.创建标记处理器：配合标记解析器完成标记的处理解析工作
        ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
        // 2.创建标记解析器
        GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);

        // #{}占位符替换成？ 2.解析替换的过程中 将#{}里面的值保存下来 ParameterMapping
        String finalSql = genericTokenParser.parse(sql);

        // #{}里面的值的一个集合 id username
        List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();

        BoundSql boundSql = new BoundSql(finalSql, parameterMappings);

        return boundSql;
    }


    /**
     * 释放资源
     */
    @Override
    public void close() {
        // 释放资源
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (preparedStatement != null) {
            try {
                preparedStatement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }


    }
}

BoundSql

package com.aiz.config;

import com.aiz.utils.ParameterMapping;

import java.util.List;

public class BoundSql {

    private String finalSql;

    private List<ParameterMapping> parameterMappingList;

    public BoundSql(String finalSql, List<ParameterMapping> parameterMappingList) {
        this.finalSql = finalSql;
        this.parameterMappingList = parameterMappingList;
    }

    public String getFinalSql() {
        return finalSql;
    }

    public void setFinalSql(String finalSql) {
        this.finalSql = finalSql;
    }

    public List<ParameterMapping> getParameterMappingList() {
        return parameterMappingList;
    }

    public void setParameterMappingList(List<ParameterMapping> parameterMappingList) {
        this.parameterMappingList = parameterMappingList;
    }
}

编码优化

通过上述我们的自定义框架，我们解决了JDBC操作数据库带来的一些问题：例如频繁创建释放数据库连 接，硬编码，手动封装返回结果集等问题，但是现在我们继续来分析刚刚完成的自定义框架代码，有没有什么问题？
问题如下：

  • dao的实现类中存在重复的代码，整个操作的过程模板重复(创建sqlsession,调用sqlsession方法，关闭 sqlsession)
  • dao的实现类中存在硬编码，调用sqlsession的方法时，参数statement的id硬编码。

解决：使用代理模式来创建接口的代理对象。

在sqlSession中添加方法

public interface SqlSession {
   public <T> T getMappper(Class<?> mapperClass);
}

实现类

package com.aiz.session;

import com.aiz.executor.Executor;
import com.aiz.pojo.Configuration;
import com.aiz.pojo.MappedStatement;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.util.List;

public class DefaultSqlSession implements SqlSession {

    private Configuration configuration;
    private Executor executor;

    public DefaultSqlSession(Configuration configuration, Executor executor) {
        this.configuration = configuration;
        this.executor = executor;
    }

    @Override
    public void close() {
        executor.close();
    }

    @SuppressWarnings("all")
    @Override
    public <T> T getMapper(Class<?> mapperClass) {

        // 使用JDK动态代理生成基于接口的代理对象
        Object proxy = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{mapperClass}, new InvocationHandler() {
            /*
                Object：代理对象的引用，很少用
                Method：被调用的方法的字节码对象
                Object[]：调用的方法的参数
             */
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                // 具体的逻辑 ：执行底层的JDBC
                // 通过调用sqlSession里面的方法来完成方法调用
                // 参数的准备：1.statementId: com.aiz.dao.IUserDao.findAll  2.param
                // 问题1：无法获取现有的statementId
                // findAll
                String methodName = method.getName();
                // com.aiz.dao.IUserDao
                String className = method.getDeclaringClass().getName();
                String statementId = className + "." + methodName;

                // 方法调用：问题2：要调用sqlSession中增删改查的什么方法呢？
                // 改造当前工程：sqlCommandType
                MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
                // select  update delete insert
                String sqlCommandType = mappedStatement.getSqlCommandType();
                switch (sqlCommandType) {
                    case "select":
                        // 执行查询方法调用
                        // 问题3：该调用selectList还是selectOne?
                        Type genericReturnType = method.getGenericReturnType();
                        // 判断是否实现了 泛型类型参数化
                        if (genericReturnType instanceof ParameterizedType) {
                            if (objects != null) {
                                return selectList(statementId, objects[0]);
                            }
                            return selectList(statementId, null);
                        }
                        return selectOne(statementId, objects[0]);

                    case "update":
                        // 执行更新方法调用
                        break;
                    case "delete":
                        // 执行delete方法调用
                        break;
                    case "insert":
                        // 执行insert方法调用
                        break;

                }
                return null;
            }
        });
        return (T) proxy;
    }
}

使用端测试代码

package com.aiz.test;


import com.aiz.dao.IUserDao;
import com.aiz.io.Resources;
import com.aiz.pojo.User;
import com.aiz.session.SqlSession;
import com.aiz.session.SqlSessionFactory;
import com.aiz.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;

public class MiniMybatisTest {

    /**
     * 传统方式（不使用mapper代理）测试
     */
    @Test
    public void test1() throws Exception {

        // 1.根据配置文件的路径，加载成字节输入流，存到内存中 注意：配置文件还未解析
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");

        // 2.解析了配置文件，封装了Configuration对象  2.创建sqlSessionFactory工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

        // 3.生产sqlSession 创建了执行器对象
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 4.调用sqlSession方法
        User user = new User();
        user.setId(1);
        user.setUsername("赵六");
        /*User user2 = sqlSession.selectOne("com.aiz.dao.IUserDao.findByCondition", user);
        System.out.println(user2);*/
        List<User> list = sqlSession.selectList("com.aiz.dao.IUserDao.findAll", null);
        for (User user1 : list) {
            System.out.println(user1);
        }

        // 5.释放资源
        sqlSession.close();
    }

    /**
     * mapper代理测试
     */
    @Test
    public void test2() throws Exception {

        // 1.根据配置文件的路径，加载成字节输入流，存到内存中 注意：配置文件还未解析
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");

        // 2.解析了配置文件，封装了Configuration对象  2.创建sqlSessionFactory工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

        // 3.生产sqlSession 创建了执行器对象
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 4.调用sqlSession方法
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);

        /*User user1 = new User();
        user1.setId(1);
        user1.setUsername("赵六");
        User user3 = userDao.findByCondition(user1);
        System.out.println(user3);*/
        List<User> all = userDao.findAll();
        all.stream().forEach(System.out::println);

        // 5.释放资源
        sqlSession.close();
    }
}

参考资料

B站视频xml版+13小时手撕源码

GitHub代码地址！！！

耀耀zz
关注
专栏目录
我的架构梦：（一）手写MyBatis框架
riemann_的博客
05-24 1381
手写mybatis框架一、前言二、JDBC问题分析三、自定义框架实现四、自定义框架优化五、代码仓库 一、前言 在手写mybatis框架之前 ，我们先来思考一下这个问题：为啥要有mybatis框架存在？它是为了解决什么问题的？我们带着这两个问题来开始我们手写mybatis框架之旅。 我们刚开始搞java的时候，貌似都知道用jdbc去连接数据库，那我们来看一下jdbc连接数据库的代码： public static void main(String[] args) { Connection conn =
MyBatis之手写简易MyBatis
RubinChu的博客
01-11 474
本博文详细阐述了笔者在手写一个简易版本的MyBatis框架的涉及以及实现过程
自己手写一个Mybatis框架
u014368614的博客
02-14 291
  继上一篇手写SpringMVC之后，我最近趁热打铁，研究了一下Mybatis。MyBatis框架的核心功能其实不难，无非就是动态代理和jdbc的操作，难的是写出来可扩展，高内聚，低耦合的规范的代码。本文完成的Mybatis功能比较简单，代码还有许多需要改进的地方，大家可以结合Mybatis源码去动手完善。 一、Mybatis框架流程简介 在手写自己的Mybatis框架之前，我们先...
MyBatis入门（手写框架）
最新发布
Dr_RR的博客
08-21 777
在看完老杜的mybatis手写框架之后也对mybatis底层运行逻辑有了更深的了解，在这里我仅做mybatis快速入门以及手撕mybatis框架的详细步骤，其他的关于mybatis框架使用规则及技巧会在后期的文章中写。
手写简单的mybatis框架
a123123sdf的博客
12-06 683
mybatis的核心是通过解析核心配置xml（获取数据源、存放mapper.xml文件的路径 ），根据mapper.xml路径解析出sql的类型（crud哪一种）、返回值类型(结果集是什么类型的)、参数类型（带不带参数就行sql操作）这些东西存放在一个Configuration 类里面（用一个map保存key为：接口全限定名.方法名。）。最后利用动态代理（jdk）去生成一个代理对象。代理对象根据Configuration类里面的存放的sql信息，利用jdbc操作数据库。
四，手写自己的MyBatis框架
javacoo的专栏
12-31 855
1.MyBatis应用分析与实践 2.MyBatis体系结构与工作原理 3.MyBatis插件原理及Spring集成 4.手写自己的MyBatis框架 本节目标： 1、 实现 1.0 版本，掌握 MyBatis 的本质、核心功能、核心对象、执行流程 2、 通过分析 2.0 版本，体验框架的演进过程，理解 MyBatis 一，需求分析 假如你在一家软件公司的研发部工作，有一天技术总监老王想让你负责开发一个项 目，你要做的第一件事情是什么？ 确定需求。 那我们要开发这个项目，需求从哪里来？ 我们要跟老王沟通
手写MyBatis框架
飓风的博客
03-25 1788
原生JDBC及手写Mybatis框架流程介绍
手写简易版ORM框架（仿mybatis）
08-21
在这个简易版ORM框架中，我们模仿了著名的MyBatis框架，旨在简化数据库操作，提高开发效率。 在手写这个框架的过程中，我们可以理解以下核心概念和知识点： 1. **数据访问层（DAL，Data Access Layer）**：ORM框架...
手写简易mybatis
03-06
【标题】"手写简易mybatis"涉及到的知识点主要涵盖了MyBatis框架的核心概念和实现原理，这包括了配置文件解析、SQL会话管理、Mapper注解以及动态代理技术的应用。下面将对这些主题进行详细阐述。 首先，**配置文件...
手写简易Mybatis框架教程
资源摘要信息:"本项目标题为‘简易Mybatis’，是一个尝试理解和复现Mybatis核心机制...同时，亲手实现一个简化版的Mybatis，也有助于理解框架设计的哲学和实现的细节，为未来开发更为复杂的持久层框架打下坚实的基础。
从0开始手写一个Mybatis框架.docx
06-22
构建一个简易版的MyBatis框架不仅有助于深入理解其内部工作机制，还能够提高对Java反射、动态代理和数据库连接池管理等技术的理解。虽然本文介绍的实现较为基础，但它为扩展更复杂的功能打下了坚实的基础。对于初学...
自己动手写MyBatis框架项目源代码
01-26
自己动手写基于Spring Boot的注解版MyBatis框架项目源代码，更多详情请查看相关博客：https://blog.csdn.net/qq_31142553/article/details/86655951
Mybatis手写框架
weixin_50999696的博客
07-31 570
Mybatis是一个半ORM（对象关系映射）框架，它内部封装了JDBC，开发时只需要关注SQL语句本身，不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。程序员直接编写原生态sql，可以严格控制sql执行性能，灵活度高。
手写一个mybatis框架
Imciandy的博客
09-05 182
手写mybatis框架 simple-ibatis 前言： 很久没有更新mybatis的源码解析了，因为最近在将自己所理解的mybatis思想转为实践。 在学习mybatis的源码过程中，根据mybatis的思想自己构建了一个ORM框架 。整个代码都是自己手动构造，没有一句代码是Copy，肯定不如谷歌大神那样的代码，但已基本实现了SQL语句的实现和对象关系映射功能。若对源码感兴趣，可加入我一起写这个项目。后文会附带地址，若觉得不错，希望手动star下哦！ 项目地址：simple-ibatis 项目简介： s
自己动手写MyBatis框架
周先生丶的博客
01-26 1742
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。 至于怎么使用，源码分析就不讲了，来直接实...
手写mybatis框架
weixin_45596022的博客
02-14 193
我这个需求的底层逻辑是什么？顶层设计在哪？最终交付价值是什么？过程的抓手在哪里？如何保证结果的闭环？我比别人的亮点在哪里？优势在哪里？我的思考和沉淀在哪里？我有形成自己的方法论么？我这个需求换别人来写是否会一样？我是如何做到对齐拉通的？我是如何赋能的？ 一，需求分析 1）它需要实现对连接资源的自动管理，也就是把创建 Connection、Statement、关闭 Connection、Statement、ResultSet 这些操作封装到底层的对象中，不需要在应用层手动调用。 2）它需要把 SQL 语句抽离
手写Mybatis框架
lov3r的博客
12-16 110
分析JDBC操作问题 问题总结 数据库连接创建、释放频繁造成系统资源浪费，从而影响系统性能。 Sql语句在代码中硬编码，造成代码不易维护，实际应用中sql变化的可能较大，sql变动需要改变 java代码。 使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能 多也可能少，修改sql还要修改代码，系统不易维护。 对结果集解析存在硬编码(查询列名)，sql变化导致解析代码变化，系统不易维护，如果能将数据 库 记录封装成pojo对象解析比较方便 解决
手写一个简单的mybatis框架
hongtaolong的博客
02-27 1041
前言： mysql作为优秀的开源框架之一，作为一个高级java程序员不仅仅学会使用它，更应该学习它的源码、设计、思想。经过前面对mybatis的流程的学习，今天分享一下如何自己实现一个简单的mybatis框架。当然由于技术和时间的限制，本文在这里实现的一个简化版本的mybatis，相对来说只是mybatis本身框架的冰山一角，但是整体的流程以及设计的思想都是和mybatis一样的，个人觉得对我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

耀耀zz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值