106-Mybatis的底层原理

Mybatis的底层原理

之前说明的都是Mybatis的应用（61章博客开始），现在来说明他为什么可以那样做

我们继续分析分析JDBC操作的问题：

首先给出具体sql语句：

链接：https://pan.baidu.com/s/1KVIkn4A48tJbkposXGiBLA

提取码：alsk

实体类：

package com;

/**
 *
 */
public class User {
    Integer id;
    String userName;

    public Integer getId() {
        return id;
    }

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

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

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

依赖：

  <dependencies>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.8version>
        dependency>
    dependencies>

测试类：

package com;

import java.sql.*;

/**
 *
 */
public class Mybatis {
    public static void main(String[] args) throws Exception {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            // 加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 通过驱动管理类获取数据库链接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "123456");
            // 定义sql语句？表示占位符
            String sql = "select * from user where username = ?";
            // 获取预处理statement
            preparedStatement = connection.prepareStatement(sql);
            // 设置参数，第一个参数为sql语句中参数的序号(从1开始)，第⼆个参数为设置的参数值
            preparedStatement.setString(1, "tom");
            // 向数据库发出sql执⾏查询，查询出结果集
            resultSet = preparedStatement.executeQuery();
            // 遍历查询结果集
            User user = new User();
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String username = resultSet.getString("username");
                // 封装User
                user.setId(id);
                user.setUserName(username);
            }
            System.out.println(user);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

首先说明jdbc的问题：

1：数据库连接创建、释放频繁造成系统资源浪费，从而影响系统性能

2：Sql语句连接信息或者sql语句（他们简称为sql）在代码中有硬编码，造成代码不易维护，实际应用中sql变化的可能较大，sql变动需要改变java代码，比如说，如果使用配置文件存放，那么若代码有自动识别是否修改而改变的，那么改动即可，若没有，那么他一个配置是可以给多个类使用的，即我们只需要改动一次即可部署完毕，而由于一般我们都只会提交class文件，原来的还要继续编译（找源代码），而不能直接的运行，即从上不难看出解决硬编码问题的好处

3：使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能 多也可能少，修改sql还要修改代码，系统不易维护（也可以归属于sql语句）

4：对结果集解析存在硬编码（如查询列名），sql变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成pojo对象解析比较方便

问题解决思路：

1：使用数据库连接池初始化连接资源

2：将sql语句抽取到xml配置文件中，注意：这里最好将sql语句和sql连接信息分开，虽然可以在一个配置文件中，但是由于sql会变动很大，可能造成在自动识别中需要识别更多的信息，虽然其他方面没有问题，但是也是一个解决的好处，除了这样且也便于维护

3：使用反射、内省等底层技术，自动将实体与表进行属性与字段的自动映射，内省：Java内省机制是指通过标准的get/set方法（利用反射调用成员方法）对成员属性进行操作（实际上也是反射，只是对这个操作进行另外一种称呼而已），而不是直接通过反射对属性操作，在Mybatis的sql语句中，就使用到了这个（说明set时就是这样，如类似的set后面名称可以忽略大小写等等，所以是利用了反射，要不然怎么判断忽略呢，当然，这里我们不操作这种情况，所以这里了解即可，所以配置文件中的名称最好要对应）

为了完成上面的要求，现在我们来自定义框架

自定义框架设计：

使用端（也就是项目）：

提供核心配置文件：

sqlMapConfig.xml：存放数据源信息，并引入Mapper.xml

Mapper.xml：sql语句的配置文件信息

注意：上面配置文件名称是可以随便写的，只是为了对标Mybatis来弄成这样而已，让你更加的理解Mybatis的工作流程

框架端（可以认为我们编写的框架，或者说jar包）：

1：读取配置文件

一般来说读取完成以后以流的形式存在（getResourceAsSteam(配置文件路径)，配置文件是sqlMapConfig.xml），但是我们不能将读取到的配置信息以流的形式存放在内存中，因为不好操作，所以我们可以提取将他们的信息来进行保存好（当然，提取步骤在后面的解析配置文件中说明），即先进行操作完毕，而不是在使用时进行提取，那么我们可以创建javaBean来存储

第一个javaBean：Configuration，用来存放数据库基本信息（一般是sqlMapConfig.xml的信息）和Map<唯一标识，Mapper> ，唯一标识：namespace + “.” + id

第二个javaBean：MappedStatement（Mapper的简称，一般是Mapper.xml的信息），主要是操作sql语句、statement类型（一般是操作标识，即定位的，当然大多数是代表本身，比如select，delete等等的id属性）、输入参数java类型、输出参数java类型等等

2：解析配置文件

创建sqlSessionFactoryBuilder类：

方法：sqlSessionFactory build(流参数)：

第一：使用dom4j解析配置文件，将解析出来的内容封装到Configuration和MappedStatement中

第二：创建SqlSessionFactory的实现类DefaultSqlSession

3：SqlSessionFactory：

方法：openSession()，来获取sqlSession接口的实现类实例对象

4：sqlSession接口及实现类：主要封装crud方法，可以任务是会话对象，即代码平台（或者说语句执行平台）

方法：selectList(String statementId,Object param)：查询所有

selectOne(String statementId,Object param)：查询单个

具体实现：封装JDBC完成对数据库表的查询操作

涉及到的设计模式：

Builder构建者设计模式、工厂模式、代理模式

上面具体流程只是大致说明完毕，具体细节建议看后面的代码就行，实际上可以看出我们就是来完成Mybatis的底层操作，现在开始实现：

在使用端项目中创建配置配置文件

创建 sqlMapConfig.xml（资源文件夹下）：

<configuration> 

 <property name="driverClass" value="com.mysql.jdbc.Driver">property>
 <property name="jdbcUrl" value="jdbc:mysql:///mybatis">property>
    
 <property name="user" value="root">property>
 <property name="password" value="123456">property>
 
 <mapper resource="mapper.xml">mapper>
configuration> 

mapper.xml：

<mapper namespace="User"> 
    <select id="selectOne" paramterType="com.User" resultType="com.User">
        select * from user where id = #{id} and username =#{username}
        <!--id最好就是id，因为我们并没有操作什么大小写，或者get和set的操作，这里主要是类似于aClass.getDeclaredField的方法，他是必须-要对应参数存在的，否则报错，并且我们也没有在之前进行设置忽略的相关操作（比如可以操作try的不报错的循环判断，循环退出后，再考虑是否存在，从而考虑报错）->
    select>
    <select id="selectList" resultType="com.User">
        select * from user
    select>
mapper>

上面我们并没有操作什么约束，因为我们只是测试而已，所以只要符合xml格式即可，这里建议将mapper修改成UserMapper，这样可以有效的知道是服务于那个实体类的，有利于维护，那么对应的sqlMapConfig配置文件中对应位置也记得要修改

至此，我们与定义的读取配置文件的数据都操作完毕，现在，我们主要从后端代码中拿取这些数据了

User实体（与之前一样）：

package com;

/**
 *
 */
public class User { //记得与数据库中的表对应
    Integer id;
    String username;
    String password;
    String birthday;

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", birthday='" + birthday + '\'' +
                '}';
    }
}

再创建一个Maven工程（与原来的同级，当然是子项目也行，这里简称为框架项目）并且导入需要用到的依赖坐标（主要在以后作为jar包来使用的）

<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">
    <parent>
        <artifactId>mybatisartifactId>
        <groupId>org.examplegroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>mybaartifactId>

    <properties>
        <maven.compiler.source>11maven.compiler.source>
        <maven.compiler.target>11maven.compiler.target>
    properties>
    <dependencies>

        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.17version>
        dependency>

        <dependency>
            <groupId>c3p0groupId>
            <artifactId>c3p0artifactId>
            <version>0.9.1.2version>
        dependency>


        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.12version>
        dependency>

        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.10version>
        dependency>

        <dependency>
            <groupId>dom4jgroupId>
            <artifactId>dom4jartifactId>
            <version>1.6.1version>
        dependency>

        <dependency>
            
            <groupId>jaxengroupId>
            <artifactId>jaxenartifactId>
            <version>1.1.6version>
        dependency>
    dependencies>

project>

Resources类（包路径记得在里面看）：

package com.Res;

import java.io.InputStream;

/**
 *
 */
public class Resources {

    //这里是用来读取配置文件的，所以这里定义一个读取配置文件的方法
    public static InputStream getResourceAsSteam(String path) {
        //通过类加载器来使用对应的方法，得到输入流（加载器有顶端出现class，而顶端是c的代码，所以不用怀疑不能）
        //默认是classpath路径，也就是项目路径，或者说资源文件夹里面的以及java（文件夹）里面的
        //但要注意的是，如果对应的项目在当前idea，就算你安装了，那么首先也是使用他的，所以在实际操作中，记得去除掉对应的框架项目，使得不在当前idea中，当然，你可以另外创建一个项目在其他窗口也行
        InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path);
        return resourceAsStream;
    }

}

现在我们可以在主项目中进行测试：

但是首先我们需要导入依赖包：

  <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.10version>
        dependency>
        <dependency>
            
            <groupId>org.examplegroupId>
            <artifactId>testartifactId>
            <version>1.0-SNAPSHOTversion>
            
        dependency>

然后创建test类进行测试：

package com;

import com.Res.Resources;
import org.junit.Test;

import java.io.InputStream;

/**
 *
 */
public class test {
    @Test
    public void res() {
        //得到配置文件的流，从而可以读取信息
        InputStream resourceAsSteam = Resources.getResourceAsSteam("sqlMapConfig.xml");
    }
}

现在我们回到框架项目，编写如下类：

//上面我们拿取了xml的配置信息，主要是解决硬编码问题了，那么现在开始，将配置信息进行实际操作
//在前面我们知道有四个信息：MappedStatement（Mapper的简称，一般是Mapper.xml的信息）：主要是操作sql语句、statement类型（一般是操作标识，即定位的，当然大多数是代表本身）、输入参数java类型、输出参数java类型等等
//所以这里也需要四个参数
package com.pojo;

/**
 *
 */
public class MappedStatement {
    //id（statement类型，比如select，delete等等标签的对应id信息，所以这里最好是String类型）
    private String id; //这里是statement，而不是statementId哦
    //sql语句
    private String sql;
    //输入参数
    private Class<?> paramterType;
    //输出参数
    private Class<?> resultType;

    public String getId() {
        return id;
    }

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

    public String getSql() {
        return sql;
    }

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

    public Class<?> getParamterType() {
        return paramterType;
    }

    public void setParamterType(Class<?> paramterType) {
        this.paramterType = paramterType;
    }

    public Class<?> getResultType() {
        return resultType;
    }

    public void setResultType(Class<?> resultType) {
        this.resultType = resultType;
    }
}

再创建如下：

//Configuration，用来存放数据库基本信息（一般是sqlMapConfig.xml的信息）和Map<唯一标识，Mapper> ，唯一标识：namespace + "."  + id
package com.pojo;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 *
 */
public class Configuration {
    //数据源
    private DataSource dataSource;
    //map集合： key:statementId value:MappedStatement（包含对应的标签哦，因为我们只是扫描一个xml，通过他来得到信息，所以且一般需要多个，既然是存，那么为什么不存在这里呢）
    private Map<String, MappedStatement> mappedStatementMap = new HashMap<String, MappedStatement>();

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public Map<String, MappedStatement> getMappedStatementMap() {
        return mappedStatementMap;
    }

    public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) {
        this.mappedStatementMap = mappedStatementMap;
    }
}

好了对应的类创建完毕，那么读取配置文件需要的步骤操作完毕，现在开始进行完成解析配置文件，我们继续再框架项目中添加如下的类：

package com.config;

import com.Res.Resources;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import com.pojo.Configuration;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.beans.PropertyVetoException;
import java.io.InputStream;
import java.util.List;
import java.util.Properties;

/**
 *
 */
public class XMLConfigerBuilder {
    private Configuration configuration;

    //合成复用，每个操作都给一个类来进行操作，而不是创建一个，主要用于一个类被多人操作的情况
    public XMLConfigerBuilder(Configuration configuration) {
        this.configuration = new Configuration();
    }

    //解析配置文件，封装Configuration类
    public Configuration parseConfiguration(InputStream inputStream) throws Exception {
        Document document = new SAXReader().read(inputStream); //解析XML获取文档对象document
        //，getRootElement() 获得根元素，这里的api可以选择到42章博客去查看
        Element rootElement = document.getRootElement();
        //selectNodes(query)：得到的是xml根节点下的所有满足 xpath 的节点，参数是Xpath 查询串
        List<Element> propertyElements = rootElement.selectNodes("//property");
        Properties properties = new Properties();
        for (Element propertyElement : propertyElements) {
            //attributeValue(…) 获得指定属性名的属性值
            String name = propertyElement.attributeValue("name");
            String value = propertyElement.attributeValue("value");
            //其中Properties类是Hashtable类的子类，该对象主要用于处理属性文件，key和value都是String类型的，即也是集合类的一种
            properties.setProperty(name, value);
        }
        //连接池，使用默认配置，具体在41章博客有说明
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        comboPooledDataSource.setDriverClass(properties.getProperty("driverClass"));
        comboPooledDataSource.setJdbcUrl(properties.getProperty("jdbcUrl"));
        comboPooledDataSource.setUser(properties.getProperty("user"));
        comboPooledDataSource.setPassword(properties.getProperty("password"));
        //填充 configuration
        configuration.setDataSource(comboPooledDataSource);
        //至此，对应的数据源信息都操作完毕，上面之所以要分开，主要是判断getProperty参数里面是否一致的问题，我们先进行添加就不用判断了
        //mapper 部分，这里以多个指向的xml为主，不要认为是操作包的哦
        List<Element> mapperElements = rootElement.selectNodes("//mapper");
        XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
        for (Element mapperElement : mapperElements) {
            String mapperPath = mapperElement.attributeValue("resource");
            //继续读取，所以也需要一个对于的对象来操作，即xmlMapperBuilder，也自然需要传递输入流
            InputStream resourceAsSteam = Resources.getResourceAsSteam(mapperPath);
            xmlMapperBuilder.parse(resourceAsSteam);
        }
        return configuration;
    }
}

需要的对应类：

package com.config;

import com.pojo.Configuration;
import com.pojo.MappedStatement;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.List;

/**
 *
 */
public class XMLMapperBuilder {
    private Configuration configuration;

    public XMLMapperBuilder(Configuration configuration) {
        this.configuration = configuration;
    }

    public void parse(InputStream inputStream) throws Exception {
        Document document = new SAXReader().read(inputStream);
        Element rootElement = document.getRootElement();
        String namespace = rootElement.attributeValue("namespace");
        List<Element> select = rootElement.selectNodes("select");
        for (Element element : select) { //id的值
            String id = element.attributeValue("id");
            String paramterType = element.attributeValue("paramterType");
            String resultType = element.attributeValue("resultType");
            //输入参数class，既然对应的输入和输出是一个具体的类型，且是全路径，自然需要直接得到对应的class类型
            Class<?> paramterTypeClass = getClassType(paramterType);
            //返回结果class
            Class<?> resultTypeClass = getClassType(resultType);
            //statementId
            String key = namespace + "." + id;
            //sql语句，得到内容，并且去除两边的空格
            String textTrim = element.getTextTrim();
            //封装 mappedStatement
            MappedStatement mappedStatement = new MappedStatement();
            mappedStatement.setId(id);
            mappedStatement.setParamterType(paramterTypeClass);
            mappedStatement.setResultType(resultTypeClass);
            mappedStatement.setSql(textTrim);
            //填充 configuration
            configuration.getMappedStatementMap().put(key, mappedStatement);

        }

    }

    //得到class类型
    private Class<?> getClassType(String paramterType) throws Exception {
         //这里也要考虑对应是否为null，如果是，那么应该返回null
        if(paramterType==null){
            return null;
        }
        Class<?> aClass = Class.forName(paramterType);
        return aClass;
    }
}

至此，上面的两个类，使得配置文件的信息得以保存，并且放在Configuration里面，现在我们需要如下的类来进行操作：

package com.sqlsession;

import com.config.XMLConfigerBuilder;
import com.pojo.Configuration;
import org.dom4j.DocumentException;

import java.beans.PropertyVetoException;
import java.io.InputStream;

/**
 *
 */
public class SqlSessionFactoryBuilder {
    private Configuration configuration;

    public SqlSessionFactoryBuilder() {
        this.configuration = new Configuration();
    }

    public SqlSessionFactory build(InputStream inputStream) throws Exception {
        //1.解析配置文件，封装Configuration，我们可以选择将解析过程写在这里，但是为了好维护，我们创建XMLConfigerBuilder类来进行解析，使得以后可以复用的
        XMLConfigerBuilder xmlConfigerBuilder = new XMLConfigerBuilder(configuration);
        Configuration configuration = xmlConfigerBuilder.parseConfiguration(inputStream);
        //2.创建 sqlSessionFactory，工厂模式，使得主操作不用创建，只需要修改这一处即可，所以正是因为这样，一般来说我们需要一个接口，来完成可以以后的修改，那么自然不能是当前类了
        SqlSessionFactory sqlSessionFactory = new DefaultSqlSessionFactory(configuration);
        return sqlSessionFactory;

    }
}

package com.sqlsession;

/**
 *
 */
public interface SqlSessionFactory {
    public SqlSession openSession();
}

package com.sqlsession;

import java.sql.SQLException;
import java.util.List;

/**
 *
 */
public interface SqlSession {
    public <E> List<E> selectList(String statementId, Object... param) throws Exception;

    public <T> T selectOne(String statementId, Object... params) throws Exception;

    public void close() throws SQLException;
}

package com.sqlsession;

import com.pojo.Configuration;

/**
 *
 */
//因为是实现他，所以才说是工厂接口（接口可以让更多人进行操作，只需要改动类即可，所以一般我们都会将需求称为接口，因为接口必然对应实现类，也是现在的规范），其中我们将解析配置文件的结果configuration传递进来进行操作
//之所以是工厂，是因为如果有其他的实现类（其他的操作，或者就是该类，但是我们添加一些代表补充，虽然补充一般我们会认为是装饰器模式（前提是指向相同方法，且是方法）），那么使用他就行，从而改变所有使用对应的SqlSessionFactoryBuilder类的地方，这也是工厂模式的好处
public class DefaultSqlSessionFactory implements SqlSessionFactory{
    private Configuration configuration;
    public DefaultSqlSessionFactory(Configuration configuration) {

        this.configuration = configuration;
    }
    //被返回后他也有方法可以操作，简单来说前面根据SqlSessionFactoryBuilder操作的配置文件后，返回的一个类就是这个，而他是工厂操作，那么自然每个工厂返回的类有他自己的类操作
    //很明显，他在满足工厂模式的情况下，进一步返回操作封装的configuration，其实，如果可以，他可以返回自身，而自身继续操作，但是这样没有满足工厂的，也就没有什么扩展可言
   	
    //这里的方法，又实现工厂模式，大多数我们并不会在主操作中操作new，所以我们通常这样操作
    @Override
    public SqlSession openSession(){
        return new DefaultSqlSession(configuration);
    }
}

实际上工厂模式除了将创建对象给方法外，还有一个最为重要的操作，即可以将操作分开，使得一个类不会有多个操作，这也是为什么类也有分工的原因，虽然大多数不是使用工厂来区分的，即工厂的核心还是没有在主操作中进行创建对象

这里就是主要的操作了：

package com.sqlsession;

import com.pojo.Configuration;
import com.pojo.MappedStatement;

import java.sql.SQLException;
import java.util.List;

/**
 *
 */
public interface Executor {
    <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object[] param) throws Exception;

    void close() throws SQLException;

}

package com.sqlsession;

import com.pojo.Configuration;
import com.pojo.MappedStatement;

import java.sql.SQLException;
import java.util.List;

/**
 *
 */
public class DefaultSqlSession implements SqlSession {
    private Configuration configuration;


    public DefaultSqlSession(Configuration configuration) {
        this.configuration = configuration;
    }

    //处理器对象，专门来操作具体sql执行的，也就是jdbc代码，这里并不会用来返回给任何人，所以直接使用他的方法即可
    private Executor simpleExcutor = new SimpleExecutor();

    //对应工厂返回的对象类中，都有各自的操作，当然，这里一般只有一个工厂（大多都是这样，只是使用模式而已，总不能没有扩展吧），对应的类都也操作工厂模式


    @Override
    //由于我们不知道对应的类型是什么，所以这里利用泛型方法来表示对应的类型（变成对应的类型，包括返回值的泛型和参数的泛型）
    public <E> List<E> selectList(String statementId, Object... param) throws Exception {
        //这里我们传递对应的标识，既然我们知道对应的配置信息，那么要执行这个，必然是需要找到对应的sql语句的，并需要利用配置文件的数据库配置信息
        //所以这里的statementId就是对应的namespace.id，而Object... param可以认为是条件（因为条件的多个的），且可以是类，所以设为Object的可变长参数
        //当然，对应的由于是操作类，所以这里以一个类为主，即这个参数主要考虑paramterType的名称的值

        //在map中拿取指定的标签的信息，即通过我们传递的statementId可以得到对应的信息，因为
        /*
        //statementId
        String key = namespace + "." + id;
         */
        MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
        List<E> query = simpleExcutor.query(configuration, mappedStatement, param);
        return query;
    }

    @Override
    //selectOne 中调用 selectList
    public <T> T selectOne(String statementId, Object... params) throws Exception {
        List<Object> objects = selectList(statementId, params);
        if (objects.size() == 1) {
            return (T) objects.get(0);
        } else if (objects.size() == 0) {
            throw new RuntimeException("没有结果");
        } else {
            throw new RuntimeException("返回结果过多");
        }
    }

    @Override
    public void close() throws SQLException {
        simpleExcutor.close();
    }
}

很明显上面的主要操作就是simpleExcutor的操作，所以我们看看这个类：

package com.sqlsession;

import com.pojo.Configuration;
import com.pojo.MappedStatement;
import com.utils.GenericTokenParser;
import com.utils.ParameterMapping;
import com.utils.ParameterMappingTokenHandler;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/**
 *
 */
public class SimpleExecutor implements Executor {
    private Connection connection = null;

    //操作jdbc代码，我们之前的配置最终都需要这样的操作，只是需要获取或者保存一系列的信息而已以及一些设计模式的使用
    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object[] param) throws Exception {
        //获取连接
        connection = configuration.getDataSource().getConnection();
        // select * from user where id = #{id} and username = #{username}
        String sql = mappedStatement.getSql();
        //对sql进行处理，由于对应的sql中存在#{}所以需要进行变化，且之所以没有操作?，是因为若是实体类，我们需要根据里面的信息来进行替换的，这也是为什么需要使用#{}的一个原因
        //得到最终数据的结果，即?位置及其数据，替换了?哦
        BoundSql boundsql = getBoundSql(sql);
        // 得到select * from where id = ? and username = ?
        String finalSql = boundsql.getSqlText();
        //获取传入参数类型，mappedStatement可是保存我们定位到的标签信息哦
        Class<?> paramterType = mappedStatement.getParamterType();
        //获取预编译preparedStatement对象，他是操作?的，这也是为什么我们使用替换?的一个原因
        PreparedStatement preparedStatement = connection.prepareStatement(finalSql);
        //得到?的位置及其数据替换（如id等等）
        List<ParameterMapping> parameterMappingList = boundsql.getParameterMappingList();
        //由于这个大小的存在，所以如果没有参数，他自然不会执行，也就不会考虑paramterType是否为null的情况了
        //因为没有参数，他自然为0，因为每有一个?他都会添加
        for (int i = 0; i < parameterMappingList.size(); i++) {
            //拿取每一个的ParameterMapping数据，他就包括了?的位置，实际上由于这个循环的作用，那么这个位置也不用操作了，我们只需要将他的对应的替换进行操作即可
            ParameterMapping parameterMapping = parameterMappingList.get(i);
            //得到那个替换数据
            String name = parameterMapping.getContent();
            //反射，注意：这里是操作类的，所以这里并没有其他的判断，这里要注意
            //Field getDeclaredField(String name)，用于获取此Class对象所表示类中参数指定的单个成员变量信息
            //由于这里操作入参，因为?是替换的，所以获取该成员信息
            Field declaredField = paramterType.getDeclaredField(name); //这之前，我们并不操作set，只是操作成员变量而已
            //void setAccessible(booleanflag)，当实参传递true时，则反射对象在使用时应该取消 Java 语言访问检查，即保证修改成功
            declaredField.setAccessible(true);
            //参数的值，因为是类，所以这里直接为0，因为只有一个
            //Object get(Object obj)，获取参数对象obj中此Field对象所表示成员变量的数值
            Object o = declaredField.get(param[0]);
            //实际上这里之所以利用反射，是保证入参类型与传递的参数类型一致，所以如果不一致，那么通常可能会报错
            //也就是说Object o = declaredField.get(param[0]);会发生报错，所以利用反射也是一种防止手段，那么有个问题，可以自己判断吗
            //答：不能，因为上面的Object类型的，你怎么知道他的类是啥呢，所以这里利用反射来确定一致性
            //给占位符赋值
            preparedStatement.setObject(i + 1, o);
        }
        //上面就完成了设置参数，现在我们需要执行
        //因为都是select，所以操作executeQuery方法，当然，这里只是测试，如果是多个的话，我们一般是需要判断的
        ResultSet resultSet = preparedStatement.executeQuery();
        //获得返回的类型
        Class<?> resultType = mappedStatement.getResultType();
        ArrayList<E> results = new ArrayList<E>(); //因为可以得到多行数据，或者说列数据（对于结果来说），所以需要这个集合
        //当然，由于我们并没有操作其他的标签属性来决定是否操作集合，所以这里统一操作集合
        while (resultSet.next()) { //进行遍历
            //PrepareStatement 预处理对象调用 getMetaData () , 获取的是ResultSetMetaData , 结果集元数据对象
            //他（ResultSetMetaData metaData）包含如下方法：
            /*
            //getColumnCount() : 当前结果集共有多少列，注意，这里代表的是结果，也就是说代表一行一行的数据
            //getColumnName(int i) : 获取指定列号的列名, 参数是整数 从1开始
            //getColumnTypeName(int i): 获取指定列号列的类型, 参数是整数 从1开始
             */
            ResultSetMetaData metaData = resultSet.getMetaData();
            E e = (E) resultType.newInstance(); //创建定义返回的类，一般情况下，编译期会将这个e可能放在外面来操作，具体如何主要看编译器怎么操作了（可能如果后面没有，放在最外面），这里了解即可
            //getColumnCount() : 当前结果集共有多少列
            int columnCount = metaData.getColumnCount();
            for (int i = 1; i <= columnCount; i++) { //因为上面是从1开始的，所以这里也是哦
                //属性名
                //getColumnName(int i) : 获取指定列号的列名, 参数是整数 从1开始
                String columnName = metaData.getColumnName(i);
                //属性值
                Object value = resultSet.getObject(columnName);
                //很明显，这里我们可以根据上面的属性名来设置前面E类的值（反射，或者说内省），但是这里我们使用另外一种我们没有使用过的技术
                //看如下：
                //创建属性描述器，为属性⽣成读写方法，相当于操作对应的属性
                PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultType);
                //获取写方法
                Method writeMethod = propertyDescriptor.getWriteMethod();
                //向类中写入值
                writeMethod.invoke(e, value);
                /*
                一般情况下，我们会使用这种方式

                Field declaredField = resultType.getDeclaredField(columnName);
                declaredField.set(e,value);

               很明显，PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultType);
               就相当于
               Field declaredField = resultType.getDeclaredField(columnName);
               declaredField.setAccessible(true);
               declaredField.set(e,value);
                只是里面自定义了declaredField	.set(e,value);的封装方法，使得进行操作，我们可以看到，使用原来的应该要好点，那么为什么使用这个呢，或者说好处是什么
                首先他没有什么null的问题，因为他不是resultType来调用的，这就是主要的好处

                 */
            }
            results.add(e);
        }
        return results;
    }


    @Override
    public void close() throws SQLException {
        //SqlSession的close最终还是连接的close关闭操作
        connection.close();
    }


    //完成#{}的替换，然后将真的数据进行保存并返回
    private BoundSql getBoundSql(String sql) {
        //标记处理类：主要是配合通用标记解析器GenericTokenParser类完成对配置文件等的解析工作，其中TokenHandler主要完成处理
        ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
        //GenericTokenParser :通用的标记解析器，完成了代码⽚段中的占位符的解析，然后再根据给定的标记处理器(TokenHandler)来进行表达式的处理
        //三个参数：分别为openToken (开始标记)、closeToken (结束标记)、handler (标记处理器)
        GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
        //将sql传递进来进行解析
        String parse = genericTokenParser.parse(sql);
        //这里就是得到?对应的替换信息，其中下标代表?的先后顺序，而类保存的值，代表替换的数据
        List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
        //将解析数据进行保存
        BoundSql boundSql = new BoundSql(parse, parameterMappings);
        return boundSql;
    }
}

package com.sqlsession;

import com.utils.ParameterMapping;

import java.util.ArrayList;
import java.util.List;

/**
 *
 */
public class BoundSql {
    //解析过后的sql语句
    private String sqlText;
    //解析出来的参数
    private List<ParameterMapping> parameterMappingList = new ArrayList<ParameterMapping>();


    public BoundSql(String sqlText, List<ParameterMapping> parameterMappingList) {
        this.sqlText = sqlText;
        this.parameterMappingList = parameterMappingList;
    }


    public String getSqlText() {
        return sqlText;
    }


    public void setSqlText(String sqlText) {
        this.sqlText = sqlText;
    }

    public List<ParameterMapping> getParameterMappingList() {
        return parameterMappingList;
    }

    public void setParameterMappingList(List<ParameterMapping> parameterMappingList) {
        this.parameterMappingList = parameterMappingList;
    }
}

package com.utils;

/**
 * @author Clinton Begin
 */
public interface TokenHandler {
  String handleToken(String content);
}

package com.utils;

public class ParameterMapping {

    //保存了对应替换的信息，以字符串的形式进行
    private String content;

    public ParameterMapping(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

package com.utils;

import java.util.ArrayList;
import java.util.List;


public class ParameterMappingTokenHandler implements TokenHandler {
    //之所以要这样，是保证添加的顺序，以及信息，所以这样就可以决定谁先操作?了
    private List<ParameterMapping> parameterMappings = new ArrayList();

    // context是参数名称 #{id} #{username}
    @Override
    public String handleToken(String content) {
        parameterMappings.add(buildParameterMapping(content));
        return "?";
    }

    private ParameterMapping buildParameterMapping(String content) {
        ParameterMapping parameterMapping = new ParameterMapping(content);
        return parameterMapping;
    }

    public List<ParameterMapping> getParameterMappings() {
        return parameterMappings;
    }

    public void setParameterMappings(List<ParameterMapping> parameterMappings) {
        this.parameterMappings = parameterMappings;
    }

}

后续是mybatis的替换操作

/**
 * Copyright 2009-2017 the original author or authors.
 * 

 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 

 * http://www.apache.org/licenses/LICENSE-2.0
 * 

 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.utils;

/**
 * @author Clinton Begin
 */
public class GenericTokenParser {

    private final String openToken; //开始标记
    private final String closeToken; //结束标记
    private final TokenHandler handler; //标记处理器

    public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
        this.openToken = openToken;
        this.closeToken = closeToken;
        this.handler = handler;
    }

    /**
     * 解析${}和#{}
     *
     * @param text
     * @return 该方法主要实现了配置文件、脚本等片段中占位符的解析、处理工作，并返回最终需要的数据
     * 其中，解析工作由该方法完成，处理工作是由处理器handler的handleToken()方法来实现
     */
    //这里一般传递的是sql
    public String parse(String text) {
        // 验证参数问题，如果是null，就返回空字符串。
        if (text == null || text.isEmpty()) {
            return "";
        }

        // 下面继续验证是否包含开始标签，如果不包含，默认不是占位符，直接原样返回即可，否则继续执行，也就是不用解析，sql就是sql
        //int indexOf(String str, int fromIndex)，表示从字符串的fromIndex位置开始检索str第一次出现的位置
        int start = text.indexOf(openToken, 0);
        if (start == -1) {
            return text;
        }

        // 把text转成字符数组src，并且定义默认偏移量offset=0、存储最终需要返回字符串的变量builder
        // text变量中占位符对应的变量名为expression，判断start是否大于-1(即text中是否存在openToken)，如果存在就执行下面代码

        //我们将sql的字符串信息变成字符数组，在xml中得到的都是字符串哦
        char[] src = text.toCharArray();
        //定义起始偏移量
        int offset = 0;
        //使用这个可变的String
        final StringBuilder builder = new StringBuilder();
        StringBuilder expression = null;
        while (start > -1) { //代表存在
            // 判断如果开始标记前如果有转义字符，就不作为openToken进行处理，否则继续处理
            if (start > 0 && src[start - 1] == '\\') {
                //这个append方法代表将字符数组的offset起始位置，添加start - offset - 1数量的值进行添加，从offset开始
                //然后继续加上openToken，说明拿取了包括#{之前的sql信息
                builder.append(src, offset, start - offset - 1).append(openToken);
                //起始位置发生改变，正好在#{后面一个位置
                offset = start + openToken.length();
            } else {
                //重置expression变量，避免空指针或者老数据干扰
                if (expression == null) {
                    expression = new StringBuilder();
                } else {
                    //setLength()方法用于在将字符序列替换为新字符序列时设置字符序列的长度，因此该序列的长度将由给定参数指定
                    //比如：你有123这个数据，若我设置为2，那么只会显示12，3被清除，所以如果设置为0，代表清空数据，并且如果设置为4，那么多余的用空字符来代表，注意是字符哦，对于基本数据类型来说，超过的则总后面显示
                    expression.setLength(0);
                }
                //继续添加，但是并没有添加#{，主要是为了后面进行替换?
                builder.append(src, offset, start - offset);
                //改变起始位置
                offset = start + openToken.length();
                //再次获得结果，只不过这里以结束标记作为起始，且是以整个test的sql来查找的，一般都是利用test的
                int end = text.indexOf(closeToken, offset);
                while (end > -1) {//存在结束标记时
                    //继续判断，重复上面的动作，但是这里是判断结束标记的，而不是开始标记
                    if (end > offset && src[end - 1] == '\\') {//如果结束标记前面有转义字符时
                        // this close token is escaped. remove the backslash and continue.
                        expression.append(src, offset, end - offset - 1).append(closeToken);
                        offset = end + closeToken.length();
                        end = text.indexOf(closeToken, offset);
                    } else {//不存在转义字符，即需要作为参数进行处理，他也不添加}，也是为了后面的?做替换
                        //并且expression保留了#{}里面的信息，但是由于我们只会保留一个，所以直接返回
                        expression.append(src, offset, end - offset);
                        offset = end + closeToken.length();
                        break;
                    }
                }
                //如果没有结果，说明没有}，所以直接执行如下，后面的就不用判断了，因为没有}，自然不用操作替换，即必然会使得后面进行退出
                if (end == -1) {
                    // close token was not found.
                    //得到后面的sql内容
                    builder.append(src, start, src.length - start);
                    offset = src.length;
                } else {
                    //首先根据参数的key（即expression）进行参数处理，返回?作为占位符
                    //其中，handler是封装的，我们执行他的方法，且他的方法也是操作创建类的，这里也基本都利用的工厂模式
                    //总之，只是保存一下而已，而expression就是对应的要替换的信息，因为直接返回了，所以替换了?
                    builder.append(handler.handleToken(expression.toString()));
                }
            }
            //查看后面是否还有#{，从而判断是否继续执行这个循环
            start = text.indexOf(openToken, offset);
        }
        //判断开始标签直接不存在的情况
        if (offset < src.length) {
            builder.append(src, offset, src.length - offset);
        }
        return builder.toString();
    }
    //注意：上面的操作中，你可能会认为是有很多的细节问题的，实际上并没有
    //这个问题在后面进行说明，现在我们先使用这个，当然，那些问题又何尝不是一些小问题呢

    //比如你可以尝试一下#{s\\} && user = #{user}，会发现结果很特殊，所以说，如果是规范的那么不会出现这样的特殊问题，这主要是该替换的缺陷而已
    //比如在if (end > offset && src[end - 1] == '\\')里面就有逻辑的问题（不规范的情况下）
    //你可以尝试一下：select * from ee where id = #{s\\} && user = #{user}
    //最终会变成select * from ee where id = ?，而不是select * from ee where id = #{s} && user = ?
    //实际上他是对的，因为#{s\\} && user = #{user}中被包括的是s\\} && user = #{user，他是一个整体，要不然，为什么上面的if (end > offset && src[end - 1] == '\\')里面代表是否存在的问题呢，所以说该问题并不是问题，只是一个不好的操作而已

}

在mybatis的3.5.4版本中，是这样的操作：

      public String parse(String text) {
      if (text != null && !text.isEmpty()) {
            int start = text.indexOf(this.openToken);
            if (start == -1) {
                return text;
            } else {
                char[] src = text.toCharArray();
                int offset = 0;
                StringBuilder builder = new StringBuilder();

                for(StringBuilder expression = null; start > -1; start = text.indexOf(this.openToken, offset)) {
                    if (start > 0 && src[start - 1] == '\\') {
                        builder.append(src, offset, start - offset - 1).append(this.openToken);
                        offset = start + this.openToken.length();
                    } else {
                        if (expression == null) {
                            expression = new StringBuilder();
                        } else {
                            expression.setLength(0);
                        }

                        builder.append(src, offset, start - offset);
                        offset = start + this.openToken.length();

                        int end;
                        for(end = text.indexOf(this.closeToken, offset); end > -1; end = text.indexOf(this.closeToken, offset)) {
                            if (end <= offset || src[end - 1] != '\\') {
                                expression.append(src, offset, end - offset);
                                break;
                            }

                            expression.append(src, offset, end - offset - 1).append(this.closeToken);
                            offset = end + this.closeToken.length();
                        }

                        if (end == -1) {
                            builder.append(src, start, src.length - start);
                            offset = src.length;
                        } else {
                            builder.append(this.handler.handleToken(expression.toString()));
                            offset = end + this.closeToken.length();
                        }
                    }
                }

                if (offset < src.length) {
                    builder.append(src, offset, src.length - offset);
                }

                return builder.toString();
            }
        } else {
            return "";
        }
    }
//对于\\来说，一般无论是#{，还是}，只要有一个人存在，那么直接找后面的，虽然有细节问题（但还是合理的）

测试（记得到另外一个窗口项目，与主项目一样，并导入安装的框架项目依赖来操作，或者在框架项目中加上对应的配置文件来操作）：

package com;

import com.Res.Resources;
import com.sqlsession.SqlSession;
import com.sqlsession.SqlSessionFactory;
import com.sqlsession.SqlSessionFactoryBuilder;

import java.io.InputStream;

/**
 *
 */
public class a {
    public static void main(String[] args) throws Exception {
        InputStream resourceAsSteam = Resources.getResourceAsSteam("sqlMapConfig.xml");
        //读取配置信息，并通过工厂模式返回一个可以操作的类
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsSteam);
        //每个可以操作的类也有方法，且也是工厂模式来返回操作的类
        SqlSession sqlSession = build.openSession();
        User user = new User();
        user.setId(2);
        user.setUsername("tom");

        User o = sqlSession.selectOne("User.selectOne", user);
        System.out.println(o);
        List<Object> list = sqlSession.selectList("User.selectList");
        System.out.println(list);
    }
}
//这里我们要记得一下，一般来说，有些mysql版本可能在mysql中password会被替换成authentication_string，所以注意即可，一般高版本是这样的，这里了解即可，即记得看版本哦，一般8.0好像就被替换了

你可以发现，对应的与前面的我们写的替换操作基本是一样的，只是代码不同顺序而已

尝试细节问题：

package com.utils;

/**
 *
 */
public class m {
    public static void main(String[] args) {
        String a = "select * from ee where id = #{s\\} && user = #{user}";
        String parse = new GenericTokenParser("#{", "}", new ParameterMappingTokenHandler()).parse(a);
        System.out.println(parse); //select * from ee where id = ?

        //String a = "select * from ee where id = #{s && user = #{user}";也是
    }
}
//注意：他是对的

实际上前面也操作了工厂模式，当然，我并没有指出，一般情况下，没有在主操作中创建的对象，我们都会认为是工厂模式，但是工厂模式一定好吗，其实我们可以发现，工厂模式虽然看起来好，但是最终类或者接口实在太多，也就是说，如果死板的按照设计模式来编写，在维护上，即在一定程度上，反而降低了维护效率，所以有时候，我们会直接的使用对应的方法，而不是返回出现，即定义成员变量或者静态变量等等，所以设计模式（不只是工厂模式哦，其他也算）一般也需要平衡类的多少或者存在的合理来进行设计，而不是看到一个类就使用设计模式

到这里mybatis的原理基本说明完毕，当然了，上面的功能或者细节，远不及真的mybatis，因为对于mybatis来说，他的标签可是非常多了，我们远不及他，因为mybatis可不是一人就能开发完毕的，就算可以，也是需要非常多的时间，因为就算你跟着他的源码敲也需要非常多的时间，更不要说自己完成了

当然，上面的细节问题，我们了解即可，并不需要修改，因为一般我们都会规范的写的，且他是对的

最后，要说明一下如下操作：

//Field的setAccessible(true)方法
//用来满足私有的权限，并且满足不在同一个包下（其中若对应的类是当前包下的子包，也算）
//简单来说，如果对应的类的某个属性设置了私有，或者该类没有在你当前的包下，或者在当前包下的其他包下，那么就会不能访问，即报错，所以需要这个

//还有一点，如果maven没有操作包，那么可能直接在java资源文件夹下的类，应该是不能导入的，或者说，不能操作，这一般是maven的问题，在springboot中，一般也有这样的问题，这可能是一个规定，具体可以百度

自定义框架优化：

通过上述我们的自定义框架，我们解决了JDBC操作数据库带来的一些问题：例如频繁创建释放数据库连 接，硬编码，⼿动封装返回结果集和参数等问题，但是现在我们继续来分析刚刚完成的自定义框架代码，有没 有什么问题？

问题如下：

这里的dao看后面的代码：

dao的实现类（认为的我们操作的流程，看后面的实现类即可）中存在重复的代码，整个操作的过程模板重复（读取配置文件，创建SqlSessionFactory，创建sqlsession）

dao的实现类中存在硬编码，调用sqlsession的方法时，参数statement的id（简称statementId）硬编码需要我们进行编写

解决：使用代理模式来创建接口的代理对象：

现在我们来进行操作，首先，就是在主项目中，添加如下的接口和类（包自己创建）：

package com.dao;

import com.User;

import java.util.List;

/**
 *
 */
public interface IUserDao {
    //查询所有用户
    public List<User> findAll();

    //根据条件进行用户查询
    public User findBy(User user);
}

package com.dao;

import com.Res.Resources;
import com.User;
import com.sqlsession.SqlSession;
import com.sqlsession.SqlSessionFactory;
import com.sqlsession.SqlSessionFactoryBuilder;

import java.io.InputStream;
import java.util.List;

/**
 *
 */
public class IUserDaoImpl implements IUserDao {
    @Override
    public List<User> findAll() throws Exception {
        InputStream resourceAsSteam = Resources.getResourceAsSteam("sqlMapConfig.xml");
        //读取配置信息，并通过工厂模式返回一个可以操作的类
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsSteam);
        //每个可以操作的类也有方法，且也是工厂模式来返回操作的类
        SqlSession sqlSession = build.openSession();
        List<User> list = sqlSession.selectList("User.selectList");
        System.out.println(list);
        return list;
    }

    @Override
    public User findBy(User user) throws Exception {
        InputStream resourceAsSteam = Resources.getResourceAsSteam("sqlMapConfig.xml");
        //读取配置信息，并通过工厂模式返回一个可以操作的类
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsSteam);
        //每个可以操作的类也有方法，且也是工厂模式来返回操作的类
        SqlSession sqlSession = build.openSession();
        User o = sqlSession.selectOne("User.selectOne", user);
        System.out.println(o);
        return o;

    }
}

很明显，上面我们若要操作一个执行，必然会有重复的操作，而由于大多数我们并不会操作一个方法里面，所以有重复问题：

 InputStream resourceAsSteam = Resources.getResourceAsSteam("sqlMapConfig.xml");
        //读取配置信息，并通过工厂模式返回一个可以操作的类
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsSteam);
        //每个可以操作的类也有方法，且也是工厂模式来返回操作的类
        SqlSession sqlSession = build.openSession();

所以我们需要进行提取，当然，实际上虽然他封装的，但是你调用他们还是执行的，即还是存在很多代码（这里包括mybatis中的接口操作，所以一般其只是操作包地址来解决后面的标识，而不是用方法包括而已，因为方法的名称是固定的，而他们不是）

其中statementId存在硬编码，当然，对于读取配置文件来说，必然需要存在的，因为代码直接总要有个联系吧，而我们只能降低联系，那么我们也要就解决这个硬编码，那么如何解决呢，我们使用代理来解决

对于提取来说，并不需要说明，但是这个硬编码我们需要进行操作，现在，我们将实现类删除，在框架项目的SqlSession中加上如下：

//为Dao接口生成代理实现类
    public <T> T getMapper(Class<?> mapperClass);

在DefaultSqlSession实现类中加上如下：

 @Override
    public  <T> T getMapper(Class<?> mapperClass) {
        //使用JDk动态代理，来为Dao接口生成代理对象，并返回
        /*
        Proxy.newProxyInstance()方法的参数介绍：
        ClassLoader loader,
        类加载器，反射基本也是可以是类加载器来操作的（他可以操作Class，一般也有其他功能，所以这里是类加载器），这里可以借助被代理对象获取到类加载器
        由于大多数的类加载器是一样的，所以这个参数基本可以随便使用某个类的加载器
        Class[] interfaces,
        被代理类所需要实现的全部接口，所以是数组，注意是接口的Class类型哦，一般这里代表返回值类型(因为代理类与他相关，实现他)
        InvocationHandler h
        当代理对象调用接口中的任意方法时，那么都会执行InvocationHandler的invoke方法
         */
        Object o = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{mapperClass}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // 得到接口方法的名称
                String methodName = method.getName();
                // 得到接口方法当前接口（method.getDeclaringClass()）的名称（getName()）
                String className = method.getDeclaringClass().getName();
                //statementid
                String key = className + "." + methodName;
                //得到对应statementid的信息
                MappedStatement mappedStatement = configuration.getMappedStatementMap().get(key);
                //得到接口方法的返回值类型
                Type genericReturnType = method.getGenericReturnType();
                //判断是否实现泛型类型参数化，也就是说，如果返回值类型有泛型，那么返回true
                if (genericReturnType instanceof ParameterizedType) {
                    return selectList(key, args);

                }
                return selectOne(key, args);
            }
        });
        return (T) o;
    }
//很明显，上面是将接口的路径（全限定名，是在项目的路径）和名称作为配置文件的对应的statementid，其中我们并不操作

现在在另外一个窗口项目中，修改如下（记得同步主项目的接口或者类）：

package com;

import com.Res.Resources;
import com.dao.UserMapper;
import com.sqlsession.SqlSession;
import com.sqlsession.SqlSessionFactory;
import com.sqlsession.SqlSessionFactoryBuilder;

import java.io.InputStream;
import java.util.List;

/**
 *
 */
public class a {
    public static void main(String[] args) throws Exception {
        InputStream resourceAsSteam = Resources.getResourceAsSteam("sqlMapConfig.xml");
        //读取配置信息，并通过工厂模式返回一个可以操作的类
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsSteam);
        //每个可以操作的类也有方法，且也是工厂模式来返回操作的类
        SqlSession sqlSession = build.openSession();
        User user = new User();
        user.setId(2);
        user.setUsername("tom");

//        User o = sqlSession.selectOne("User.selectOne", user);
//        System.out.println(o);
//        List