跳至主要內容

手动实现MyBatis

LiAngJava2023年11月16日MyBatisJava大约 15 分钟约 2948 字

Mybatis 核心框架示意图

MyBatis整体架构分析
MyBatis整体架构分析

1. mybatis 的核心配置文件

​ mybatis-config.xml: 进行全局配置，全局只能有一个这样的配置文件

​ XxxMapper.xml 配置多个 SQL，可以有多个 XxxMappe.xml 配置文件

2.通过 mybatis-config.xml 配置文件得到 SqlSessionFactory

3.通过 SqlSessionFactory 得到 SqlSession，用 SqlSession 就可以操作数据了

4.SqlSession 底层是 Executor(执行器)，有两个重要的实现类，有很多方法

image-20220701095503103image-20220701095533054

5.MappedStatement 是通过 XxxMapper.xml 中定义，生成的 statement 对象。

6.参数输入执行并输出结果集，无需手动判断参数类型和参数下标位置，且自动将结果集 映射为 Java 对象

搭建开发环境

1.创建Maven项目

image-20220701095714197
image-20220701095714197
image-20220701095744182
image-20220701095744182

2.修改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>com.lzw</groupId>
    <artifactId>lzw-mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>

	<!--指定编译器版本-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <java.version>1.8</java.version>
    </properties>
    
    <!--引入必要的依赖-->
    <dependencies>
        <!--引入dom4j-->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <!--引入mysql依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>

        <!--lombok-简化entity/javabean/pojo开发-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

3.创建数据库和表

CREATE DATABASE `lzw_mybatis`;

CREATE TABLE `monster` (
`id` INT NOT NULL AUTO_INCREMENT, 
    `age` INT NOT NULL, 
    `birthday` DATE DEFAULT NULL, 
    `email` VARCHAR(255) NOT NULL, 
    `gender` TINYINT NOT NULL, 
    `name` VARCHAR(255) NOT NULL, 
    `salary` DOUBLE NOT NULL, 
    PRIMARY KEY (`id`)
)CHARSET=utf8

INSERT INTO `monster` VALUES(NULL, 200, '2000-11-11', 'nmw@sohu.com', 1, '牛魔王', 8888.88)
image-20220701100706487
image-20220701100706487

设计思路

手动实现Mybatis底层机制的设计
手动实现Mybatis底层机制的设计

传统方式操作数据库分析(第一种方式)

  1. 得到LzwSession对象。

  2. 调用LzwExecutor的方法完成操作。

  3. LzwExecutor的连接是从LzwConfiguration获取。

MyBatis操作数据库分析(第二种方式)

  1. 得到LzwSession对象。

  2. 不直接调用LzwExecutor的方法完成操作。

  3. 通过LzwMapperProxy获取Mapper对象。

  4. 调用Mapper的方法，完成数据库的操作。

  5. Mapper最终还是动态代理方式，使用LzwExecutor的方法完成操作。

  6. 这里麻烦的就是LzwMapperProxy的动态代理机制实现。

阶段1-完成读取配置文件，得到数据库连接

示意图

image-20220701101857451
image-20220701101857451

代码实现

创建 lzw_mybatis.xml

image-20220701110959973
image-20220701110959973
<?xml version="1.0" encoding="UTF-8" ?>
<database>
    <!--配置连接数据库的信息-->
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/lzw_mybatis?userSSL=true&amp;userUnicode=true&amp;characterEncoding=UTF-8"/>

    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</database>

创建 LzwConfiguration.java

package com.lzw.lzwmybatis.sqlsession;

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

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;

/**
 * @author LiAng
 */
public class LzwConfiguration {

    //属性-类的加载器
    private static ClassLoader loader = ClassLoader.getSystemClassLoader();

    //读取xml文件信息，并处理
    public Connection build(String resource) {

        Connection connection = null;
        try {
            //加载配置文件lzw_mybatis.xml 获取到对应的InputStream
            InputStream stream = loader.getResourceAsStream(resource);

            SAXReader reader = new SAXReader();
            Document document = reader.read(stream);
            Element root = document.getRootElement();
            System.out.println("root=" + root);
            //解析root元素，返回Connection => 单独的编写一个方法
            connection = evalDataSource(root);

        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }

    //方法会解析lzw_mybatis.xml 信息,并返回Connection
    private Connection evalDataSource(Element node) {
        if (!"database".equals(node.getName())) {
            throw new RuntimeException("root 节点应该是<database>");
        }
        //连接DB的必要参数
        String driverClassName = null;
        String url = null;
        String username = null;
        String password = null;

        //遍历node下的子节点，获取属性值
        for(Object item : node.elements("property")){
            Element i = (Element)item;
            String name = i.attributeValue("name");
            String value = i.attributeValue("value");

            if(name == null || value == null){
                throw new RuntimeException("property 节点没有设置name或者value属性");
            }
            switch (name) {
                case "url":
                    url = value;
                    break;
                case "username":
                    username = value;
                    break;
                case "driverClassName":
                    driverClassName = value;
                    break;
                case "password":
                    password = value;
                    break;
                default:
                    throw new RuntimeException("属性名没有匹配到...");
            }
        }

        Connection connection = null;
        try {
            Class.forName(driverClassName);
            connection = DriverManager.getConnection(url, username, password);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return connection;//返回Connection
    }

}

创建 LzwMyBatisTest.java

image-20220701112442767
image-20220701112442767
package com.lzw.test;

import com.lzw.lzwmybatis.sqlsession.LzwConfiguration;
import org.junit.Test;

import java.sql.Connection;

/**
 * @author LiAng
 */
public class LzwMyBatisTest {
    
    @Test
    public void build(){

        LzwConfiguration lzwConfiguration = new LzwConfiguration();
        Connection connection = lzwConfiguration.build("lzw_mybatis.xml");
        System.out.println(connection);
    }
}

完成测试

image-20220701112450235
image-20220701112450235

阶段2-编写执行器，输入 SQL 语句，完成操作

示意图

image-20220701112642389
image-20220701112642389

代码实现

创建 Monster.java

package com.lzw.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

/**
 * @author LiAng
 * Monster 和 monster表有映射关系
 * 使用到了 lombok的注解
 * @Getter 就会给所有属性 生成对应的getter
 * @Setter 就会给所有属性 生成对应的setter
 * @ToString 生成 toString...
 * @NoArgsConstructor 生成无参构造器
 * @AllArgsConstructor 生成要给全参构造器
 * @Data 注解
 * 如何选择主要还是看自己需要
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Monster {

    private Integer id;
    private Integer age;
    private String name;
    private String email;
    private Date birthday;
    private double salary;
    private Integer gender;
}

创建 Executor.java

package com.lzw.lzwmybatis.sqlsession;

/**
 * @author LiAng
 */
public interface Executor {
    public <T> T query(String statement, Object parameter);
}

先在IDEA中装个插件

image-20220701121338048
image-20220701121338048

安装完记得重启IDEA

创建 LzwExecutor.java

package com.lzw.lzwmybatis.sqlsession;

import com.lzw.entity.Monster;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

/**
 * @author LiAng
 */
public class LzwExecutor implements Executor {

    private LzwConfiguration lzwConfiguration = new LzwConfiguration();


    /**
     * 根据sql查询结果
     */
    @Override
    public <T> T query(String sql, Object parameter) {
        //得到连接
        Connection connection = getConnection();
        //查询返回的结果集
        ResultSet set = null;
        PreparedStatement pre = null;

        try {
            pre = connection.prepareStatement(sql);
            //设置参数, 如果参数多, 可以使用数组处理.
            pre.setString(1,parameter.toString());
            set = pre.executeQuery();
            //把set数据封装到对象-monster
            //这里做了简化处理
            //认为返回的结果就是一个monster记录
            //完善的写法是一套反射机制.-jdbc
            Monster monster = new Monster();

            //遍历结果集, 把数据封装到monster对象
            while (set.next()) {
                monster.setId(set.getInt("id"));
                monster.setName(set.getString("name"));
                monster.setEmail(set.getString("email"));
                monster.setAge(set.getInt("age"));
                monster.setGender(set.getInt("gender"));
                monster.setBirthday(set.getDate("birthday"));
                monster.setSalary(set.getDouble("salary"));
            }
            return (T)monster;

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (set != null) {
                    set.close();
                }
                if (pre != null) {
                    pre.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (Exception throwables) {
                throwables.printStackTrace();
            }
        }
        
        return null;
    }

    //编写方法,通过HspConfiguration对象，返回连接
    private Connection getConnection() {
        Connection connection = lzwConfiguration.build("lzw_mybatis.xml");
        return connection;
    }
}

修改 LzwMyBatisTest.java

	@Test
    public void query(){
        Executor executor = new LzwExecutor();
        Monster monster = executor.query("select * from monster where id = ?",1);
        System.out.println("monster ：" + monster);
    }

完成测试

image-20220701122122290
image-20220701122122290

阶段3-将 Sqlsession 封装到执行器

示意图

image-20220701143358918
image-20220701143358918

代码实现

创建 LzwSqlSession.java

package com.lzw.lzwmybatis.sqlsession;

/**
 * @author LiAng
 * @time 2022/7/1 14:35
 * LzwSqlSession 搭建Configuration（连接）和Executor之间桥梁
 * 这里有操作DB的方法
 */
public class LzwSqlSession {
    //属性
    //执行器
    private Executor executor = new LzwExecutor();
    //配置
    private LzwConfiguration lzwConfiguration = new LzwConfiguration();


    //编写方法 SelectOne 返回一条记录-对象[做了简化]
    //说明：在原生的MyBatis中 statement不是sql，而是要执行的接口方法
    public <T> T selectOne(String statement, Object parameter){
        return executor.query(statement, parameter);
    }
}

修改 LzwMyBatisTest.java

	@Test
    public void selectOne(){
        LzwSqlSession lzwSqlSession = new LzwSqlSession();
        Monster monster = lzwSqlSession.selectOne("select * from monster where id = ? ", 1);
        System.out.println("selectOne() monster ：" + monster);
    }

完成测试

image-20220701144318753
image-20220701144318753

阶段4-开发 Mapper 接口和 Mapper.xml

示意图

image-20220701144447818
image-20220701144447818

代码实现

创建 MonsterMapper.java

package com.lzw.mapper;

import com.lzw.entity.Monster;

/**
 * @author LiAng
 * MonsterMapper 声明对DB的crud方法
 */
public interface MonsterMapper {

    //查询方法
    public Monster getMonsterById(Integer id);
}

创建 MonsterMapper.xml

image-20220701145213009
image-20220701145213009
<?xml version="1.0" encoding="UTF-8" ?>
<mapper namespace="com.lzw.mapper.MonsterMapper">
    <!--实现配置接口方法 getMonsterById-->
    <select id="getMonsterById" resultType="com.lzw.entity.Monster">
        select * from monster where id = ?
    </select>
    
</mapper>

阶段5-开发和 Mapper 接口相映射的 MapperBean

示意图

image-20220701145301794
image-20220701145301794

代码实现

创建 Function.java

package com.lzw.lzwmybatis.config;

/**
 * @author LiAng
 * Function：记录对应的Mapper的方法信息
 */
public class Function {
    //属性
    private String sqlType; //sql类型，比如select,insert,update, delete
    private String funcName; //方法名
    private String sql;//执行的sql语句
    private Object resultType;//返回类型
    private String parameterType;//参数类型

    public String getSqlType() {
        return sqlType;
    }

    public void setSqlType(String sqlType) {
        this.sqlType = sqlType;
    }

    public String getFuncName() {
        return funcName;
    }

    public void setFuncName(String funcName) {
        this.funcName = funcName;
    }

    public String getSql() {
        return sql;
    }

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

    public Object getResultType() {
        return resultType;
    }

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

    public String getParameterType() {
        return parameterType;
    }

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

    @Override
    public String toString() {
        return "Function{" +
                "sqlType='" + sqlType + '\'' +
                ", funcName='" + funcName + '\'' +
                ", sql='" + sql + '\'' +
                ", resultType=" + resultType +
                ", parameterType='" + parameterType + '\'' +
                '}';
    }
}

创建 MapperBean.java

package com.lzw.lzwmybatis.config;

import java.util.List;

/**
 * @author LiAng
 * MapperBean：将Mapper信息，进行封装
 */
public class MapperBean {
    private String interfaceName;//接口名

    //接口下的所有方法-集合
    private List<Function> functions;

    public String getInterfaceName() {
        return interfaceName;
    }

    public void setInterfaceName(String interfaceName) {
        this.interfaceName = interfaceName;
    }

    public List<Function> getFunctions() {
        return functions;
    }

    public void setFunctions(List<Function> functions) {
        this.functions = functions;
    }
    
    @Override
    public String toString() {
        return "MapperBean{" +
                "interfaceName='" + interfaceName + '\'' +
                ", functions=" + functions +
                '}';
    }
}

阶段6-在 LzwConfiguration，读取 XxxMapper.xml

能够创建 MappperBean 对象

代码实现

修改 LzwConfiguration.java

	//读取 XxxMapper.xml,能够创建 MapperBean 对象
    //path 就是xml的路径+文件名，是从类的加载路径计算的
    //如果 XxxMapper.xml 文件是放在resources目录下，直接传入xml文件名即可
    public MapperBean readMapper(String path){

        MapperBean mapperBean = new MapperBean();
        try {
            //获取到xml文件对应的InputStream
            InputStream stream = loader.getResourceAsStream(path);
            SAXReader reader = new SAXReader();
            Document document = reader.read(stream);
            //得到xml文件的根元素
            Element root = document.getRootElement();

            //获取到namespace
            String namespace = root.attributeValue("namespace").trim();
            //设置mapperBean的属性interfaceName
            mapperBean.setInterfaceName(namespace);
            //得到root的迭代器-可以遍历它的子节点/子元素-生成Function
            Iterator rootIterator = root.elementIterator();
            //保存接口下所有的方法信息
            List<Function> list = new ArrayList<>();
            //遍历它的子节点/子元素-生成Function
            while (rootIterator.hasNext()){
                Element e = (Element)rootIterator.next();
                Function function = new Function();
                String sqlType = e.getName().trim();
                String funcName = e.attributeValue("id").trim();
                //resultType是返回类型的全路径-即全类名
                String resultType = e.attributeValue("resultType").trim();
                String sql = e.getText().trim();
                //开始封装
                function.setSql(sql);
                function.setFuncName(funcName);
                function.setSqlType(sqlType);

                //function-private Object resultType; 是resultType实例
                //使用反射生成一个对象, setResultType
                Object newInstance = Class.forName(resultType).newInstance();
                function.setResultType(newInstance);

                //将封装好的function对象加入到 list
                list.add(function);
            }
            //while循环结束后, 将function的list设置
            mapperBean.setFunctions(list);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return mapperBean;
    }

修改 LzwMyBatisTest.java

	@Test
    public void readMapper(){
        LzwConfiguration lzwConfiguration = new LzwConfiguration();
        MapperBean mapperBean = lzwConfiguration.readMapper("MonsterMapper.xml");
        System.out.println("mapperBean ：" + mapperBean);
    }

完成测试

image-20220701152440287
image-20220701152440287

阶段7-实现动态代理，Mapper 的方法

示意图

image-20220701154752588
image-20220701154752588

代码实现

创建 LzwMapperProxy.java

package com.lzw.lzwmybatis.sqlsession;

import com.lzw.lzwmybatis.config.Function;
import com.lzw.lzwmybatis.config.MapperBean;

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

/**
 * @author LiAng
 * LzwMapperProxy：动态代理生成Mapper对象，调用LzwExecutor方法
 */
public class LzwMapperProxy implements InvocationHandler {
    //属性
    private LzwSqlSession lzwSqlSession;
    private String mapperFile;
    private LzwConfiguration lzwConfiguration;

    //构造器
    public LzwMapperProxy(LzwConfiguration lzwConfiguration, LzwSqlSession lzwSqlSession, Class clazz) {
        this.lzwConfiguration = lzwConfiguration;
        this.lzwSqlSession = lzwSqlSession;
        this.mapperFile = clazz.getSimpleName()+".xml";
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        MapperBean mapperBean = lzwConfiguration.readMapper(this.mapperFile);

        //判断是否是 xml文件对应的接口
        if (!method.getDeclaringClass().getName().equals(mapperBean.getInterfaceName())){
            return null;
        }

        //取出mapperBean的functions
        List<Function> functions = mapperBean.getFunctions();
        //判断当前mapperBean解析对应MapperXML后 , 有方法
        if(null != functions && 0 != functions.size()){
            for (Function function : functions) {
                //当前要执行的方法和function.getFuncName()一样
                //说明我们可以从当前遍历的function对象中,取出相应的信息sql, 并执行方法
                if(method.getName().equals(function.getFuncName())){
                    //如果我们当前的function 要执行的sqlType是select
                    //我们就去执行selectOne
                    /**
                     * 1. 如果要执行的方法是select , 就对应执行selectOne
                     * 2. 因为在LzwSqlSession就写了一个 selectOne
                     * 3. 实际上LzwSqlSession 应该对应不同的方法(多个方法)
                     * , 根据不同的匹配情况调用不同方法, 并且还需要进行参数解析处理, 还有比较复杂的字符串处理,拼接sql ,处理返回类型等等工作
                     */
                    if("select".equalsIgnoreCase(function.getSqlType())){
                        return lzwSqlSession.selectOne(function.getSql(), String.valueOf(args[0]));
                    }
                }
            }
        }

        return null;
    }
}

修改 LzwSession.java

	/**
     * 1. 返回mapper的动态代理对象
     * 2. 这里clazz 到时传入的是 MonsterMapper.class
     * 3. 返回的就是MonsterMapper接口代理对象
     * 4. 当执行接口方法时(通过代理对象调用), 根据动态代理机制会执行到LzwMapperProxy-invoke
     */
    public <T> T getMapper(Class<T> clazz){
        //返回动态代理对象
        return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, new LzwMapperProxy(lzwConfiguration, this, clazz));
    }

创建 LzwSessionFactory.java

package com.lzw.lzwmybatis.sqlsession;

/**
 * @author LiAng
 * LzwSessionFactory：会话工厂-返回会话
 */
public class LzwSessionFactory {

    public static LzwSqlSession openSession(){
        return new LzwSqlSession();
    }
}

修改 LzwMyBatisTest.java

	@Test
    public void openSession(){
        LzwSqlSession lzwSqlSession = LzwSessionFactory.openSession();
        MonsterMapper mapper = lzwSqlSession.getMapper(MonsterMapper.class);
        Monster monster = mapper.getMonsterById(1);
        System.out.println("monster ：" + monster);
    }

完成测试

image-20220701162307060
image-20220701162307060
上次编辑于: 2023/11/17 23:19:33
贡献者: LiAng