MyBatis笔记Day01_Mybatis原理_自定义Mybatis_XML方式

最新推荐文章于 2024-07-31 13:39:45 发布

ZM つ小灰灰的成长

最新推荐文章于 2024-07-31 13:39:45 发布

阅读量1.4k

点赞数 1

分类专栏： mybatis 文章标签：数据库 mybatis java mysql

本文链接：https://blog.csdn.net/weixin_44832837/article/details/106194503

版权

mybatis 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、Mybatis自定义概述

1. 学习目标

首先明确，学习自定义Mybatis是为了更好的理解Mybatis的工作过程及实现原理，而不是真的为了实现一个Mybatis框架。
首先还是从Mybatis的入门案例开始（入门案例在我的另一篇博客MyBatis笔记Day01_入门案例）

2. 简单分析

2.1入门案例中的测试类

public static void main(String[] args) throws IOException {
        // 1. 读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 2. 创建一个SqlSessionFactory工厂,SqlSessionFactory是接口，不能new,因此要使用建造者创建工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        // 3. 使用工厂生产一个SqlSession对象（不改变代码的情况下对已有功能增强）
        SqlSession sqlSession = factory.openSession();
        // 4. 使用SqlSession创建代理对象（代理模式）
        IUserDao mapper = sqlSession.getMapper(IUserDao.class);
        // 5. 使用代理对象执行方法
        List<User> users = mapper.findAll();
        for (User user : users) {
            System.out.println(user);
        }
        // 6. 释放资源
        sqlSession.close();
        in.close();
    }

通过观察测试类，可以发现Mybatis从开始到结束，总共经历了六个步骤：

读取配置文件得到输入流对象in
创建一个SqlSessionFactoryBuilder对象builder，并使用这个对象创建一个SqlSessionFactory工厂对象factory
使用factory对象生产SqlSesson对象sqlSession
使用sqlSession对象创建代理对象mapper
使用代理对象mapper执行方法获得结果集users
释放资源sqlSession和in

2.2 类与类之间的关系

在这里插入图片描述

二、Mybatis自定义的实现

下面开始对这些步骤进行逐步分析

1、读取配置文件

目的：获取主配置文件的输入流in。
方法：使用类加载器进行获取。
在这里，对使用类加载器获取主配置文件输入流进行了简单的封装，没有什么复杂的操作。

package cn.snowing.mybatis.io;

import java.io.InputStream;

/**
 * 使用类加载器读取配置文件
 */
public class Resources {
    /**
     * 根据传入的参数获取一个字节输入流
     * @param filePath
     * @return InputStream
     */
    public static InputStream getResourceAsStream(String filePath){
        return Resources.class.getClassLoader().getResourceAsStream(filePath);
    }
}

2、SqlSessionFactoryBuilder类

目的：使用SqlSessionFactoryBuilder类生产SqlSessionFactory
方法：通过分析测试类，可以发现SqlSessionFactoryBuilder类有一个build()方法，该方法参数是InputStream类型的变量，实参就是上一步中获取到是主配置文件的输入流in，获取到主配置文件输入流之后，发现输入流并不能够直接使用，因此需要对输入流对象in进行解析，并且封装到Configuration对象cfg。然后再生产出SqlSessionFactory工厂。

public SqlSessionFactory build(InputStream config){
        Configuration cfg = XMLConfigBuilder.loadConfiguration(config);
        return new DefaultSqlSessionFactory(cfg);
    }

上面是SqlSessionFactory的build方法。然而，可以发现，并不存在Configuration和XMLConfigBuilder类，因此需要新建Configuration和XMLConfigBuilder类。对于如何解析xml这里不再描述。
先观察一下主配置文件SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!-- 配置环境   -->
    <environments default="mysql">
<!--   配置mysql的环境     -->
        <environment id="mysql">
            <!--配置事务类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源，也称连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="811236"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 指定映射配制文件的路径，映射配置文件指的是每个dao对应的配置文件 -->
    <mappers>
        <mapper resource="cn/snowing/dao/IUserDao.xml"/>
    </mappers>
</configuration>

根据主配置文件得到的Configuration类

package cn.snowing.mybatis.cfg;

import java.util.HashMap;
import java.util.Map;

/**
 * Configuration用于封装解析后的XML配置文件
 */
public class Configuration {
    private String driver;
    private String url;
    private String username;
    private String password;
    private Map<String, Mapper> mappers =  new HashMap<String, Mapper>(); // 保证可以使用putAll()方法而不报空指针异常

    public void setMappers(Map<String, Mapper> mappers) {
        this.mappers.putAll(mappers); //使用putAll()方式向mapper中添加元素，避免后面的mappers被覆盖掉
    }
}

Configuration类存在的价值就是对主配置文件解析结果的封装，因此，可以发现，Configuration类的发生同主配置文件的发生存在着关联。这里隐去了其它的setter/getter方法，只保留了setMapper()方法，因为这个方法很特殊，其不能像其它setter方法一个直接使用this.xxx = xxx进行赋值操作，因为主配置文件中的<mappers>标签下可能有多个<mapper>元素，如果直接赋值前面的<mapper>会被覆盖掉。

3、SqlSessionFactory

目的：生产SqlSession对象sqlSession，基于面向接口编程的思想，这里的SqlSessionFactory应当是一个接口而不是实现类。
方法：通过分析测试类，SqlSessionFactory中应当有一个openSession()方法用以获取sqlSession对象。有了这个接口之后，开始编写它的实现类DefaultSqlSessionFactory，这个实现类的编写也不难，因为其是工厂，工厂就要生产产品，对于这个工厂来说，它要生产的产品就是sqlSession对象，而方法就是其接口中定义的方法openSessiom()，那么这个方法如何实现呢？先看代码

package cn.snowing.mybatis.sqlsession.defaults;

import cn.snowing.mybatis.cfg.Configuration;
import cn.snowing.mybatis.sqlsession.SqlSession;
import cn.snowing.mybatis.sqlsession.SqlSessionFactory;

/**
 * SqlSessionFactory接口的实现类
 */
public class DefaultSqlSessionFactory implements SqlSessionFactory {
    private Configuration cfg;
    public DefaultSqlSessionFactory(Configuration cfg) {
        this.cfg = cfg;
    }
    /**
     * 用于创建一个新的操作数据库对象
     * @return
     */
    public SqlSession openSession() {
        return new DefaultSqlSession(cfg);
    }
}

所谓生产产品，其实就是new一个类的对象，在这里，也就是new一个SqlSession的对象，那么问题又来了，SqlSession应该是一个接口，不能new，因此，还要写一个SqlSession的实现类DefaultSqlSession。此外对于产品SqlSession的对象sqlSession来说，其应当包含配置信息configuration，因此，还要向其传递已经封装好的Configuration参数cfg。

4、SqlSession

目的：获取dao接口的代理对象mapper，并且在执行完成后可以释放资源。
方法：如何获取dao接口的代理对象呢？这里利用的是java的反射。首先，基于面向接口编程的思想，先定义一个SqlSession接口

package cn.snowing.mybatis.sqlsession;

/**
 * 与数据库交互的核心接口
 * 可以创建dao接口的代理对象
 */
public interface SqlSession {
    /**
     * 根据参数创建一个dao代理对象
     * @param daoInterfaceClass dao接口的字节码
     * @param <T>
     * @return
     */
    <T> T getMapper(Class<T> daoInterfaceClass);

    /**
     * 释放资源
     */
    void close();
}

然后再编写其实现类DefaultSqlSession。通过前面的分析，可以发现，这个类要实现两个功能，一个是创建代理对象，一个是释放资源。首先要实现的是代理对象的创建。目前，关于代理对象，已知的是其接口的字节码文件。因此，可以通过其接口的字节码文件利用Java代理（Proxy）来实现代理对象的创建，并通过实现InvocationHandler接口实现对代理对象功能的增强。

package cn.snowing.mybatis.sqlsession.defaults;

import cn.snowing.mybatis.cfg.Configuration;
import cn.snowing.mybatis.proxy.MapperProxy;
import cn.snowing.mybatis.sqlsession.SqlSession;
import cn.snowing.mybatis.utils.DataSourceUtil;

import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * SqlSession的实现类
 */
public class DefaultSqlSession implements SqlSession {
    private Configuration cfg;
    private Connection connection;
    public DefaultSqlSession (Configuration cfg) {
        this.cfg = cfg;
        connection = DataSourceUtil.getConnection(cfg);
    }
    /**
     * 创建代理对象
     * @param daoInterfaceClass dao接口的字节码
     * @param <T>
     * @return
     */
    public <T> T getMapper(Class<T> daoInterfaceClass) {

        return (T)Proxy.newProxyInstance(daoInterfaceClass.getClassLoader(), new Class[]{daoInterfaceClass}
        , new MapperProxy(cfg.getMappers(), connection));
    }

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

具体实现时，使用了Proxy 的静态工厂方法 newProxyInstance 创建动态代理类实例。

public static Object newProxyInstance(
		ClassLoader loader
		,Class<?>[] interfaces
		,InvocationHandler h) ;

这里有三个参数：

loader : 类加载器，这里可以通过参数中的Class类型的对象daoInterfaceClass调用getClassLoader()方法来获取类加载器。
interfaces ：实现的全部接口，这里的代理对象只实现了IUserDao接口，也就是参数中的daoInterfaceClass
h ：处理器，处理器实现代理对象的增强。
通过分析，前两个参数都可以通过参数daoInterfaceClass获取，而第三个参数h目前还没有。因此，需要创建一个InvocationHandler对象，而InvocationHandler是并不是一个类，而是接口，因此创建一个InvocationHandler的实现类MapperProxy来对代理对象增强。

package cn.snowing.mybatis.proxy;

import cn.snowing.mybatis.cfg.Mapper;
import cn.snowing.mybatis.utils.Executor;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.util.Map;

public class MapperProxy implements InvocationHandler {
    // mapper的key是全限定类名+方法名
    private Map<String, Mapper> mappers;
    private Connection conn;
    public MapperProxy(Map<String, Mapper> mappers, Connection conn){
        this.mappers = mappers;
        this.conn = conn;
    }
    /**
     * 用于对方法进行增强，对于这个例子，就是调用selectList()方法
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 获取方法名
        String methodName = method.getName();
        // 获取类名
        String className = method.getDeclaringClass().getName();
        // 组合key
        String key = className + '.' + methodName;
        Mapper mapper = mappers.get(key);
        if (mapper == null){
            throw new IllegalArgumentException("传入的参数有误！");
        }

        return new Executor().selectList(mapper, conn);
    }
}

因为要使用代理对象操作数据库，因此必须有一个Connection对象以获取连接，然而问题出现了，之前并没有提到Connection对象，那Connection对象从哪里来呢？可以直接在MapperProxy类中直接创建一个吗？答案是可以的。但是之前提到过，SqlSession需要释放资源，那么这个资源是什么呢？其实就是Connection对象。因此，将Connection对象定义在SqlSession实现类DefaultSqlSession中更加的合理。因此，在DefaultSqlSession声明Connection对象connection并使用工具类获取Connection对象。关于获取Connection对象的工具类，这里直接提供代码

package cn.snowing.mybatis.utils;

import cn.snowing.mybatis.cfg.Configuration;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 * 用于创建数据库连接的工具类
 */
public class DataSourceUtil {
    /**
     * 获取连接
     * @param cfg
     * @return
     */
    public static Connection getConnection(Configuration cfg){
        try {
            Class.forName(cfg.getDriver());
            return DriverManager.getConnection(cfg.getUrl(),cfg.getUsername(),cfg.getPassword());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }
}

得到了connection对象之后，想要操作数据库，必须要有的还有一样东西，那就是sql语句和结果集对应的实体类对象。因此，需要一个Mapper类来封装，那么sql语句和结果集实体类从哪里来呢？答案是xml配置文件，也就是入门案例中的IUserDao.xml文件。至于解析，在解析主配置文件的时候已经一起做了。

package cn.snowing.mybatis.cfg;

import java.util.Map;

/**
 * 用于封装Sql执行结果的全限定类名
 */
public class Mapper {
    private String queryString;
    private String resultType;
}

当代理对象获取Connection连接对象和包含sql语句和结果集对应的实体类对象的Mapper集合后，就可以使用invoke()方法将其封装到代理对象中去。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 1.获取方法名
        String methodName = method.getName();
        // 2.获取类名
        String className = method.getDeclaringClass().getName();
        // 3.组合key
        String key = className + '.' + methodName;
        // 4.获取mapper中key对应的值
        Mapper mapper = mappers.get(key);
        if (mapper == null){
            throw new IllegalArgumentException("传入的参数有误！");
        }
        // 5.执行查询
        return new Executor().selectList(mapper, conn);
    }

关于这里的参数中的method，这里有一个不成熟的看法。

// 5. 使用代理对象执行方法
        List<User> users = mapper.findAll();

在测试类中，使用mapper对象调用findAll()方法，这里.操作符后的findAll就是method对象中name属性的值，因此

String methodName = method.getName();

得到的就是findAll()方法的名称findAll字符串。同样的代理类的全限定类名就可以通过String className = method.getDeclaringClass().getName();来获取。而这两者组合得到的key就是Mapper对象mappers中的键名。如此，就可以拿到mappers对象中调用方法对应的mapper，至此就得到了查询的sql语句和要封装的结果集实体。最后就是执行sql语句并封装结果的操作。

// 5.执行查询
return new Executor().selectList(mapper, conn);

然后这里又出现了一个新的类Executor可以发现，Executor类的静态方法selectList()方法执行了sql查询语句并将结果集返回。

至此，代理对象的创建以及其功能的增强都已实现。

5. 使用代理对象mapper执行方法获得结果集users

List<User> users = mapper.findAll();

6. 释放资源

sqlSession.close();
in.close();

ZM つ小灰灰的成长

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录