天哪！手动编写mybatis雏形竟然长这样

悠悠 2023-02-12 07:30 13阅读 0赞

# 前言 #

mybaits 在ORM 框架中，可算是半壁江山了，由于它是轻量级，半自动加载，灵活性和易拓展性。深受广大公司的喜爱，所以我们程序开发也离不开mybatis 。但是我们有对mabtis 源码进行研究吗？或者想看但是不知道怎么看的苦恼吗？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70]  
归根结底，我们还是需要知道为什么会有mybatis ,mybatis 解决了什么问题？  
想要知道mybatis 解决了什么问题，就要知道传统的JDBC 操作存在哪些痛点才促使mybatis 的诞生。  
我们带着这些疑问，再来一步步学习吧。

# 原始JDBC 存在的问题 #

所以我们先来来看下原始JDBC 的操作:  
我们知道最原始的数据库操作。分为以下几步：  
1、获取connection 连接  
2、获取preparedStatement  
3、参数替代占位符  
4、获取执行结果resultSet  
5、解析封装resultSet 到对象中返回。

如下是原始JDBC 的查询代码，存在哪些问题？

public static void main(String[] args) {
            String dirver="com.mysql.jdbc.Driver";
            String url="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8";
            String userName="root";
            String password="123456";
    
            Connection connection=null;
            List<User> userList=new ArrayList<>();
            try {
                Class.forName(dirver);
                connection= DriverManager.getConnection(url,userName,password);
    
                String sql="select * from user where username=?";
                PreparedStatement preparedStatement=connection.prepareStatement(sql);
                preparedStatement.setString(1,"张三");
                System.out.println(sql);
                ResultSet resultSet=preparedStatement.executeQuery();
    
                User user=null;
                while(resultSet.next()){
                    user=new User();
                    user.setId(resultSet.getInt("id"));
                    user.setUsername(resultSet.getString("username"));
                    user.setPassword(resultSet.getString("password"));
                    userList.add(user);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if (!userList.isEmpty()) {
                for (User user : userList) {
                    System.out.println(user.toString());
                }
            }
    
        }

小伙伴们发现了上面有哪些不友好的地方？  
我这里总结了以下几点:  
1、数据库的连接信息存在硬编码，即是写死在代码中的。  
2、每次操作都会建立和释放connection 连接，操作资源的不必要的浪费。  
3、sql 和参数存在硬编码。  
4、将返回结果集封装成实体类麻烦，要创建不同的实体类，并通过set方法一个个的注入。

存在上面的问题，所以mybatis 就对上述问题进行了改进。  
对于硬编码，我们很容易就想到配置文件来解决。mybatis 也是这么解决的。  
对于资源浪费，我们想到使用连接池，mybatis 也是这个解决的。  
对于封装结果集麻烦，我们想到是用JDK的反射机制，好巧，mybatis 也是这么解决的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 1]

# 设计思路 #

既然如此，我们就来写一个自定义持久层框架，来解决上述问题，当然是参照mybatis 的设计思路，这样我们在写完之后，再来看mybatis 的源码就恍然大悟，这个地方这样配置原来是因为这样啊。  
我们分为使用端和框架端两部分。

## 使用端 ##

我们在使用mybatis 的时候是不是需要使用SqlMapConfig.xml 配置文件，用来存放数据库的连接信息，以及mapper.xml 的指向信息。mapper.xml 配置文件用来存放sql 信息。  
所以我们在使用端来创建两个文件SqlMapConfig.xml 和mapper.xml。

## 框架端 ##

框架端要做哪些事情呢？如下：  
1、获取配置文件。也就是获取到使用端的SqlMapConfig.xml 以及mapper.xml的 文件  
2、解析配置文件。对获取到的文件进行解析，获取到连接信息，sql，参数，返回类型等等。这些信息都会保存在configuration 这个对象中。  
3、创建SqlSessionFactory，目的是创建SqlSession的一个实例。  
4、创建SqlSession ,用来完成上面原始JDBC 的那些操作。

那在SqlSession 中 进行了哪些操作呢？  
1、获取数据库连接  
2、获取sql,并对sql 进行解析  
3、通过内省，将参数注入到preparedStatement 中  
4、执行sql  
5、通过反射将结果集封装成对象

# 使用端实现 #

好了，上面说了一下，大概的设计思路，主要也是仿照mybatis 主要的类实现的，保证类名一致，方便我们后面阅读源码。我们先来配置好使用端吧，我们创建一个maven 项目。  
在项目中，我们创建一个User实体类

public class User {
        private Integer id;
        private String username;
        private String password;
        private String birthday;
        //getter()和setter()方法
    }

创建SqlMapConfig.xml 和Mapper.xml  
**SqlMapConfig.xml**

<?xml version="1.0" encoding="UTF-8" ?>
    <configuration>
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false"></property>
        <property name="userName" value="root"></property>
        <property name="password" value="123456"></property>
        
        <mapper resource="UserMapper.xml">
        </mapper>
    </configuration>

可以看到我们xml 中就配置了数据库的连接信息，以及mapper 一个索引。mybatis中的SqlMapConfig.xml 中还包含其他的标签，只是丰富了功能而已，所以我们只用最主要的。

**mapper.xml**  
是每个类的sql 都会生成一个对应的mapper.xml 。我们这里就用User 类来说吧，所以我们就创建一个UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
    <mapper namespace="cn.quellanan.dao.UserDao">
        <select id="selectAll" resultType="cn.quellanan.pojo.User">
            select * from user
        </select>
        <select id="selectByName" resultType="cn.quellanan.pojo.User" paramType="cn.quellanan.pojo.User">
            select * from user where username=#{username}
        </select>
    </mapper>

可以看到有点mybatis 里面文件的味道，有namespace表示命名空间，id 唯一标识，resultType 返回结果集的类型，paramType 参数的类型。  
我们使用端先创建到这，主要是两个配置文件，我们接下来看看框架端是怎么实现的。

加油哈哈。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 2]

# 框架端实现 #

框架端，我们按照上面的设计思路一步一步来。

## 获取配置 ##

怎么样获取配置文件呢？我们可以使用JDK自带自带的类Resources加载器来获取文件。我们创建一个自定义Resource类来封装一下：

import java.io.InputStream;
    public class Resources {
        public  static InputStream getResources(String path){
            //使用系统自带的类Resources加载器来获取文件。
            return Resources.class.getClassLoader().getResourceAsStream(path);
        }
    }

这样通过传入路径，就可以获取到对应的文件流啦。

## 解析配置文件 ##

上面获取到了SqlMapConfig.xml 配置文件，我们现在来解析它。  
不过在此之前，我们需要做一点准备工作，就是解析的内存放到什么地方？  
所以我们来创建两个实体类Mapper 和Configuration。

**Mapper**  
Mapper 实体类用来存放使用端写的mapper.xml 文件的内容，我们前面说了里面有.id、sql、resultType 和paramType .所以我们创建的Mapper实体如下：

public class Mapper {
        private String id;
        private Class<?> resultType;
        private Class<?> parmType;
        private String sql;
        //getter()和setter()方法
    }

这里我们为什么不添加namespace 的值呢？  
聪明的你肯定发现了，因为mapper里面这些属性表明每个sql 都对应一个mapper,而namespace 是一个命名空间，算是sql 的上一层，所以在mapper中暂时使用不到，就没有添加了。

**Configuration**  
Configuration 实体用来保存SqlMapConfig 中的信息。所以需要保存数据库连接，我们这里直接用JDK提供的 DataSource。还有一个就是mapper 的信息。每个mapper 有自己的标识，所以这里采用hashMap来存储。如下:

public class Configuration {
    
        private DataSource dataSource;
        HashMap <String,Mapper> mapperMap=new HashMap<>();
        //getter()和setter方法
        }

### XmlMapperBuilder ###

做好了上面的准备工作，我们先来解析mapper 吧。我们创建一个XmlMapperBuilder 类来解析。通过dom4j 的工具类来解析XML 文件。我这里用的dom4j 依赖为:

思路：  
1、获取文件流，转成document。  
2、获取根节点，也就是mapper。获取根节点的namespace属性值  
3、获取select 节点，获取其id，sql,resultType，paramType  
4、将select 节点的属性封装到Mapper 实体类中。  
5、同理获取update/insert/delete 节点的属性值封装到Mapper 中  
6、通过namespace.id 生成key 值将mapper对象保存到Configuration实体中的HashMap 中。  
7、返回 Configuration实体  
代码如下：

public class XmlMapperBuilder {
        private Configuration configuration;
        public XmlMapperBuilder(Configuration configuration){
            this.configuration=configuration;
        }
    
        public Configuration loadXmlMapper(InputStream in) throws DocumentException, ClassNotFoundException {
            Document document=new SAXReader().read(in);
    
            Element rootElement=document.getRootElement();
            String namespace=rootElement.attributeValue("namespace");
    
            List<Node> list=rootElement.selectNodes("//select");
    
            for (int i = 0; i < list.size(); i++) {
                Mapper mapper=new Mapper();
                Element element= (Element) list.get(i);
                String id=element.attributeValue("id");
                mapper.setId(id);
                String paramType = element.attributeValue("paramType");
                if(paramType!=null && !paramType.isEmpty()){
                    mapper.setParmType(Class.forName(paramType));
                }
                String resultType = element.attributeValue("resultType");
                if (resultType != null && !resultType.isEmpty()) {
                    mapper.setResultType(Class.forName(resultType));
                }
                mapper.setSql(element.getTextTrim());
                String key=namespace+"."+id;
                configuration.getMapperMap().put(key,mapper);
            }
            return configuration;
        }
    
    }

上面我只解析了select 标签。大家可以解析对应insert/delete/uupdate 标签，操作都是一样的。

### XmlConfigBuilder ###

我们再来解析一下SqlMapConfig.xml 配置信息思路是一样的，  
1、获取文件流，转成document。  
2、获取根节点，也就是configuration。  
3、获取根节点中所有的property 节点，并获取值，也就是获取数据库连接信息  
4、创建一个dataSource 连接池  
5、将连接池信息保存到Configuration实体中  
6、获取根节点的所有mapper 节点  
7、调用XmlMapperBuilder 类解析对应mapper 并封装到Configuration实体中  
8、完  
代码如下：

public class XmlConfigBuilder {
        private Configuration configuration;
        public XmlConfigBuilder(Configuration configuration){
            this.configuration=configuration;
        }
    
        public Configuration loadXmlConfig(InputStream in) throws DocumentException, PropertyVetoException, ClassNotFoundException {
    
            Document document=new SAXReader().read(in);
    
            Element rootElement=document.getRootElement();
    
            //获取连接信息
            List<Node> propertyList=rootElement.selectNodes("//property");
            Properties properties=new Properties();
    
            for (int i = 0; i < propertyList.size(); i++) {
                Element element = (Element) propertyList.get(i);
                properties.setProperty(element.attributeValue("name"),element.attributeValue("value"));
            }
    		//是用连接池
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            dataSource.setDriverClass(properties.getProperty("driverClass"));
            dataSource.setJdbcUrl(properties.getProperty("jdbcUrl"));
            dataSource.setUser(properties.getProperty("userName"));
            dataSource.setPassword(properties.getProperty("password"));
            configuration.setDataSource(dataSource);
    
            //获取mapper 信息
            List<Node> mapperList=rootElement.selectNodes("//mapper");
            for (int i = 0; i < mapperList.size(); i++) {
                Element element= (Element) mapperList.get(i);
                String mapperPath=element.attributeValue("resource");
                XmlMapperBuilder xmlMapperBuilder = new XmlMapperBuilder(configuration);
                configuration=xmlMapperBuilder.loadXmlMapper(Resources.getResources(mapperPath));
            }
            return configuration;
        }
    }

## 创建SqlSessionFactory ##

完成解析后我们创建SqlSessionFactory 用来创建Sqlseesion 的实体，这里为了尽量还原mybatis 设计思路，也也采用的工厂设计模式。  
SqlSessionFactory 是一个接口，里面就一个用来创建SqlSessionf的方法。  
如下：

public interface SqlSessionFactory {
        public SqlSession openSqlSession();
    }

单单这个接口是不够的，我们还得写一个接口的实现类，所以我们创建一个DefaultSqlSessionFactory。  
如下：

public class DefaultSqlSessionFactory implements SqlSessionFactory {
    
        private Configuration configuration;
    
        public DefaultSqlSessionFactory(Configuration configuration) {
            this.configuration = configuration;
        }
        public SqlSession openSqlSession() {
            return new DefaultSqlSeeion(configuration);
        }
    }

可以看到就是创建一个DefaultSqlSeeion并将包含配置信息的configuration 传递下去。DefaultSqlSeeion 就是SqlSession 的一个实现类。

## 创建SqlSession ##

在SqlSession 中我们就要来处理各种操作了，比如selectList，selectOne，insert.update,delete 等等。  
我们这里SqlSession 就先写一个selectList 方法。  
如下：

public interface SqlSession {
    
        /**
         * 条件查找
         * @param statementid  唯一标识，namespace.selectid
         * @param parm  传参，可以不传也可以一个，也可以多个
         * @param <E>
         * @return
         */
        public <E> List<E> selectList(String statementid,Object...parm) throws Exception;

然后我们创建DefaultSqlSeeion 来实现SqlSeesion 。

public class DefaultSqlSeeion implements SqlSession {
        private Configuration configuration;
    	private Executer executer=new SimpleExecuter();
    	
        public DefaultSqlSeeion(Configuration configuration) {
            this.configuration = configuration;
        }
    
    	@Override
        public <E> List<E> selectList(String statementid, Object... parm) throws Exception {
            Mapper mapper=configuration.getMapperMap().get(statementid);
            List<E> query = executer.query(configuration, mapper, parm);
            return query;
        }
    
    }

我们可以看到DefaultSqlSeeion 获取到了configuration，并通过statementid 从configuration 中获取mapper。 然后具体实现交给了Executer 类来实现。我们这里先不管Executer 是怎么实现的，就假装已经实现了。那么整个框架端就完成了。通过调用Sqlsession.selectList() 方法，来获取结果。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 3]  
感觉我们都还没有处理，就框架搭建好了？骗鬼呢，确实前面我们从获取文件解析文件，然后创建工厂。都是做好准备工作。下面开始我们JDBC的实现。

# SqlSession 具体实现 #

我们前面说SqlSeesion 的具体实现有下面5步  
1、获取数据库连接  
2、获取sql,并对sql 进行解析  
3、通过内省，将参数注入到preparedStatement 中  
4、执行sql  
5、通过反射将结果集封装成对象

但是我们在DefaultSqlSeeion 中将实现交给了Executer来执行。所以我们就要在Executer中来实现这些操作。

我们首先来创建一个Executer 接口，并写一个DefaultSqlSeeion中调用的query 方法。

public interface Executer {
    
        <E> List<E> query(Configuration configuration,Mapper mapper,Object...parm) throws Exception;
    
    }

接着我们写一个SimpleExecuter 类来实现Executer 。  
然后SimpleExecuter.query()方法中，我们一步一步的实现。

## 获取数据库连接 ##

因为数据库连接信息保存在configuration，所以直接获取就好了。

//获取连接
            connection=configuration.getDataSource().getConnection();

## 获取sql,并对sql 进行解析 ##

我们这里想一下，我们在Usermapper.xml写的sql 是什么样子？

select * from user where username=#{username}

\#\{username\} 这样的sql 我们该怎么解析呢？

分两步  
1、将sql 找到\#\{\*\*\*\},并将这部分替换成 ？号

2、对 \#\{\*\*\*\} 进行解析获取到里面的参数对应的paramType 中的值。

具体实现用到下面几个类。  
GenericTokenParser类，可以看到有三个参数，开始标记，就是我们的“\#\{” ，结束标记就是 “\}”, 标记处理器就是处理标记里面的内容也就是username。

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()方法来实现
       */
      public String parse(String text) {
     	 //具体实现
     	 }
      ｝

主要的就是parse() 方法，用来获取操作1 的sql。获取结果例如：

select * from user where username=?

那上面用到TokenHandler 来处理参数。  
ParameterMappingTokenHandler实现TokenHandler的类

public class ParameterMappingTokenHandler implements TokenHandler {
    	private List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();
    
    	// 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;
    	}
    
    }

可以看到将参数名称存放 ParameterMapping 的集合中了。  
ParameterMapping 类就是一个实体，用来保存参数名称的。

public class ParameterMapping {
    
        private String content;
    
        public ParameterMapping(String content) {
            this.content = content;
        }
    	//getter()和setter() 方法。
    }

所以我们在我们通过GenericTokenParser类，就可以获取到解析后的sql,以及参数名称。我们将这些信息封装到BoundSql实体类中。

public class BoundSql {
    
        private String sqlText;
        private List<ParameterMapping> parameterMappingList=new ArrayList<>();
        public BoundSql(String sqlText, List<ParameterMapping> parameterMappingList) {
            this.sqlText = sqlText;
            this.parameterMappingList = parameterMappingList;
        }
        getter()和setter() 方法。
      }

好了，那么分两步走，先获取，后解析  
**获取**  
获取原始sql 很简单，sql 信息就存在mapper 对象中，直接获取就好了。

String sql=mapper.getSql()

**解析**  
1、创建一个ParameterMappingTokenHandler 处理器  
2、创建一个GenericTokenParser 类，并初始化开始标记，结束标记，处理器  
3、执行genericTokenParser.parse(sql);获取解析后的sql‘’，以及在parameterMappingTokenHandler 中存放了参数名称的集合。  
4、将解析后的sql 和参数封装到BoundSql 实体类中。

/**
         * 解析自定义占位符
         * @param sql
         * @return
         */
        private BoundSql getBoundSql(String sql){
            ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
            GenericTokenParser genericTokenParser = new GenericTokenParser("#{","}",parameterMappingTokenHandler);
            String parse = genericTokenParser.parse(sql);
            return new BoundSql(parse,parameterMappingTokenHandler.getParameterMappings());
    
        }

## 将参数注入到preparedStatement 中 ##

上面的就完成了sql,的解析，但是我们知道上面得到的sql 还是包含 JDBC的 占位符，所以我们需要将参数注入到preparedStatement 中。  
1、通过boundSql.getSqlText()获取带有占位符的sql.  
2、接收参数名称集合 parameterMappingList  
3、通过mapper.getParmType() 获取到参数的类。  
4、通过getDeclaredField(content)方法获取到参数类的Field。  
5、通过Field.get() 从参数类中获取对应的值  
6、注入到preparedStatement 中

BoundSql boundSql=getBoundSql(mapper.getSql());
            String sql=boundSql.getSqlText();
            List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
    
            //获取preparedStatement，并传递参数值
            PreparedStatement preparedStatement=connection.prepareStatement(sql);
            Class<?> parmType = mapper.getParmType();
    
            for (int i = 0; i < parameterMappingList.size(); i++) {
                ParameterMapping parameterMapping = parameterMappingList.get(i);
                String content = parameterMapping.getContent();
                Field declaredField = parmType.getDeclaredField(content);
                declaredField.setAccessible(true);
                Object o = declaredField.get(parm[0]);
                preparedStatement.setObject(i+1,o);
            }
            System.out.println(sql);
            return preparedStatement;

## 执行sql ##

其实还是调用JDBC 的executeQuery()方法或者execute()方法

//执行sql
     ResultSet resultSet = preparedStatement.executeQuery();

## 通过反射将结果集封装成对象 ##

在获取到resultSet 后，我们进行封装处理，和参数处理是类似的。  
1、创建一个ArrayList  
2、获取返回类型的类  
3、循环从resultSet中取数据  
4、获取属性名和属性值  
5、创建属性生成器  
6、为属性生成写方法，并将属性值写入到属性中  
7、将这条记录添加到list 中  
8、返回list

/**
         * 封装结果集
         * @param mapper
         * @param resultSet
         * @param <E>
         * @return
         * @throws Exception
         */
        private <E> List<E> resultHandle(Mapper mapper,ResultSet resultSet) throws Exception{
            ArrayList<E> list=new ArrayList<>();
            //封装结果集
            Class<?> resultType = mapper.getResultType();
            while (resultSet.next()) {
                ResultSetMetaData metaData = resultSet.getMetaData();
                Object o = resultType.newInstance();
                int columnCount = metaData.getColumnCount();
                for (int i = 1; i <= columnCount; i++) {
                    //属性名
                    String columnName = metaData.getColumnName(i);
                    //属性值
                    Object value = resultSet.getObject(columnName);
                    //创建属性描述器,为属性生成读写方法
                    PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName,resultType);
                    Method writeMethod = propertyDescriptor.getWriteMethod();
                    writeMethod.invoke(o,value);
                }
                list.add((E) o);
            }
            return list;
        }

# 创建SqlSessionFactoryBuilder #

我们现在来创建一个SqlSessionFactoryBuilder 类，来为使用端提供一个人口。

public class SqlSessionFactoryBuilder {
    
        private Configuration configuration;
    
        public SqlSessionFactoryBuilder(){
            configuration=new Configuration();
        }
    
        public SqlSessionFactory build(InputStream in) throws DocumentException, PropertyVetoException, ClassNotFoundException {
            XmlConfigBuilder xmlConfigBuilder = new XmlConfigBuilder(configuration);
            configuration=xmlConfigBuilder.loadXmlConfig(in);
    
            SqlSessionFactory sqlSessionFactory = new DefaultSqlSessionFactory(configuration);
            return sqlSessionFactory;
        }
    }

可以看到就一个build 方法，通过SqlMapConfig的文件流将信息解析到configuration，创建并返回一个sqlSessionFactory 。

到此，整个框架端已经搭建完成了，但是我们可以看到，只实现了select 的操作，update、inster、delete 的操作我们在我后面提供的源码中会有实现，这里只是将整体的设计思路和流程。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 4]

# 测试 #

终于到了测试的环节啦。我们前面写了自定义的持久层，我们现在来测试一下能不能正常的使用吧。  
见证奇迹的时刻到啦  
![在这里插入图片描述][20200525175716513.png]

我们先引入我们自定义的框架依赖。以及数据库和单元测试

<dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.11</version>
            </dependency>
            <dependency>
                <groupId>cn.quellanan</groupId>
                <artifactId>myself-mybatis</artifactId>
                <version>1.0.0</version>
            </dependency>
    
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.10</version>
            </dependency>

然后我们写一个测试类  
1、获取SqlMapperConfig.xml的文件流  
2、获取Sqlsession  
3、执行查找操作

@org.junit.Test
        public void test() throws Exception{
            InputStream inputStream= Resources.getResources("SqlMapperConfig.xml");
            SqlSession sqlSession = new SqlSessionFactoryBuilder().build(inputStream).openSqlSession();
            List<User> list = sqlSession.selectList("cn.quellanan.dao.UserDao.selectAll");
    
            for (User parm : list) {
                System.out.println(parm.toString());
            }
            System.out.println();
    
            User user=new User();
            user.setUsername("张三");
            List<User> list1 = sqlSession.selectList("cn.quellanan.dao.UserDao.selectByName", user);
            for (User user1 : list1) {
                System.out.println(user1);
            }
    
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 5]  
可以看到已经可以了，看来我们自定义的持久层框架生效啦。  
![在这里插入图片描述][20200525183337612.png]

# 优化 #

但是不要高兴的太早哈哈，我们看上面的测试方法，是不是感觉和平时用的不一样，每次都都写死statementId ,这样不太友好，所以我们接下来来点骚操作，通用mapper 配置。  
我们在SqlSession中增加一个getMapper方法，接收的参数是一个类。我们通过这个类就可以知道statementId .

/**
         * 使用代理模式来创建接口的代理对象
         * @param mapperClass
         * @param <T>
         * @return
         */
        public <T> T getMapper(Class<T> mapperClass);

具体实现就是利用JDK 的动态代理机制。  
1、通过Proxy.newProxyInstance() 获取一个代理对象  
2、返回代理对象  
那代理对象执行了哪些操作呢？  
创建代理对象的时候，会实现一个InvocationHandler接口，重写invoke() 方法，让所有走这个代理的方法都会执行这个invoke() 方法。那这个方法做了什么操作？  
这个方法就是通过传入的类对象，获取到对象的类名和方法名。用来生成statementid 。所以我们在mapper.xml 配置文件中的namespace 就需要制定为类路径，以及id 为方法名。  
实现方法：

@Override
        public <T> T getMapper(Class<T> mapperClass) {
    
            Object proxyInstance = Proxy.newProxyInstance(DefaultSqlSeeion.class.getClassLoader(), new Class[]{mapperClass}, new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
                    //获取到方法名
                    String name = method.getName();
                    //类型
                    String className = method.getDeclaringClass().getName();
                    String statementid=className+"."+name;
    
                    return selectList(statementid,args);
                }
            });
    
    
            return (T) proxyInstance;
        }

我们写一个UserDao

public interface UserDao {
        List<User> selectAll();
    
        List<User> selectByName(User user);
    }

这个是不是我们熟悉的味道哈哈，就是mapper层的接口。  
然后我们在mapper.xml 中指定namespace 和id  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 6]  
接下来我们在写一个测试方法

@org.junit.Test
        public void test2() throws Exception{
            InputStream inputStream= Resources.getResources("SqlMapperConfig.xml");
            SqlSession sqlSession = new SqlSessionFactoryBuilder().build(inputStream).openSqlSession();
    
            UserDao mapper = sqlSession.getMapper(UserDao.class);
            List<User> users = mapper.selectAll();
            for (User user1 : users) {
                System.out.println(user1);
            }
    
            User user=new User();
            user.setUsername("张三");
            List<User> users1 = mapper.selectByName(user);
            for (User user1 : users1) {
                System.out.println(user1);
            }
    
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 7]

# 番外 #

自定义的持久层框架，我们就写完了。这个实际上就是mybatis 的雏形，我们通过自己手动写一个持久层框架，然后在来看mybatis 的源码，就会清晰很多。下面这些类名在mybatis 中都有体现。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 8]  
这是我在拉勾训练营学习之后，跟着老师动手写的一个 mybatis 雏形，自己动手写出来还是很有成就感的，并且对 mybatis 源码有更深的了解。这里抛砖引玉，祝君阅读源码愉快。觉得有用的兄弟们记得收藏啊。

**厚颜无耻的求波点赞！！！**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 9]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200525135721614.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200525144114112.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020052515193478.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200525164015861.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/2020052517543075.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx,size_16,color_FFFFFF,t_70
[20200525175716513.png]: https://img-blog.csdnimg.cn/20200525175716513.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200525181138287.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx,size_16,color_FFFFFF,t_70
[20200525183337612.png]: https://img-blog.csdnimg.cn/20200525183337612.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/2020052518492815.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200525185139887.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200525185501726.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200525185842986.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx,size_16,color_FFFFFF,t_70