MyBatis底层原理实现（基于动态代理）

已于 2022-08-01 16:38:13 修改
阅读量796 收藏 7
点赞数 5
文章标签： mybatis java maven 经验分享 mysql
于 2022-07-30 01:07:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aliano217/article/details/126065427
版权

1.动态代理机制

基于InvocationHandler实现的动态代理（不了解的同学建议先去学习一下动态代理）

1.1大致步骤

1.获取配置文件config.xml
2.通过JDBC执行SQL，并通过开发者自定义的接口，生成动态代理对象
3.创建实现类

2.MyBatis的具体实现

1.项目结构

在这里插入图片描述
Test为主类
Book为对应数据库表的实体类
pom.xml文件在这里展示

<?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.example</groupId>
    <artifactId>mymybatis001</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>

        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>

        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>

    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>

        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

注意：plugins 那里可能会报红 可忽略
在这里插入图片描述

2.用到的数据库

MySQL+ DataGrip
实体表：
在这里插入图片描述在这里插入图片描述
这里要注意bookid要设置为自增

3.1主类Test

package com.aliano.test;

import com.aliano.entity.Book;
import com.aliano.mapper.BookMapper;
import java.util.List;

public class Test {
    public static void main(String[] args) throws Exception {
        MyBatisInvocationHandler handler = new MyBatisInvocationHandler();
        BookMapper mapper = (BookMapper) handler.bind(BookMapper.class);
        List<Book> list = mapper.list();
        for (Book book : list) {
            System.out.println(book);
        }
    }

}

3.2工具类MyBatisUtils

package com.aliano.test;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class MyBatisUtil {

    //定义数据库连接池
    private static ComboPooledDataSource dataSource = null;

    public static Connection getConnection(){
        Connection connection = null;
        try {
            //读取XML，获取配置信息
            Map<String, String> map = parseXML();
            //加载数据源
            loadDataSource(map);
            connection = dataSource.getConnection();
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }
        return connection;
    }

    public static void release(Connection connection, Statement statement, ResultSet resultSet){
        try {
            if(connection != null) connection.close();
            if(statement != null) statement.close();
            if(resultSet != null) resultSet.close();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    public static void loadDataSource(Map<String,String> map){
        try {
            dataSource = new ComboPooledDataSource();
            dataSource.setDriverClass(map.get("driver"));
            dataSource.setJdbcUrl(map.get("url"));
            dataSource.setUser(map.get("username"));
            dataSource.setPassword(map.get("password"));
            dataSource.setInitialPoolSize(5);
            dataSource.setMaxPoolSize(10);
            dataSource.setMinPoolSize(3);
            dataSource.setAcquireIncrement(5);
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }
    }

    public static Map<String,String> parseXML() throws Exception {
        Map<String,String> map = new HashMap<String, String>();
        //读取config.xml
        SAXReader saxReader = new SAXReader();
        Document document = saxReader.read("src/main/resources/config.xml");
        Element rootElement = document.getRootElement();
        Iterator<Element> iterator = rootElement.elementIterator();
        while (iterator.hasNext()) {
            Element next = iterator.next();
            if(next.getName().equals("environments")){
                Iterator<Element> iterator1 = next.elementIterator();
                while (iterator1.hasNext()) {
                    Element next1 = iterator1.next();
                    Iterator<Element> iterator2 = next1.elementIterator();
                    while (iterator2.hasNext()) {
                        Element next2 = iterator2.next();
                        if("dataSource".equals(next2.getName())){
                            Iterator<Element> iterator3 = next2.elementIterator();
                            while (iterator3.hasNext()) {
                                Element next3 = iterator3.next();
                                String name = next3.attributeValue("name");
                                String value = next3.attributeValue("value");
                                map.put(name, value);
                            }
                        }
                    }
                }
            }
        }
        return map;
    }

}

这一块是难点所在 既有JDBC连接的实现还有配置文件的读取。
步骤是先读取项目xml文件里的配置， 即：
1.用parseXML获取config.xml文件的配置
config.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!-- MyBatis环境 -->
    <environments default="dev">
        <environment id="dev">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test1"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="com/aliano/mapper/BookMapper.xml"/>
    </mappers>

</configuration>

在这里插入图片描述
由于这一段代码特别乱，建议初学者使用Dubug打断点的方式去理解。
这里是过程：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
接着就是对数据库连接池以及JDBC的配置：
在这里插入图片描述
在这里插入图片描述

3.3动态代理的实现类 MyBatisInvocationHandler

package com.aliano.test;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class MyBatisInvocationHandler implements InvocationHandler {

    public Object bind(Class cls){
        return Proxy.newProxyInstance(
                MyBatisInvocationHandler.class.getClassLoader(),
                new Class[]{cls},
                this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //获取数据源
        List list = new ArrayList();
        Connection connection = MyBatisUtil.getConnection();
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        SAXReader reader = new SAXReader();
        Document document = reader.read("src/main/java/com/aliano/mapper/BookMapper.xml");
        Element rootElement = document.getRootElement();
        Iterator<Element> iterator = rootElement.elementIterator();
        while (iterator.hasNext()) {
            Element next = iterator.next();
            String name = method.getName();
            if (next.attributeValue("id").equals(name)) {
                String sql = next.getText();
                statement = connection.prepareStatement(sql);
                resultSet = statement.executeQuery();
                String resultType = next.attributeValue("resultType");
                //通过反射机制获取目标类
                Class<?> aClass = Class.forName(resultType);
                Field[] declaredFields = aClass.getDeclaredFields();
                while (resultSet.next()) {
                    Object instance = aClass.getConstructor(null).newInstance(null);
                    for (Field declaredField : declaredFields) {
                        Object value = null;
                        String methodName = "set"+declaredField.getName().substring(0, 1).toUpperCase()+declaredField.getName().substring(1);
                        Method declaredMethod = aClass.getDeclaredMethod(methodName, declaredField.getType());
                        switch (declaredField.getType().getName()){
                            case "java.lang.Integer":
                                value = resultSet.getInt(declaredField.getName());
                                declaredMethod.invoke(instance,(Integer)value);
                                break;
                            case "java.lang.String":
                                value = resultSet.getString(declaredField.getName());
                                declaredMethod.invoke(instance,(String)value);
                                break;
                            case "java.lang.Double":
                                value = resultSet.getDouble(declaredField.getName());
                                declaredMethod.invoke(instance,(Double)value);
                                break;
                        }
                    }
                    list.add(instance);
                }
                MyBatisUtil.release(connection, statement, resultSet);
            }
        }
        return list;
    }
}

在这里插入图片描述
List用来记录最后的返回对象。
这里接下里继续看三个文件：
Book 与数据表对应

package com.aliano.entity;

import lombok.Data;

@Data
public class Book {
    private Integer bookid;
    private String name;
    private Double price;
}

BookMapper.java 定义增删改查实现的接口 为反射准备

package com.aliano.mapper;

import com.aliano.entity.Book;
import java.util.List;

public interface BookMapper {
    public List<Book> list();
    public Book findById(Integer id);
    public void add(Book book);
    public void update(Book book);
    public void delete(Integer id);
}

BookMapper.xml 定义SQL语句的地方

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.aliano.mapper.BookMapper">

    <insert id="add">
        insert into book(name,price) values(#{name},#{price})
    </insert>

    <update id="update">
        update book set name = #{name},price = #{price} where bookid = #{bookid}
    </update>

    <delete id="delete">
        delete from book where bookid = #{id}
    </delete>

    <select id="list" resultType="com.aliano.entity.Book">
        select * from book
    </select>

    <select id="findById" resultType="com.aliano.entity.Book">
        select * from book where bookid = #{id}
    </select>

</mapper>

回到反射类
在这里插入图片描述
这里是利用传过来的接口 即Test类里的

MyBatisInvocationHandler handler = new MyBatisInvocationHandler();
BookMapper mapper = (BookMapper) handler.bind(BookMapper.class);

动态创建MyBatis的代理对象 参数是运行时类 从而获取方法 属性 以及类的参数等。
初始化JDBC的工作
在这里插入图片描述
这里我们以list方法为例
在这里插入图片描述
这一块同样是利用SAXReader来获取xml文件的内容，觉得比较乱的同学建议打断点去梳理。
紧接着就是通过反射机制来动态的获取本次调用方法的目标类。
在这里插入图片描述
通过resultType我们可以得知本次获取到的运行时类包括com.aliano.entity.Book
使用反射机制获取Book类里面的三个属性，记为declaredFields

Object instance = aClass.getConstructor(null).newInstance(null);

对当前Book类实现无参构造，实例化一个instance（即Book对象的实例化）

for (Field declaredField : declaredFields) {
      Object value = null;
      String methodName = "set"+declaredField.getName().substring(0, 1).toUpperCase()+declaredField.getName().substring(1);
      Method declaredMethod = aClass.getDeclaredMethod(methodName, declaredField.getType());
      switch (declaredField.getType().getName()){
            case "java.lang.Integer":
                 value = resultSet.getInt(declaredField.getName());
                 declaredMethod.invoke(instance,(Integer)value);
                 break;
            case "java.lang.String":
                 value = resultSet.getString(declaredField.getName());
                 declaredMethod.invoke(instance,(String)value);
                 break;
            case "java.lang.Double":
                 value = resultSet.getDouble(declaredField.getName());
                 declaredMethod.invoke(instance,(Double)value);
                  break;
 }
}

在这里插入图片描述这里是通过属性名来动态生成Setter 和 Getter 方法名 以及属性的类型
这里举例是Integer、String、Double（实际上肯定还有更多）
然后进switch：
在这里插入图片描述

value = resultSet.getInt(declaredField.getName());
value = resultSet.getString(declaredField.getName());
value = resultSet.getDouble(declaredField.getName());

分别获取结果集中bookid name price 对应的值 用value存储

declaredMethod.invoke(instance,(Integer)value);
declaredMethod.invoke(instance,(String)value);
declaredMethod.invoke(instance,(Double)value);

利用反射机制 实现三个值的set方法，完成赋值，最后通过for循环 依次将instance实例对象添加到list

list.add(instance);

最后不要忘记释放JDBC连接资源

MyBatisUtil.release(connection, statement, resultSet);

最后 返回主类
在这里插入图片描述
遍历得到结果：
在这里插入图片描述

3.总结

本文所用到的主要技术就是JDBC的实现，以及通过反射机制实现的动态代理。也算是进行一定程度的复习。
紧接着才是一些流程的封装和调用，整个动态的过程都离不开动态代理这一设计模式。需要对流程完成一定的梳理，然后进行粗实现，再去考虑代码的封装性，可复用性以及耦合性。
所有优秀的框架都离不开底层知识以及核心机制，MyBatis和Spring等优秀框架都是站在巨人的肩膀上完成的，没有什么真正难的框架，都是基于底层知识一层一层的叠加，一层一层的封装。一点一点的的积累吧。

Aliano217
关注
mybatis的底层实现原理
qq_22162093的博客
07-03 1316
最近发现自己对jdbc和mybatis底层实现了解很浅，特此写一篇关于mybatis的底层实现文章来增加自己的理解 在说mybatis底层实现之前，先看下几个基本的知识点 Mybatis之Sqlsession、Connection和Transaction解析关系与原理 ...
mybatis框架底层原理分析（会话工厂和缓存机制）附详细代码示例
m0_48717384的博客
10-18 487
sqlsession会话底层创建过程以及debug跟踪mybatis一级缓存和二级缓存的底层实现原理
Mybatis实现动态代理,动态SQL
09-07
Mybatis+JDBC实现的动态代理,动态SQL，步骤较为详细：1）接口绑定方案；2）实现查询：方法参数为多个基本类型；3）动态SQL；4）缓存
浅析MyBatis的动态代理原理
weixin_33724570的博客
05-09 235
原文博客地址: pjmike的博客 前言 一直以来都在使用MyBatis做持久化框架，也知道当我们定义XXXMapper接口类并利用它来做CRUD操作时，Mybatis是利用了动态代理的技术帮我们生成代理类。那么动态代理内部的实现细节到底是怎么的呀？XXXMapper.java类和XXXMapper.xml到底是如何关联起来的呀？本篇文章就来详细剖析下MyBatis的动态代理的具体实现机制。 ...
深入探索MyBatis的动态代理模式
最新发布
m0_71752625的博客
08-18 1067
动态代理是一种设计模式，它在运行时创建代理对象，以控制对某个对象的访问。MyBatis的动态代理模式允许开发者定义一个Mapper接口，而无需提供实现类。MyBatis会在运行时自动创建这个接口的代理对象，代理对象会拦截接口方法的调用，并执行相应的数据库操作。// 更多数据库操作方法...
Mybatis动态代理的原理详解
tsxiong123的博客
07-24 1419
1.MyBatis简介 MyBatis是一个ORM工具，通过声明查询接口，工具实现接口的查询。 1.引入依赖 采用Maven包依赖管理，mybatis-3.5.5版本；同时需要数据库连接驱动 <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.5</version>
MyBatis动态代理原理
傅红雪的专栏
02-20 3373
1. MyBatis核心组件 在详细探究MyBatis中动态代理机制之前，先来补充一下基础知识，认识一下MyBatis的核心组件。 SqlSessionFactoryBuilder(构造器)： 它可以从XML、注解或者手动配置Java代码来创建SqlSessionFactory。 SqlSessionFactory: 用于创建SqlSession (会话) 的工厂 SqlSession: ...
MyBatis中的动态代理
m0_56336875的博客
07-04 987
MyBatis
mybatis 底层实现原理
08-24
- *1* *2* *3* [Mybatis底层原理实现](https://blog.csdn.net/weixin_60267819/article/details/120431486)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...
用中文介绍mybatis底层原理
03-31
总之，Mybatis的底层原理是基于Java反射机制和XML配置文件实现的，使用了很多设计模式，其中代理模式是其核心设计之一。通过这些机制，Mybatis实现了与数据库的交互，为开发人员提供了方便、高效的持久化解决方案。
mybatis框架入门之dao层动态代理实现---详细介绍
weixin_43880289的博客
10-30 621
mybatis框架入门之dao层动态代理实现—详细介绍 一、mybatis框架介绍 MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。它可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,即普通的Java对象)映射成数据库中的记录。 1. 优点 （1）简单易学：mybatis没有任何第三方依赖，只需要安装两个jar包和配置几个映射文件即可。 （2）使用灵活：mybatis不会对应用程
Mybatis mapper动态代理的原理解析
12-16
前言 在开始动态代理的原理讲解以前，我们先看一下集成mybatis以后dao层不使用动态代理以及使用动态代理的两种实现方式，通过对比我们自己实现dao层接口以及mybatis动态代理可以更加直观的展现出mybatis动态代理替我们所做的工作，有利于我们理解动态代理的过程，讲解完以后我们再进行动态代理的原理解析，此讲解基于mybatis的环境已经搭建完成，并且已经实现了基本的用户类编写以及用户类的Dao接口的声明，下面是Dao层的接口代码 public interface UserDao { /* 查询所有用户信息 */ List findAll(); /** *
mybatis——动态代理
mooonk的博客
07-09 310
一、动态代理实现CRUD 在开发项目中，我们可以通过接口快速的找到对应的方法，但是引入mybatis之后我们不要接口就可以实现数据库的连接以及数据操作，现在通过动态代理，在接口中写数据库操作的方法，对应的和接口名相同名称的xml文件中的数据操作相当于对接口中方法的实现。 作用过程 接口和xml文件必须在同一个包下，之后在mybatis.xml中可以直接通过包名来加载xml文件（前提是必须实现动态代理，必须有接口，接口名和xml文件名必须相同，xml文件中的mapper的namespace属性值必须为接口全
MyBatis之【动态代理】
weixin_48485216的博客
05-09 1357
一、代理模式 1、什么是代理模式 （1）目标对象不可访问，通过代理对象增强功能访问。 2、代理模式的作用 （1）控制目标对象的访问 （2）增强功能 3、代理模式的分类 （1）静态代理 （2）动态代理： ①JDK动态代理 ②CGLib动态代理 4、代理的实现方式 （1）静态代理实现 （2）动态代理的实现分为JDK动态代理和CGLib动态代理 二、静态代理 1、静态代理的特点 （1）目标对象和代理对象实现同一个业务接口 （2）目标对象必须实现接口 （3）代理对象在程序运行前就
绝对干货，超全的 MyBatis 动态代理原理讲解！
Java知音
12-12 331
点击关注公众号，实用技术文章及时了解1.MyBatis简介MyBatis是一个ORM工具，封装了JDBC的操作，简化业务编程；Mybatis在web工程中，与Spring集成，提供业务读写数据库的能力。2.使用步骤1.引入依赖采用Maven包依赖管理，mybatis-3.5.5版本；同时需要数据库连接驱动<dependency> <groupId>org.mybat...
绝对肝货，超全的 MyBatis 动态代理原理讲解。
m0_71777195的博客
12-24 1312
MyBatis是一个ORM工具，封装了JDBC的操作，简化业务编程；Mybatis在web工程中，与Spring集成，提供业务读写数据库的能力。定义实体}接口定义}定义映射文件
MyBatis原理之动态代理在MyBatis中的使用
微服务技术栈
08-26 636
在使用Mybatis时，我们有两种使用方式，第一种是直接通过SqlSession提供的select等方法进行操作数据库，传入的参数为Mapper.xml的Id和对应的参数，如下我们配置的mapper.xml并且根据该种方式查询。 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybati
mybatis动态代理原理初步解析
qq_33719894的博客
10-10 568
 为什么我们在调用一个未实现的方法能够执行定义的方法，就是因为mybatis用动态代理给我们实现了。 首先mybatis里面有一个实现InvocationHandler接口的类叫MapperProxy, 类里面有一个方法叫Mapperproxy.invoke();通过Proxy.newProxyInstance创建一个代理实例， 我们在写代码时用sqlSession.getMapper实现。...
Mybatis插件运行原理-动态代理
weixin_42595206的博客
06-07 398
Myabtis插件运行原理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值