手写Mybatis，还需要后面调整下

参考博客

https://blog.csdn.net/Kurozaki_Kun/article/details/81482212

个人理解

 读取Mybatis配置文件
     数据库连接信息
 读取Mapper.xml文件
     1.把增删改查节点信息封装成一个MapperInfo
     2.创建一个Map存放(接口全路径名+方法名, MapperInfo);
     3.提供方法，通过接口获取MapperInfo信息
 创建一个动态搭理接口SqlSession
     通过传入核心Sql执行类SqlExecuteHandler获得被代理对象。
 创建SqlExecuteHandler执行类
     1.通过接口方法，获取接口名称和接口方法名称，然后获得MapperInfo信息
     2.获得了MapperInfo信息后，获取执行的sql语句，把参数赋值进去，然后执行得到结果。
 主要核心点
 接口和Mapper之间的关系，用Map(接口+方法名, MapperInfo)进行关联
 sql的执行，通过接口生成的代理对象调用方法的时候，执行InvokerHandler方法，通过代理的方法名获取MapperInfo信息，然后获取其中的sql进行执行操作。
 查询结果返回的是ResultSet, 需要映射成实体类。

实现步骤

1.创建一个maven项目，导入dom4j和mysql包。

<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.jtfr</groupId>
  <artifactId>SimpleMybatis</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>SimpleMybatis</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
        <groupId>dom4j</groupId>
        <artifactId>dom4j</artifactId>
        <version>1.6.1</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>

  </dependencies>
</project>

2.创建测试表

 CREATE DATABASE db_test;

 USE db_test;

 CREATE TABLE `tb_user` (
   `id` INT(11) NOT NULL,
   `name` VARCHAR(20) NOT NULL,
   `age` TINYINT(4) DEFAULT '',
   `addr` VARCHAR(20) NOT NULL,
   PRIMARY KEY (`id`)
 ) ENGINE=INNODB DEFAULT CHARSET=utf8mb4

 INSERT INTO tb_user(id,NAME,age,addr) VALUES(1,'ckm1', 100, 'sz1');
 INSERT INTO tb_user(id,NAME,age,addr) VALUES(2,'ckm2', 100, 'sz2');
 INSERT INTO tb_user(id,NAME,age,addr) VALUES(3,'ckm3', 100, 'sz3');
 INSERT INTO tb_user(id,NAME,age,addr) VALUES(4,'ckm4', 100, 'sz4');
 INSERT INTO tb_user(id,NAME,age,addr) VALUES(5,'ckm5', 100, 'sz5');
 COMMIT;

3.创建测试用的实体类

 package com.jtfr.entity;

 /**
  * 用户实体
  * @author ckm
  *
  */
 public class User {

     private int id;
     private String name;
     private int age;
     private String addr;

     public int getId() {
         return id;
     }

     public void setId(int id) {
         this.id = id;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     public String getAddr() {
         return addr;
     }

     public void setAddr(String addr) {
         this.addr = addr;
     }

     @Override
     public String toString() {
         return "User{" +
                 "id=" + id +
                 ", name='" + name + '\'' +
                 ", age=" + age +
                 ", addr='" + addr + '\'' +
                 '}';
     }
 }

4.创建操作的接口

 package com.jtfr.dao;

 import com.jtfr.entity.User;

 public interface UserDao {

     User getUserInfo(int id);

     int updateUserName(String newName, int id);

     int insertUser(int id, String name, int age, String addr);
 }

5.模仿Mybaitis编写对应接口的Mapper.xml

 <?xml version="1.0" encoding="UTF-8" ?>
 <mapper namespace="com.jtfr.dao.UserDao">
     <select id="getUserInfo" resultType="com.jtfr.entity.User">
         select * from tb_user
         where id = ?;
     </select>

     <update id="updateUserName">
         update tb_user set name = ?
         where id = ?
     </update>

     <insert id="insertUser">
         insert into tb_user
         values(?, ?, ?, ?);
     </insert>
 </mapper>

6.读取和记录Mapper.xml文件

　　6.1需要有一个MapperInfo来存放Mapper.xml里面的每一个操作信息。

 package com.jtfr.core;

 public class MapperInfo {

     private QueryType queryType;
     private String interfaceName;
     private String methodName;
     private String sql;
     private String resultType;

     public QueryType getQueryType() {
         return queryType;
     }

     public void setQueryType(QueryType queryType) {
         this.queryType = queryType;
     }

     public String getSql() {
         return sql;
     }

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

     public String getResultType() {
         return resultType;
     }

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

     public String getInterfaceName() {
         return interfaceName;
     }

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

     public String getMethodName() {
         return methodName;
     }

     public void setMethodName(String methodName) {
         this.methodName = methodName;
     }

     @Override
     public String toString() {
         return "MapperInfo{" +
                 "queryType=" + queryType +
                 ", interfaceName='" + interfaceName + '\'' +
                 ", methodName='" + methodName + '\'' +
                 ", sql='" + sql + '\'' +
                 ", resultType='" + resultType + '\'' +
                 '}';
     }
 }

　　6.2需要一个枚举类，记录Mybatis的操作。

 package com.jtfr.core;

 public enum QueryType {
     SELECT, UPDATE, INSERT, DELETE;

     /**
      * 这里的作用，判断标签是否是四种其中的一种
      * @param v
      * @return
      */
     public static QueryType value(String v) {
         return valueOf(v.toUpperCase());
     }
 }

　　6.3读取Mapper.xml文件，并且处理相关数据，最后形成一个Map<String, MapperInfo>存放。

 package com.jtfr.core;

 import java.io.File;
 import java.util.HashMap;
 import java.util.Map;

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

 public enum SqlMappersHolder {

     INSTANCE;

     private Map<String, MapperInfo> mi = null;

     SqlMappersHolder() {
         if (mi != null)
             return;
         mi = new HashMap<String, MapperInfo>();
         // 获取mapper.xml文件所在路径
         File dir = new File(SqlMappersHolder.class.getClassLoader().getResource(Config.DEFAULT.getMapperPath()).getFile());

         // 用dom4j解析
         SAXReader reader = new SAXReader();
         try {
             for (String file : dir.list()) {
                 // 读取mapper.xml
                 Document doc = reader.read(new File(dir, file));
                 Element root = doc.getRootElement();
                 // 获取接口全路径名
                 String className = root.attributeValue("namespace");

                 for (Object o : root.elements()) {
                     Element e = (Element) o;

                     MapperInfo info = new MapperInfo();
                     info.setQueryType(QueryType.value(e.getName()));
                     info.setInterfaceName(className);
                     info.setMethodName(e.attributeValue("id"));
                     info.setResultType(e.attributeValue("resultType"));
                     info.setSql(e.getText());

                     mi.put(idOf(className, e.attributeValue("id")), info);
                 }
             }
         } catch (DocumentException e) {
             e.printStackTrace();
         }
     }

     public MapperInfo getMapperInfo(String className, String methodName) {
         return mi.get(idOf(className, methodName));
     }

     /*
      * 接口全路径+"."+方法名作为唯一id
      */
     private String idOf(String className, String methodName) {
         return className + "." + methodName;
     }
 }

7.通过接口生成动态代理对象

　　7.1JDK动态代理需要先有一个实现InvocationHandler的处理类

　　

 package com.jtfr.core;

 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;

 public class SqlExecuteHandler implements InvocationHandler {

     public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
         // 传入的要被执行的接口方法，通过获取接口名和方法名，然后获取要MapperInfo信息。
         MapperInfo info = getMapperInfo(method);

         // 通过MapperInfo和传入的参数，执行Sql语句，并且返回结果。
         return executeSql(info, params);
     }

     private MapperInfo getMapperInfo(Method method) throws Exception {
         MapperInfo mapperInfo = SqlMappersHolder.INSTANCE.getMapperInfo(method.getDeclaringClass().getName(), method.getName());
         if (mapperInfo == null) {
             throw new Exception("Mapper not found for method: " +
                     method.getDeclaringClass().getName() + "." + method.getName());
         }
         return mapperInfo;
     }

     private Object executeSql(MapperInfo info, Object[] params)
             throws SQLException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
         Object result = null;
         PreparedStatement pstat = ConnectionManager.get().prepareStatement(info.getSql());
         for (int i = 0; i < params.length; i++) {
             pstat.setObject(i + 1, params[i]);
         }

         if (info.getQueryType() == QueryType.SELECT) {
             ResultSet rs = pstat.executeQuery();
             rs.first();
             // 将查询结果映射为ava类或基本数据类型
             // 目前简化版仅支持String和int两种类型
             if (rs.getMetaData().getColumnCount() == 1) {
                 switch (info.getResultType()) {
                     case "int":
                         result = rs.getInt(1);
                         break;
                     default:
                         result = rs.getString(1);
                 }
             } else {
                 Class<?> resultTypeClass = Class.forName(info.getResultType());
                 Object inst = resultTypeClass.newInstance();
                 for (Field field : resultTypeClass.getDeclaredFields()) {
                     String setterName = "set" +
                             field.getName().substring(0, 1).toUpperCase() +
                             field.getName().substring(1);
                     Method md;

                     switch (field.getType().getSimpleName()) {
                         case "int":
                             // 获取方法
                             md = resultTypeClass.getMethod(setterName, new Class[]{int.class});
                             // 反射执行方法对 field进行赋值。
                             md.invoke(inst, rs.getInt(field.getName()));
                             break;
                         /* 其他类型还没来得及测试，后面修复
                         case "long":
                             md = resultTypeClass.getMethod(setterName, new Class[]{long.class});
                             md.invoke(inst, rs.getLong(field.getName()));
                             break;*/
                         case "string":
                             md = resultTypeClass.getMethod(setterName, new Class[]{String.class});
                             md.invoke(inst, rs.getString(field.getName()));
                             break;

                         default:
                             md = resultTypeClass.getMethod(setterName, new Class[]{String.class});
                             md.invoke(inst, rs.getString(field.getName()));
                     }
                 }
                 result = inst;
             }
         } else {
             result = pstat.executeUpdate();
         }
         pstat.close();
         return result;
     }

 }

　　7.2生成动态代理对象。

 package com.jtfr.core;

 import java.lang.reflect.Proxy;

 public class SqlSession {

     @SuppressWarnings("unchecked")
     public <T> T getMapper(Class<T> cls) {
         return (T) Proxy.newProxyInstance(cls.getClassLoader(),
                 new Class[]{cls},
                 new SqlExecuteHandler());
     }
 }

剩下的待补充