手把手教你写个Mybatis框架

叁歲伎倆 2023-05-22 22:14 120阅读 0赞

日常开发常用的持久层框架 Hibernate、Mybatis。本文按照Mybatis的执行流程简单搭建一个Demo，仅仅供大家对Mybatis框架有个更加透彻的理解。

**目录**

一、Mybatis的执行流程解读

二、开发环境准备

二、Mybatis相关

Mybatis-config.xml

Config

Mapper

Resources

DataSourceUtils

Executor

XMLConfigBuilder

User

UserDao

UserDao.xml

SqlSessionFactoryBuilder

SqlSessionFactory

SqSession

MapperProxy

MybatisTest

三、参考文献

四、支持注解形式

--------------------

# 一、Mybatis的执行流程解读 #

*  读取MyBatis配置文件(包括数据库，Mapper等)
 *  创建SqlSessionBuilder创建SqlSessionFactory工厂(构造者模式，得到工厂对象)
 *  SqlSessionFactory 创建 SqlSession 对象 (工厂对象创建出真正执行对象SqlSession)
 *  SqlSession对象与数据库完成交互 (利用反向代理将Mapper在不改变源码得基础上接口方法进行增强）
 *  SqlSession增强得方法进行Sql执行得到结果集 (Executor 执行器 真正交互得地方)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xzNDkwNDQ3NDA2_size_16_color_FFFFFF_t_70][]

# 二、开发环境准备 #

*  创建Maven项目 
 *  引入所需POM依赖

<dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.6</version>
            </dependency>
            
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.12</version>
            </dependency>
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.10</version>
                
                <scope>test</scope>
            </dependency>
            
            <dependency>
                <groupId>dom4j</groupId>
                <artifactId>dom4j</artifactId>
                <version>1.6.1</version>
            </dependency>
            
            <dependency>
                <groupId>jaxen</groupId>
                <artifactId>jaxen</artifactId>
                <version>1.1.6</version>
            </dependency>
            
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>

*  项目目录结构

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xzNDkwNDQ3NDA2_size_16_color_FFFFFF_t_70 1][]

# 二、Mybatis相关 #

##  Mybatis-config.xml ##

<?xml version="1.0" encoding="UTF-8"?>
    
    <configuration>
        
        <environments default="mysql">
            
            <environment id="mysql">
                
                <transactionManager type="JDBC"></transactionManager>
                
                <dataSource type="POOLED">
                    
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://localhost:3306/local_test?characterEncoding=utf8"/>
                    <property name="username" value="root"/>
                    <property name="password" value="123456"/>
                </dataSource>
            </environment>
        </environments>
        
        <mappers>
            
            <mapper resource="com/lishuo/dao/IUserDao.xml"/>
            
        </mappers>
    </configuration>

## Config ##

package com.lishuo.mybatis.cfg;
    
    import lombok.AllArgsConstructor;
    import lombok.Getter;
    import lombok.NoArgsConstructor;
    import lombok.Setter;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * Mybatis 配置类
     */
    @Setter
    @Getter
    @AllArgsConstructor
    @NoArgsConstructor
    public class Configuration {
    
        /** 数据库驱动链接 */
        private String driver;
        /** 数据库地址 */
        private String url;
        /** 账号 */
        private String username;
        /** 密码 */
        private String password;
    
        private Map<String, Mapper> mappers = new HashMap<String, Mapper>();
    
    }

## Mapper ##

package com.lishuo.mybatis.cfg;
    
    import lombok.AllArgsConstructor;
    import lombok.Getter;
    import lombok.NoArgsConstructor;
    import lombok.Setter;
    
    /**
     * 封装执行的Sql和结果集类型
     */
    @Setter
    @Getter
    @AllArgsConstructor
    @NoArgsConstructor
    public class Mapper {
    
        /** 要执行的sql语句 */
        private String queryString;
        /** 实体类的全限定类名 */
        private String resultType;
    
    
    }

## Resources  ##

*  获取字节流

package com.lishuo.mybatis.io;
    
    import java.io.InputStream;
    
    public class Resources {
    
        /**
         * 根据传入的参数获取字节输入流
         *
         * @param filePath
         * @return
         */
        public static InputStream getResourceAsStream(String filePath) {
            // 获取当前类的字节码，获取字节码的类加载器，根据类加载器读取配置文件信息
            return Resources.class.getClassLoader().getResourceAsStream(filePath);
        }
    }

## DataSourceUtils ##

*  获取数据库连接

package com.lishuo.mybatis.utils;
    
    import com.lishuo.mybatis.cfg.Configuration;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    
    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);
            }
        }
    
    }

## Executor ##

*  Sql执行器

package com.lishuo.mybatis.utils;
    
    import com.lishuo.mybatis.cfg.Mapper;
    
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.Method;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * Sql 执行器
     */
    public class Executor {
    
        public <E> List<E> selectList(Mapper mapper, Connection conn) {
            PreparedStatement pstm = null;
            ResultSet rs = null;
            try {
                // 1.取出mapper中的数据
                String queryString = mapper.getQueryString();//select * from user
                String resultType = mapper.getResultType();
                Class domainClass = Class.forName(resultType);
                // 2.获取PreparedStatement对象
                pstm = conn.prepareStatement(queryString);
                // 3.执行SQL语句，获取结果集
                rs = pstm.executeQuery();
                // 4.封装结果集
                List<E> list = new ArrayList<E>();// 定义返回值
                while (rs.next()) {
                    // 实例化要封装的实体类对象
                    E obj = (E) domainClass.newInstance();
    
                    // 取出结果集的元信息：ResultSetMetaData
                    ResultSetMetaData rsmd = rs.getMetaData();
                    // 取出总列数
                    int columnCount = rsmd.getColumnCount();
                    // 遍历总列数
                    for (int i = 1; i <= columnCount; i++) {
                        // 获取每列的名称，列名的序号是从1开始的
                        String columnName = rsmd.getColumnName(i);
                        //  根据得到列名，获取每列的值
                        Object columnValue = rs.getObject(columnName);
                        // 给obj赋值：使用Java内省机制（借助PropertyDescriptor实现属性的封装）
                        PropertyDescriptor pd = new PropertyDescriptor(columnName, domainClass);// 实体类的属性和数据库表的列名相同
                        // 获取它的写入方法
                        Method writeMethod = pd.getWriteMethod();
                        // 把获取的列的值，给对象赋值
                        writeMethod.invoke(obj, columnValue);
                    }
                    // 把赋好值的对象加入到集合中
                    list.add(obj);
                }
                return list;
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                release(pstm, rs);
            }
        }
    
    
        private void release(PreparedStatement pstm, ResultSet rs) {
            if (rs != null) {
                try {
                    rs.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
    
            if (pstm != null) {
                try {
                    pstm.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
    }

## XMLConfigBuilder ##

*  解析XML

package com.lishuo.mybatis.utils;
    
    
    import com.lishuo.mybatis.cfg.Configuration;
    import com.lishuo.mybatis.cfg.Mapper;
    import com.lishuo.mybatis.io.Resources;
    import org.dom4j.Attribute;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.lang.reflect.Method;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    public class XMLConfigBuilder {
    
        /**
         * 解析主配置文件，把里面的内容填充到DefaultSqlSession所需要的地方
         *
         */
        public static Configuration loadConfiguration(InputStream config) {
            try {
                // 定义封装连接信息的配置对象（mybatis的配置对象）
                Configuration cfg = new Configuration();
    
                // 1.获取SAXReader对象
                SAXReader reader = new SAXReader();
                // 2.根据字节输入流获取Document对象
                Document document = reader.read(config);
                // 3.获取根节点
                Element root = document.getRootElement();
                // 4.使用xpath中选择指定节点的方式，获取所有property节点
                List<Element> propertyElements = root.selectNodes("//property");
                // 5.遍历节点
                for (Element propertyElement : propertyElements) {
                    // 判断节点是连接数据库的哪部分信息
                    // 取出name属性的值
                    String name = propertyElement.attributeValue("name");
                    if ("driver".equals(name)) {
                        // 表示驱动
                        // 获取property标签value属性的值
                        String driver = propertyElement.attributeValue("value");
                        cfg.setDriver(driver);
                    }
                    if ("url".equals(name)) {
                        // 表示连接字符串
                        // 获取property标签value属性的值
                        String url = propertyElement.attributeValue("value");
                        cfg.setUrl(url);
                    }
                    if ("username".equals(name)) {
                        // 表示用户名
                        // 获取property标签value属性的值
                        String username = propertyElement.attributeValue("value");
                        cfg.setUsername(username);
                    }
                    if ("password".equals(name)) {
                        // 表示密码
                        // 获取property标签value属性的值
                        String password = propertyElement.attributeValue("value");
                        cfg.setPassword(password);
                    }
                }
                // 取出mappers中的所有mapper标签，判断他们使用了resource还是class属性
                List<Element> mapperElements = root.selectNodes("//mappers/mapper");
                // 遍历集合
                for (Element mapperElement : mapperElements) {
                    //  判断mapperElement使用的是哪个属性
                    Attribute attribute = mapperElement.attribute("resource");
                    if (attribute != null) {
                        System.out.println("使用的是XML");
                        // 表示有resource属性，用的是XML
                        // 取出属性的值
                        String mapperPath = attribute.getValue();
                        // 把映射配置文件的内容获取出来，封装成一个map
                        Map<String, Mapper> mappers = loadMapperConfiguration(mapperPath);
                        // 给configuration中的mappers赋值
                        cfg.setMappers(mappers);
                    } else {
                        System.out.println("使用的是注解");
                        // 表示没有resource属性，用的是注解
                        // 获取class属性的值
                        String daoClassPath = mapperElement.attributeValue("class");
                        // 根据daoClassPath获取封装的必要信息
                        //Map<String, Mapper> mappers = loadMapperAnnotation(daoClassPath);
                        // 给configuration中的mappers赋值
                        //cfg.setMappers(mappers);
                    }
                }
                // 返回Configuration
                return cfg;
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                try {
                    config.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
    
        }
    
        /**
         * 根据传入的参数，解析XML，并且封装到Map中
         *
         * @param mapperPath 映射配置文件的位置
         * @return map中包含了获取的唯一标识（key是由dao的全限定类名和方法名组成）
         * 以及执行所需的必要信息（value是一个Mapper对象，里面存放的是执行的SQL语句和要封装的实体类全限定类名）
         */
        private static Map<String, Mapper> loadMapperConfiguration(String mapperPath) throws IOException {
            InputStream in = null;
            try {
                // 定义返回值对象
                Map<String, Mapper> mappers = new HashMap<String, Mapper>();
                // 1.根据路径获取字节输入流
                in = Resources.getResourceAsStream(mapperPath);
                // 2.根据字节输入流获取Document对象
                SAXReader reader = new SAXReader();
                Document document = reader.read(in);
                // 3.获取根节点
                Element root = document.getRootElement();
                // 4.获取根节点的namespace属性取值
                String namespace = root.attributeValue("namespace");// 是组成map中key的部分
                // 5.获取所有的select节点
                List<Element> selectElements = root.selectNodes("//select");
                // 6.遍历select节点集合
                for (Element selectElement : selectElements) {
                    // 取出id属性的值 （组成map中key的部分）
                    String id = selectElement.attributeValue("id");
                    // 取出resultType属性的值  （组成map中value的部分）
                    String resultType = selectElement.attributeValue("resultType");
                    // 取出文本内容  （组成map中value的部分）
                    String queryString = selectElement.getText();
                    // 创建Key
                    String key = namespace + "." + id;
                    // 创建Value
                    Mapper mapper = new Mapper();
                    mapper.setQueryString(queryString);
                    mapper.setResultType(resultType);
                    // 把key和value存入mappers中
                    mappers.put(key, mapper);
                }
                return mappers;
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                in.close();
            }
        }
    
        /**
         * 根据传入的参数，得到dao中所有被select注解标注的方法。
         * 根据方法名称和类名，以及方法上注解value属性的值，组成Mapper的必要信息
         *
         * @param daoClassPath
         * @return
         */
    /*    private static Map<String, Mapper> loadMapperAnnotation(String daoClassPath) throws Exception {
            // 定义返回值对象
            Map<String, Mapper> mappers = new HashMap<String, Mapper>();
    
            // 1.得到dao接口的字节码对象
            Class daoClass = Class.forName(daoClassPath);
            // 2.得到dao接口中的方法数组
            Method[] methods = daoClass.getMethods();
            // 3.遍历Method数组
            for (Method method : methods) {
                // 取出每一个方法，判断是否有select注解
                boolean isAnnotated = method.isAnnotationPresent(Select.class);
                if (isAnnotated) {
                    // 创建Mapper对象
                    Mapper mapper = new Mapper();
                    // 取出注解的value属性值
                    Select selectAnno = method.getAnnotation(Select.class);
                    String queryString = selectAnno.value();
                    mapper.setQueryString(queryString);
                    // 获取当前方法的返回值，还要求必须带有泛型信息
                    Type type = method.getGenericReturnType();
                    // 判断type是不是参数化的类型
                    if (type instanceof ParameterizedType) {
                        // 强转
                        ParameterizedType ptype = (ParameterizedType) type;
                        // 得到参数化类型中的实际类型参数
                        Type[] types = ptype.getActualTypeArguments();
                        // 取出第一个
                        Class domainClass = (Class) types[0];
                        // 获取domainClass的类名
                        String resultType = domainClass.getName();
                        // 给Mapper赋值
                        mapper.setResultType(resultType);
                    }
                    // 组装key的信息
                    // 获取方法的名称
                    String methodName = method.getName();
                    String className = method.getDeclaringClass().getName();
                    String key = className + "." + methodName;
                    // 给map赋值
                    mappers.put(key, mapper);
                }
            }
            return mappers;
        }*/
    
    }

## User ##

package com.lishuo.pojo;
    
    import lombok.*;
    
    import java.io.Serializable;
    
    @Data
    public class User implements Serializable {
    
        private Integer id;
    
        private String username;
    
        private String sex;
    
        private String address;
    
    }

## UserDao ##

package com.lishuo.dao;
    
    import com.lishuo.pojo.User;
    
    import java.util.List;
    
    /**
     * @author ls
     * @Date
     */
    public interface IUserDao {
    
        List<User> findAll();
    
    }

## UserDao.xml ##

<?xml version="1.0" encoding="UTF-8"?>
    <mapper namespace="com.lishuo.dao.IUserDao">
        
        <select id="findAll" resultType="com.lishuo.pojo.User">
            select * from user
        </select>
    </mapper>

## SqlSessionFactoryBuilder ##

*  Facotry 构造器

package com.lishuo.mybatis.sqlsession;
    
    import com.lishuo.mybatis.cfg.Configuration;
    import com.lishuo.mybatis.sqlsession.defaults.DefaultSqlSessionFactory;
    import com.lishuo.mybatis.utils.XMLConfigBuilder;
    
    import java.io.InputStream;
    
    public class SqlSessionFactoryBuilder {
    
        /**
         * 根据参数的字节输入流来构建一个SqlSessionFactory工厂
         *
         * @param config
         * @return
         */
        public SqlSessionFactory build(InputStream config) {
            Configuration cfg = XMLConfigBuilder.loadConfiguration(config);
            return new DefaultSqlSessionFactory(cfg);
        }
    
    
    }

## SqlSessionFactory ##

*  SqlSession工厂接口

package com.lishuo.mybatis.sqlsession;
    
    public interface SqlSessionFactory {
    
        SqlSession openSession();
    
    }

*  SqlSession工厂默认实现类

package com.lishuo.mybatis.sqlsession.defaults;
    
    import com.lishuo.mybatis.cfg.Configuration;
    import com.lishuo.mybatis.sqlsession.SqlSession;
    import com.lishuo.mybatis.sqlsession.SqlSessionFactory;
    
    public class DefaultSqlSessionFactory implements SqlSessionFactory {
    
        private Configuration cfg;
    
        public DefaultSqlSessionFactory(Configuration cfg) {
            this.cfg = cfg;
        }
    
        /**
         * 用于创建一个新的连接
         *
         * @return
         */
        public SqlSession openSession() {
            return new DefaultSqlSession(cfg);
        }
    }

## SqSession ##

*  SqSession 接口

package com.lishuo.mybatis.sqlsession;
    
    public interface SqlSession {
    
        /**
         * 根据参数创建一个代理对象
         *
         * @param daoInterfaceClass dao接口的字节码
         * @param <T>
         * @return
         */
        <T> T getMapper(Class<T> daoInterfaceClass);
    
        /**
         * 释放资源
         */
        void close();
    
    }

*  SqSession 默认实现类

package com.lishuo.mybatis.sqlsession.defaults;
    
    import com.lishuo.mybatis.cfg.Configuration;
    import com.lishuo.mybatis.sqlsession.SqlSession;
    import com.lishuo.mybatis.utils.DataSourceUtil;
    
    import java.lang.reflect.Proxy;
    import java.sql.Connection;
    import java.sql.SQLException;
    
    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();
                }
            }
        }
    
    }

## MapperProxy ##

*  用于Mapper方法得增强

package com.lishuo.mybatis.sqlsession.defaults;
    
    import com.lishuo.mybatis.cfg.Mapper;
    import com.lishuo.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 {
    
        // map 的key是全限定类名加方法名
        private Map<String, Mapper> mappers;
    
        private Connection conn;
    
        public MapperProxy(Map<String, Mapper> mappers, Connection conn) {
            this.mappers = mappers;
            this.conn = conn;
        }
    
        /**
         * 用于对方法增强，调用select1List方法
         *
         * @param proxy
         * @param method
         * @param args
         * @return
         * @throws Throwable
         */
        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.获取mappers中的mapper对象
            Mapper mapper = mappers.get(key);
            // 5.判断是否有mapper
            if (mapper == null) {
                throw new IllegalArgumentException("传入的参数有错误");
            }
            // 6.调用工具类查询所有
            return new Executor().selectList(mapper, conn);
        }
    
    }

## MybatisTest ##

*  测试整体结构

package com.lishuo;
    
    import com.lishuo.dao.IUserDao;
    import com.lishuo.mybatis.io.Resources;
    import com.lishuo.mybatis.sqlsession.SqlSession;
    import com.lishuo.mybatis.sqlsession.SqlSessionFactory;
    import com.lishuo.mybatis.sqlsession.SqlSessionFactoryBuilder;
    import com.lishuo.pojo.User;
    
    import java.io.InputStream;
    import java.util.List;
    
    public class MyBatisTest {
    
        public static void main(String[] args) throws Exception {
            // 1.读取配置文件
            InputStream input = Resources.getResourceAsStream("Mybatis-configs.xml");
            // 2.创建SqlSessionFactory工厂
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            // 使用构建者模式，把对象的创建信息隐藏，使得调用方法的时候就可拿到对象
            SqlSessionFactory factory = builder.build(input);
            // 3.使用工厂创建SqlSession对象(借助此对象与数据库交互)
            // 使用工厂模式，解耦（降低类之间的依赖关系）
            SqlSession session = factory.openSession();
            // 4.使用SqlSession对象创建dao接口的代理对象
            // 使用代理模式，不修改源码的基础上对方法进行增强
            IUserDao userDao = session.getMapper(IUserDao.class);
            // 5.使用代理对象执行dao接口中的方法
            List<User> list = userDao.findAll();
            list.forEach(user -> {
                System.out.println(user.toString());
            });
            // 6.释放资源
            session.close();
            input.close();
        }
    
    }

![20200418160636870.png][]

# 三、参考文献 #

大牛得博客很清晰：[https://blog.csdn.net/weixin\_43570367/article/details/103244430][https_blog.csdn.net_weixin_43570367_article_details_103244430]

# 四、支持注解形式 #

下文：[https://blog.csdn.net/ls490447406/article/details/105602512][https_blog.csdn.net_ls490447406_article_details_105602512]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xzNDkwNDQ3NDA2_size_16_color_FFFFFF_t_70]: /images/20230521/246d702014124e018597beb0f0b7d862.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xzNDkwNDQ3NDA2_size_16_color_FFFFFF_t_70 1]: /images/20230521/efd70d151c5e49ad9a19fa430cfc33dd.png
[20200418160636870.png]: /images/20230521/417c548b04384e189ac04382fd3bb97b.png
[https_blog.csdn.net_weixin_43570367_article_details_103244430]: https://blog.csdn.net/weixin_43570367/article/details/103244430
[https_blog.csdn.net_ls490447406_article_details_105602512]: https://blog.csdn.net/ls490447406/article/details/105602512