手写一个Mybatis框架

第一：Mybatis框架介绍

　　最近看了一篇关于Mybatis的文章，发现MyBatis框架的核心功能其实不难，无非就是动态代理和jdbc的操作，难的是写出可扩展，高聚合，低耦合的规范的代码。

　　本文手写的Mybatis框架功能比较简单。对Mybatis框架源码理解的也不是很透彻，仅限帮助大家理解源码。

　　口述一下我们平常用Mybatis框架的运行原理：

　　1.配置Configuration文件，或注解。

　　2.通过配置文件创建SqlSessionFactory。其可以创建出Sqlsession.

　　3.Sqlsession类似于一个Request。其作用是：操作数据库。

　　4.Executory(执行器)。这是一个接口（基本执行器，缓存执行器）。Sqlsession内部通过执行器来操作数据库。

　　5.MappedStatement 是通过Mapper.xml中定义statement生成的对象。 参数输入执行并输出结果集，无需手动判断参数类型和参数下标位置，并自动将结果集映射为Java对象。

第二：梳理自己的Mybatis的设计模式。

　　1.读取xml文件，建立连接。

　　　　我们在配置文件中把数据库连接信息，mapper.xml（操作数据库信息）配置好。通过MyConfiguration将这些信息全部取出。本程序利用dom4j来读取XML文件。

　　2.创建Sqlsession,搭建Configuration和Executor之间的联系。

　　　　一个Session仅拥有一个对应的数据库连接。类似于一个前端请求Request，他可以直接调用exec(SQL)来执行SQL语句。MySqlSession中必须有MyExecutor和MySqlSession将有一个getMapper方法，然后使用动态代理生成对象后，就可以做数据库的操作了。

　　3.创建Executor，封装JDBC操作数据库

　　Executor是一个执行器，负责SQL语句的生成和查询缓存（缓存还没完成）的维护，也就是JDBC的代码在这里完成。

　　4.创建MapperProxy,使用动态代理生成Mapper对象。

　　这里只是因为接口无法直接调用方法，所在在这里使用动态代理生成对象，在执行时还是回到MySqlSession中调用查询，最终由MyExecutor做JDBC查询。

第三:实现自己的Mybatis框架。

　　1.目录结构

　　

　　2.创建maven项目，引入依赖。

     <dependency>
            <!-- 读取XML文件 -->
            <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.30</version>
        </dependency>

　　3.配置数据库信息，实体类，实体Mapper.

　　

<?xml version="1.0" encoding="UTF-8" ?>
<!--数据库信息-->
<database>
    <property name="driverClassName">com.mysql.jdbc.Driver</property>
    <property name ="url">jdbc:mysql://localhost:3306/gantee?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai</property>
    <property name="username">root</property>
    <property name="password">123456</property>
</database>

　　

/**
 * @author ：leleChang
 * @date ：Created in 2020/6/17 11:16
 * @description：任务实体类
 * @modified By：
 */
public class Project {
    private String id;
    private String projectname;
    private Date startdate;
    private Date finalldate;

   //省略set get方法
}

　　

package com.cll.mybatis.mapper;

import com.cll.mybatis.bean.Project;
/**
 *这里定义一个数据库操作，相当于使用原来的框架时的DAO层的接口。
 */
public interface ProjectMapper {
    public Project getProjectById(String id);
}

　　4.创建Myconfiguration类。这个主要是读取配置文件信息

package com.cll.mybatis.sqlSession;

import com.cll.mybatis.config.Function;
import com.cll.mybatis.config.MapperBean;
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;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * @author ：leleChang
 * @date ：Created in 2020/6/17 11:23
 * @description：读取解析配置信息，并返回处理后的Environment
 * @modified By：
 */
public class MyConfiguration {
    private static ClassLoader loader = ClassLoader.getSystemClassLoader();
    /**
     * 读取XML信息并处理
     */
    //建立连接
    public Connection build(String resource){

        try {
            //使用IO流读取配置文件
            InputStream stream = loader.getResourceAsStream(resource);
            SAXReader reader = new SAXReader();
            Document document = reader.read(stream);
            Element element = document.getRootElement();
            return evalDataSource(element);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("error occured while evaling xml "+resource);
        }
    }

    //获得数据库链接信息
    private Connection evalDataSource(Element node) throws ClassNotFoundException {
        if (!node.getName().equals("database")){
            throw new RuntimeException("element should be <database>");
        }
        String driverClassName = null;
        String url = null;
        String username = null;
        String password = null;
        //获取属性节点
        for (Object item: node.elements("property")) {
            Element i = (Element) item;
            String value = getValue(i);
            String name = i.attributeValue("name");
            if (name == null || value == null){
                throw new RuntimeException("[database]:<property> should contain name and value");
            }
            //赋值
            switch (name){
                case "url" : url =value; break;
                case "username": username = value; break;
                case "password": password = value; break;
                case "driverClassName" : driverClassName = value;break;
                default:throw new RuntimeException("[database]: <property> unknown name");
            }
        }
        Class.forName(driverClassName);
        Connection connection = null;
        try {
            connection = DriverManager.getConnection(url,username,password);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return connection;
    }

    //获取property属性的值，如果有value值，则读取；没有设置value，则读取内容
    private String getValue(Element node) {
        return node.hasContent()?node.getText():node.attributeValue("value");
    }
    //把***Mapper.xml配置的SQL读取出来，整合成可执行对象。
    @SuppressWarnings("rawtypes")
    public MapperBean readMapper(String path) {
        MapperBean mapperBean = new MapperBean();
        try {
            InputStream stream = loader.getResourceAsStream(path);
            SAXReader reader = new SAXReader();
            Document document = reader.read(stream);
            Element element = document.getRootElement();
            //把mapper节点的nameSpace值存为接口名
            mapperBean.setInterfactName(element.attributeValue("nameSpace").trim());
            //用来存储方法的list
            List<Function> list = new ArrayList<Function>();
            //遍历根节点下所有子节点
            for (Iterator rootIter = element.elementIterator(); rootIter.hasNext(); ) {
                //用来存储一条方法的信息
                Function fun = new Function();
                Element e = (Element) rootIter.next();
                String sqltype = e.getName().trim();
                String funcName = e.attributeValue("id").trim();
                String sql = e.getText().trim();
                String resultType = e.attributeValue("resultType").trim();
                fun.setSqltype(sqltype);
                fun.setFuncName(funcName);
                Object newTnstance = null;
                try {
                    newTnstance = Class.forName(resultType).newInstance();
                } catch (IllegalAccessException illegalAccessException) {
                    illegalAccessException.printStackTrace();
                } catch (InstantiationException instantiationException) {
                    instantiationException.printStackTrace();
                } catch (ClassNotFoundException classNotFoundException) {
                    classNotFoundException.printStackTrace();
                }
                fun.setResultType(newTnstance);
                fun.setSql(sql);
                list.add(fun);
            }
            mapperBean.setList(list);
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return mapperBean;

    }
}

　　5.建立MapperBean和funaction类。

　　Myconfiguration的readMapper方法其实就是把mapper.xml里的信息拿出来。利用funaction,和list来把必要的信息拿出来，所以就需要两个实体类来封装这些数据。

/**
 * @author ：leleChang
 * @date ：Created in 2020/6/17 13:42
 * @description：
 * @modified By：
 */
public class MapperBean {
    //接口名
    private String interfactName;
    //接口下的方法
    private List<Function> list;

//省略get set方法
}

　

public class Function {
    private String sqltype;
    private String funcName;
    private String sql;
    private Object resultType;
    private String parametetType;
    //省略get,set方法    

}

　　6.建立SqlSession。

　

public class MySqlsession {
    //自己建立的执行器，这个执行器封装好了结果为对象
    private Excutor executor = new MyExcutor();
    //这里是多次获取数据库实例，为了下面的动态代理
    private MyConfiguration myConfiguration = new MyConfiguration();
    //调用自己写的执行器，执行SQL
    public <T> T selectOne(String statement, Object parameter) {
        return executor.query(statement,parameter);
    }

    //动态代理
    public <T> T getMapper(Class<T> clas){
        //动态代理调用
        return (T) Proxy.newProxyInstance(clas.getClassLoader(),new Class[]{clas},
                new MyMapperProxy(myConfiguration,this));
    }
}

　　7.创建Executor和实现类。这里把返回结果集封装为对象。

public interface Excutor {
    public <T> T query(String statement,Object parameter);
}

　　

public class MyExcutor implements Excutor {
    private MyConfiguration xmlconfiguration = new MyConfiguration();

    @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();
            Project project = new Project();
            //返回结果集
            while(set.next()){
                project.setId(set.getString("id"));
                project.setProjectname(set.getString("projectname"));
                project.setStartdate(set.getTimestamp("startdate"));
                project.setFinalldate(set.getTimestamp("finalldate"));
            }
            return (T) project;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            try {
                if(set!=null){
                    set.close();
                }if(pre!=null){
                    pre.close();
                }if(connection!=null){
                    connection.close();
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        return null;
    }

    private Connection getConnection() {
        Connection connection = null;
        try {
            connection = xmlconfiguration.build("config.xml");
            return connection;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

　　8.MyMapperProxy代理类完成xml方法和真实方法对应，执行查询。

public class MyMapperProxy implements InvocationHandler {

    private MySqlsession mySqlsession;

    private MyConfiguration myConfiguration;

    public MyMapperProxy(MyConfiguration myConfiguration,MySqlsession mySqlsession){
        this.myConfiguration = myConfiguration;
        this.mySqlsession = mySqlsession;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MapperBean readMapper = myConfiguration.readMapper("UserMapper.xml");
        //是否是XML文件对应的接口
        if(!method.getDeclaringClass().getName().equals(readMapper.getInterfactName())){
           return null;
        }
        //获得配置文件里每个操作SQL的所有信息
        List<Function> list = readMapper.getList();
        if (null != list ||0 !=list.size()){
            for (Function function:list) {
                //id是否与接口名称一样
                if (method.getName().equals(function.getFuncName())){
                    return mySqlsession.selectOne(function.getSql(),String.valueOf(args[0]));
                }
            }
        }
        return null;
    }
}

　　9.进行测试。　　

public class TestMybatis {
    public static void main(String[] args) {
        MySqlsession mySqlsession =new MySqlsession();
        ProjectMapper mapper = mySqlsession.getMapper(ProjectMapper.class);
        Project project = mapper.getProjectById("1");
        System.out.println(project);
    }
}