我们来自定义一个持久层框架，也就是Mybatis的简易版。

使用端的搭建

idea中新建maven工程IPersistence_test：



在resources目录下新建sqlMapConfig.xml文件，

  1. <Configuration>
  2.     <dataSource>
  3.         <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  4.         <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/lagou?useUnicode=true&amp;characterEncoding=utf8&amp;zeroDateTimeBehavior=convertToNull&amp;useSSL=false"></property>
  5.         <property name="user" value="root"></property>
  6.         <property name="password" value="000"></property>
  7.     </dataSource>
  9.     <mapper resource="UserMapper.xml"></mapper>
  11. </Configuration>

UserMapper.xml:

  1. <mapper namespace="user">
  2. <select id="selectOne" paramterType="com.lagou.pojo.User"
  3. resultType="com.lagou.pojo.User">
  4. select * from user where id = #{id} and username =#{username}
  5. </select>
  6. <select id="selectList" resultType="com.lagou.pojo.User">
  7. select * from user
  8. </select>
  9. </mapper>

User实体类：

  1. package com.lagou.test;
  3. /**
  4.  * @author liuyj
  5.  * @Title: User
  6.  * @create 2020-05-29 15:06
  7.  * @ProjectName lagou_project
  8.  * @Description: TODO
  9.  */
  10. public class User {
  11.     private Integer id;
  12.     private String username;
  14.     public Integer getId() {
  15.         return id;
  16.     }
  18.     public void setId(Integer id) {
  19.         this.id = id;
  20.     }
  22.     public String getUsername() {
  23.         return username;
  24.     }
  26.     public void setUsername(String username) {
  27.         this.username = username;
  28.     }
  30.     @Override
  31.     public String toString() {
  32.         return "User{" +
  33.                 "id=" + id +
  34.                 ", username='" + username + '\'' +
  35.                 '}';
  36.     }
  37. }

使用端暂时就搭建完成。

持久层框架端的搭建

下面我们来搭建持久层框架：

新建一个module,maven项目：IPersistence

pom.xml中引入一下依赖

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>mysql</groupId>
  4.             <artifactId>mysql-connector-java</artifactId>
  5.             <version>5.1.44</version>
  6.         </dependency>
  7.         <!-- 连接池-->
  8.         <dependency>
  9.             <groupId>c3p0</groupId>
  10.             <artifactId>c3p0</artifactId>
  11.             <version>0.9.1.2</version>
  12.         </dependency>
  13.         <dependency>
  14.             <groupId>log4j</groupId>
  15.             <artifactId>log4j</artifactId>
  16.             <version>1.2.12</version>
  17.         </dependency>
  18.         <dependency>
  19.             <groupId>junit</groupId>
  20.             <artifactId>junit</artifactId>
  21.             <version>4.10</version>
  22.         </dependency>
  23.         <!-- 解析xml文件-->
  24.         <dependency>
  25.             <groupId>dom4j</groupId>
  26.             <artifactId>dom4j</artifactId>
  27.             <version>1.6.1</version>
  28.         </dependency>
  29.         <dependency>
  30.             <groupId>jaxen</groupId>
  31.             <artifactId>jaxen</artifactId>
  32.             <version>1.1.6</version>
  33.         </dependency>
  34.     </dependencies>

创建一个Configuration类,主要是存放从sqlMapConfig.xml和Usermapper.xml配置文件中解析出来的一些元素和内容，用来一层层向下传递：

  1. package com.lagou.pojo;
  3. import javax.sql.DataSource;
  4. import java.util.HashMap;
  5. import java.util.Map;
  7. /**
  8.  * @author liuyj
  9.  * @Title: Configuration
  10.  * @create 2020-05-27 15:20
  11.  * @ProjectName IPersistence
  12.  * @Description:  存放sqlMapConfig.xml解析出来的内容
  13.  */
  14. public class Configuration {
  15.     //存放数据库配置信息，从sqlMapConfig.xml中解析出来
  16.     private DataSource dataSource;
  18.     //存放Mapper.xml中解析出来的内容，key是statementId
  19.     private Map<String,MappedStatement> mappedStatementMap=new HashMap<String, MappedStatement>();
  21.     public DataSource getDataSource() {
  22.         return dataSource;
  23.     }
  25.     public void setDataSource(DataSource dataSource) {
  26.         this.dataSource = dataSource;
  27.     }
  29.     public Map<String, MappedStatement> getMappedStatementMap() {
  30.         return mappedStatementMap;
  31.     }
  33.     public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) {
  34.         this.mappedStatementMap = mappedStatementMap;
  35.     }
  36. }

其中DataSource 封装的是数据库信息，Configuration中封装了一个对象MappedStatement:

  1. package com.lagou.pojo;
  3. /**
  4.  * @author liuyj
  5.  * @Title: MappedStatement
  6.  * @create 2020-05-27 15:13
  7.  * @ProjectName IPersistence
  8.  * @Description: 存放UserMapper.xml解析出来的内容
  9.  */
  10. public class MappedStatement {
  11.     //id标识
  12.     private String id;
  14.     //返回值类型
  15.     private String resultType;
  17.     //传入参数类型
  18.     private String paramenterType;
  20.     //sql
  21.     private String sql;
  23.     public String getId() {
  24.         return id;
  25.     }
  27.     public void setId(String id) {
  28.         this.id = id;
  29.     }
  31.     public String getResultType() {
  32.         return resultType;
  33.     }
  35.     public void setResultType(String resultType) {
  36.         this.resultType = resultType;
  37.     }
  39.     public String getParamenterType() {
  40.         return paramenterType;
  41.     }
  43.     public void setParamenterType(String paramenterType) {
  44.         this.paramenterType = paramenterType;
  45.     }
  47.     public String getSql() {
  48.         return sql;
  49.     }
  51.     public void setSql(String sql) {
  52.         this.sql = sql;
  53.     }
  54. }

主要是用来存储从映射配置文件中解析出来的sql查询标签的id及传入参数、返回结果类型、查询的sql等，其中Mapper.xml中每一个标签，

比如：

  1. <select id="selectList" resultType="com.lagou.pojo.User">
  2. select * from user
  3. </select>

都会封装成一个MappedStatement对象,然后所有的MappedStatement对象都被存储到Configuration类中的Map集合mappedStatementMap当中去，Map集合中的key是statementId（statementId由两部分组成，一是Mapper.xml中的namespace，二是每一个标签中的id，比如UserMapper.xml中的selectOne，在Configuration中map集合中的key值就是user.selectOne）。

Resource文件：

主要用来读取xml文件，作为一个字节流存储在内存中：

  1. package com.lagou.io;
  3. import java.io.InputStream;
  5. /**
  6.  * @author liuyj
  7.  * @Title:
  8.  * @create 2020-05-27 14:48
  9.  * @ProjectName IPersistence
  10.  * @Description: TODO
  11.  */
  12. public class Resources {
  14.     //根据配置文件的路径，将配置文件加载成字节输入流，存储在内存中
  15.     public static InputStream getResourceAsStream(String path){
  17.         InputStream resourceStream= Resources.class.getClassLoader().getResourceAsStream(path);
  18.         return resourceStream;
  19.     }
  20. }

SqlSessionFactoryBuilder:

  1. package com.lagou.sqlSession;
  3. import com.lagou.config.XMLConfigBuilder;
  4. import com.lagou.pojo.Configuration;
  5. import org.dom4j.DocumentException;
  7. import java.beans.PropertyVetoException;
  8. import java.io.InputStream;
  10. /**
  11.  * @author liuyj
  12.  * @Title: SqlSessionFactoryBuilder
  13.  * @create 2020-05-27 15:37
  14.  * @ProjectName IPersistence
  15.  * @Description: TODO
  16.  */
  17. public class SqlSessionFactoryBuilder {
  19.     public SqlSessionFactory build(InputStream in) throws DocumentException, PropertyVetoException {
  21.         //第一，使用dom4j解析配置文件，将解析出来的内容封装到configuration中
  22.         XMLConfigBuilder xmlConfigBuilder=new XMLConfigBuilder();
  23.         Configuration configuration = xmlConfigBuilder.parseConfig(in);
  25.         //第二：创建sqlSessionFactory对象:工厂类：生产sqlSession:会话对象
  26.         DefaultSqlSessionFactory defaultSqlSessionFactory=new DefaultSqlSessionFactory(configuration);
  27.         return defaultSqlSessionFactory;
  28.     }
  29. }

XMLConfigBuilder :

使用dom4j解析sqlMapConfig.xml文件，并调用XMLMapperBuilder 中的方法解析Mapper.xml映射文件，将结果封装在Configuration对象中：

  1. package com.lagou.config;
  3. import com.lagou.io.Resources;
  4. import com.lagou.pojo.Configuration;
  5. import com.mchange.v2.c3p0.ComboPooledDataSource;
  6. import org.dom4j.Document;
  7. import org.dom4j.DocumentException;
  8. import org.dom4j.Element;
  9. import org.dom4j.io.SAXReader;
  11. import java.beans.PropertyVetoException;
  12. import java.io.InputStream;
  13. import java.util.List;
  14. import java.util.Properties;
  16. /**
  17.  * @author liuyj
  18.  * @Title: XMLConfigBuilder
  19.  * @create 2020-05-27 15:39
  20.  * @ProjectName IPersistence
  21.  * @Description: TODO
  22.  */
  23. public class XMLConfigBuilder {
  25.     private Configuration configuration;
  26.     public XMLConfigBuilder(){
  27.         this.configuration=new Configuration();
  28.     }
  30.     /**
  31.      *
  32.      *该方法就是使用dom4j将配置文件解析，封装为Configuration
  33.      */
  34.     public Configuration parseConfig(InputStream inputStream) throws DocumentException, PropertyVetoException {
  36.         Document document = new SAXReader().read(inputStream);
  37.         //<Configuration>标签
  38.         Element rootElement = document.getRootElement();
  39.         List<Element> list = rootElement.selectNodes("//property");
  40.         Properties properties=new Properties();
  41.         for (Element element : list) {
  42.             String name = element.attributeValue("name");
  43.             String value = element.attributeValue("value");
  44.             properties.setProperty(name,value);
  45.         }
  47.         ComboPooledDataSource comboPooledDataSource=new ComboPooledDataSource();
  48.         comboPooledDataSource.setDriverClass(properties.getProperty("driverClass"));
  49.         comboPooledDataSource.setJdbcUrl(properties.getProperty("jdbcUrl"));
  50.         comboPooledDataSource.setUser(properties.getProperty("user"));
  51.         comboPooledDataSource.setPassword(properties.getProperty("password"));
  53.         configuration.setDataSource(comboPooledDataSource);
  55.         //解析sqlMapConfig.xml里面的mapper标签，
  56.         // 解析mapper.xml：拿到路径--字节输入流--dom4j解析
  57.         List<Element> mapperList = rootElement.selectNodes("//mapper");
  58.         for (Element element : mapperList) {
  59.             String mapperPath = element.attributeValue("resource");
  60.             InputStream resourceAsStream = Resources.getResourceAsStream(mapperPath);
  61.             XMLMapperBuilder xmlMaperBuilder=new XMLMapperBuilder(configuration);
  62.             xmlMaperBuilder.parse(resourceAsStream);
  63.         }
  64.         return configuration;
  65.     }
  66. }

XMLMapperBuilder :

用来解析映射配置文件Mapper.xml中的内容：

  1. package com.lagou.config;
  3. import com.lagou.pojo.Configuration;
  4. import com.lagou.pojo.MappedStatement;
  5. import org.dom4j.Document;
  6. import org.dom4j.DocumentException;
  7. import org.dom4j.Element;
  8. import org.dom4j.io.SAXReader;
  10. import java.io.InputStream;
  11. import java.util.List;
  13. /**
  14.  * @author liuyj
  15.  * @Title: XMLMapperBuilder
  16.  * @create 2020-05-28 10:59
  17.  * @ProjectName lagou_project
  18.  * @Description: 解析mapper.xml文件
  19.  */
  20. public class XMLMapperBuilder {
  21.     private Configuration configuration;
  22.     public XMLMapperBuilder(Configuration configuration) {
  23.         this.configuration=configuration;
  24.     }
  26.     public void parse(InputStream inputStream) throws DocumentException {
  27.         Document document = new SAXReader().read(inputStream);
  28.         Element rootElement = document.getRootElement();
  29.         String namespace = rootElement.attributeValue("namespace");
  30.         List<Element> list = rootElement.selectNodes("//select");
  31.         for (Element element : list) {
  33.             String id = element.attributeValue("id");
  34.             String parameterType = element.attributeValue("parameterType");
  35.             String resultType = element.attributeValue("resultType");
  36.             String sqlText = element.getTextTrim();
  38.             String key=namespace+"."+id;
  39.             MappedStatement mappedStatement=new MappedStatement();
  40.             mappedStatement.setId(id);
  41.             mappedStatement.setParamenterType(parameterType);
  42.             mappedStatement.setResultType(resultType);
  43.             mappedStatement.setSql(sqlText);
  44.             configuration.getMappedStatementMap().put(key,mappedStatement);
  45.         }
  47.     }
  48. }
  1. package com.lagou.sqlSession;
  3. /**
  4.  * @author liuyj
  5.  * @Title: SqlSessionFactory
  6.  * @create 2020-05-27 15:38
  7.  * @ProjectName IPersistence
  8.  * @Description: TODO
  9.  */
  10. public interface SqlSessionFactory {
  11.     SqlSession openSession();
  12. }
  1. package com.lagou.sqlSession;
  3. import com.lagou.pojo.Configuration;
  5. /**
  6.  * @author liuyj
  7.  * @Title: DefaultSqlSessionFactory
  8.  * @create 2020-05-28 11:38
  9.  * @ProjectName lagou_project
  10.  * @Description: TODO
  11.  */
  12. public class DefaultSqlSessionFactory implements SqlSessionFactory{
  14.     private Configuration configuration;
  16.     public DefaultSqlSessionFactory(Configuration configuration) {
  17.         this.configuration = configuration;
  18.     }
  20.     public SqlSession openSession() {
  21.         return new DefaultSqlSession(configuration);
  22.     }
  23. }

SqlSession及实现类DefaultSqlSession:

  1. package com.lagou.sqlSession;
  3. import java.util.List;
  5. /**
  6.  * @author liuyj
  7.  * @Title: SqlSession
  8.  * @create 2020-05-28 11:56
  9.  * @ProjectName lagou_project
  10.  * @Description: TODO
  11.  */
  12. public interface SqlSession {
  14.     //查询所有
  15.     public <E> List<E> selectList(String statementid, Object... params) throws Exception;
  17.     //根据条件查询单个
  18.     public <T> T selectOne(String statementid,Object... params) throws Exception;
  19.     }
  1. package com.lagou.sqlSession;
  3. import com.lagou.pojo.Configuration;
  4. import com.lagou.pojo.MappedStatement;
  6. import java.lang.reflect.*;
  7. import java.util.List;
  9. /**
  10.  * @author liuyj
  11.  * @Title: DefaultSqlSession
  12.  * @create 2020-05-28 11:57
  13.  * @ProjectName lagou_project
  14.  * @Description: TODO
  15.  */
  16. public class DefaultSqlSession implements SqlSession {
  17.     private Configuration configuration;
  19.     public DefaultSqlSession(Configuration configuration) {
  20.         this.configuration = configuration;
  21.     }
  23.     public <E> List<E> selectList(String statementid, Object... params) throws Exception {
  25.         //将要去完成对simpleExecutor里的query方法的调用
  26.         SimpleExecutor simpleExecutor = new SimpleExecutor();
  27.         MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementid);
  28.         List<Object> list = simpleExecutor.query(configuration, mappedStatement, params);
  30.         return (List<E>) list;
  31.     }
  33.     public <T> T selectOne(String statementid, Object... params) throws Exception {
  34.         List<Object> objects = selectList(statementid, params);
  35.         if(objects.size()==1){
  36.             return (T) objects.get(0);
  37.         }else {
  38.             throw new RuntimeException("查询结果为空或者返回结果过多");
  39.         }
  41.     }
  42.     }

SqlSession实现类中调用的Executor及其实现类SimpleExecutor ：

  1. package com.lagou.sqlSession;
  3. import com.lagou.pojo.Configuration;
  4. import com.lagou.pojo.MappedStatement;
  6. import java.util.List;
  8. /**
  9.  * @author lyj
  10.  * @Title: Executor
  11.  * @ProjectName lagou_project
  12.  * @Description: TODO
  13.  * @date 2020/5/28 22:00
  14.  */
  16. public interface Executor {
  17.     public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception;
  18. }

package com.lagou.sqlSession;

import com.lagou.pojo.Configuration;

import com.lagou.pojo.MappedStatement;

import com.lagou.utils.GenericTokenParser;

import com.lagou.utils.ParameterMapping;

import com.lagou.utils.ParameterMappingTokenHandler;

import java.beans.PropertyDescriptor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.sql.*;

import java.util.ArrayList;

import java.util.List;

/**

  • @author lyj
  • @Title: SimpleExecutor
  • @ProjectName lagou_project
  • @Description: TODO
  • @date 2020/5/28 21:59

    */

public class SimpleExecutor implements Executor {

  1. public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception {
  2.     //注册驱动，获取数据库连接
  3.     Connection connection = configuration.getDataSource().getConnection();
  4.     //获取sql语句：select * from user where id=#{id} and username=#{username}
  5.     //转换sql：select * from user where id=？ and username=？，同时需要对#{}里面的值进行解析存储
  6.     String sql = mappedStatement.getSql();
  7.     BoundSql boundSql=getBoundSql(sql);
  8.     //获取预处理对象preparedStatement
  9.     PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
  11.     //设置参数
  12.       //获取到了参数的全路径
  13.     String paramenterType = mappedStatement.getParamenterType();
  14.     Class<?> parametertypeClass=getClassType(paramenterType);
  16.     List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
  17.     for (int i = 0; i < parameterMappingList.size(); i++) {
  18.         ParameterMapping parameterMapping = parameterMappingList.get(i);
  19.         String content = parameterMapping.getContent();
  20.         //反射
  21.         Field declaredField = parametertypeClass.getDeclaredField(content);
  22.         //暴力访问
  23.         declaredField.setAccessible(true);
  24.         Object o = declaredField.get(params[0]);
  25.         preparedStatement.setObject(i+1,o);
  26.     }
  27.     //执行sql
  28.     ResultSet resultSet = preparedStatement.executeQuery();
  29.     String resultType = mappedStatement.getResultType();
  30.     Class<?> resultTypeClass = getClassType(resultType);
  31.     ArrayList<Object> objects = new ArrayList<Object>();
  33.     //封装返回结果集
  34.     while (resultSet.next()) {
  35.         Object o = resultTypeClass.newInstance();
  36.         //元数据
  37.         ResultSetMetaData metaData = resultSet.getMetaData();
  38.         for (int i = 1; i <= metaData.getColumnCount(); i++) {
  39.             //字段名
  40.             String columnName = metaData.getColumnName(i);
  41.             //字段值
  42.             Object value = resultSet.getObject(columnName);
  44.             //使用反射或者内省，根据数据库表和实体的对应关系，完成封装
  45.             PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass);
  46.             Method writeMethod = propertyDescriptor.getWriteMethod();
  47.             writeMethod.invoke(o,value);
  48.         }
  49.         objects.add(o);
  50.     }
  52.     return (List<E>) objects;
  53. }
  55. /**
  56.  * 完成对#{}的解析工作：1.将#{}使用？代替 ，2.解析出#{}里面的值进行存储
  57.  * @param sql
  58.  * @return
  59.  */
  60. private BoundSql getBoundSql(String sql) {
  61.     //标记处理类：配置标记解析器GenericTokenParser来完成对配置文件的解析工作，其中TokenHandler主要完成处理
  62.     ParameterMappingTokenHandler parameterMappingTokenHandler=new ParameterMappingTokenHandler();

//GenericTokenParser：通用的标记解析器，完成了对代码中占位符的解析，然后再根据给定的标记处理器（TokenHandler）来进行表达式的处理

//三个参数：分别为openToken(开始标记)、closeToken（结束标记）、handler(标记处理器)

  1.     GenericTokenParser genericTokenParser=new GenericTokenParser("#{","}",parameterMappingTokenHandler);
  3.     //解析出来的sql
  4.     String parseSql = genericTokenParser.parse(sql);
  5.     //从#{}里面解析出来的参数名称
  6.     List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
  7.     BoundSql boundSql=new BoundSql(parseSql,parameterMappings);
  9.     return boundSql;
  11. }
  12. }
  13. ```

BoundSql

```java

package com.lagou.sqlSession;

import com.lagou.utils.ParameterMapping;

import java.util.ArrayList;

import java.util.List;

/**

  • @author lyj
  • @Title: BoundSql
  • @ProjectName lagou_project
  • @Description: TODO
  • @date 2020/5/28 22:03

    */

public class BoundSql {

private String sqlText;

private ListparameterMappingList=new ArrayList();

  1. public BoundSql(String sqlText, List<ParameterMapping> parameterMappingList) {
  2.     this.sqlText = sqlText;
  3.     this.parameterMappingList = parameterMappingList;
  4. }
  6. public String getSqlText() {
  7.     return sqlText;
  8. }
  10. public void setSqlText(String sqlText) {
  11.     this.sqlText = sqlText;
  12. }
  14. public List<ParameterMapping> getParameterMappingList() {
  15.     return parameterMappingList;
  16. }
  18. public void setParameterMappingList(List<ParameterMapping> parameterMappingList) {
  19.     this.parameterMappingList = parameterMappingList;
  20. }

}


  2. SimpleExecutor 中使用的几个标记解析器，也附录一下吧，是从mybatis源码中直接拿来用的：
  3. GenericTokenParser
  4. ```java
  5. /**
  6.  *    Copyright 2009-2017 the original author or authors.
  7.  *
  8.  *    Licensed under the Apache License, Version 2.0 (the "License");
  9.  *    you may not use this file except in compliance with the License.
  10.  *    You may obtain a copy of the License at
  11.  *
  12.  *       http://www.apache.org/licenses/LICENSE-2.0
  13.  *
  14.  *    Unless required by applicable law or agreed to in writing, software
  15.  *    distributed under the License is distributed on an "AS IS" BASIS,
  16.  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17.  *    See the License for the specific language governing permissions and
  18.  *    limitations under the License.
  19.  */
  20. package com.lagou.utils;
  22. /**
  23.  * @author Clinton Begin
  24.  */
  25. public class GenericTokenParser {
  27.   private final String openToken; //开始标记
  28.   private final String closeToken; //结束标记
  29.   private final TokenHandler handler; //标记处理器
  31.   public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
  32.     this.openToken = openToken;
  33.     this.closeToken = closeToken;
  34.     this.handler = handler;
  35.   }
  37.   /**
  38.    * 解析${}和#{}
  39.    * @param text
  40.    * @return
  41.    * 该方法主要实现了配置文件、脚本等片段中占位符的解析、处理工作，并返回最终需要的数据。
  42.    * 其中，解析工作由该方法完成，处理工作是由处理器handler的handleToken()方法来实现
  43.    */
  44.   public String parse(String text) {
  45.     // 验证参数问题，如果是null，就返回空字符串。
  46.     if (text == null || text.length()==0) {
  47.       return "";
  48.     }
  50.     // 下面继续验证是否包含开始标签，如果不包含，默认不是占位符，直接原样返回即可，否则继续执行。
  51.     int start = text.indexOf(openToken, 0);
  52.     if (start == -1) {
  53.       return text;
  54.     }
  56.    // 把text转成字符数组src，并且定义默认偏移量offset=0、存储最终需要返回字符串的变量builder，
  57.     // text变量中占位符对应的变量名expression。判断start是否大于-1(即text中是否存在openToken)，如果存在就执行下面代码
  58.     char[] src = text.toCharArray();
  59.     int offset = 0;
  60.     final StringBuilder builder = new StringBuilder();
  61.     StringBuilder expression = null;
  62.     while (start > -1) {
  63.      // 判断如果开始标记前如果有转义字符，就不作为openToken进行处理，否则继续处理
  64.       if (start > 0 && src[start - 1] == '\\') {
  65.         builder.append(src, offset, start - offset - 1).append(openToken);
  66.         offset = start + openToken.length();
  67.       } else {
  68.         //重置expression变量，避免空指针或者老数据干扰。
  69.         if (expression == null) {
  70.           expression = new StringBuilder();
  71.         } else {
  72.           expression.setLength(0);
  73.         }
  74.         builder.append(src, offset, start - offset);
  75.         offset = start + openToken.length();
  76.         int end = text.indexOf(closeToken, offset);
  77.         while (end > -1) {////存在结束标记时
  78.           if (end > offset && src[end - 1] == '\\') {//如果结束标记前面有转义字符时
  79.             // this close token is escaped. remove the backslash and continue.
  80.             expression.append(src, offset, end - offset - 1).append(closeToken);
  81.             offset = end + closeToken.length();
  82.             end = text.indexOf(closeToken, offset);
  83.           } else {//不存在转义字符，即需要作为参数进行处理
  84.             expression.append(src, offset, end - offset);
  85.             offset = end + closeToken.length();
  86.             break;
  87.           }
  88.         }
  89.         if (end == -1) {
  90.           // close token was not found.
  91.           builder.append(src, start, src.length - start);
  92.           offset = src.length;
  93.         } else {
  94.           //首先根据参数的key（即expression）进行参数处理，返回?作为占位符
  95.           builder.append(handler.handleToken(expression.toString()));
  96.           offset = end + closeToken.length();
  97.         }
  98.       }
  99.       start = text.indexOf(openToken, offset);
  100.     }
  101.     if (offset < src.length) {
  102.       builder.append(src, offset, src.length - offset);
  103.     }
  104.     return builder.toString();
  105.   }
  106. }

ParameterMapping:

  1. package com.lagou.utils;
  3. public class ParameterMapping {
  5.     private String content;
  7.     public ParameterMapping(String content) {
  8.         this.content = content;
  9.     }
  11.     public String getContent() {
  12.         return content;
  13.     }
  15.     public void setContent(String content) {
  16.         this.content = content;
  17.     }
  18. }

ParameterMappingTokenHandler:

  1. package com.lagou.utils;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class ParameterMappingTokenHandler implements TokenHandler {
  7. 	private List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();
  9. 	// context是参数名称 #{id} #{username}
  11. 	public String handleToken(String content) {
  12. 		parameterMappings.add(buildParameterMapping(content));
  13. 		return "?";
  14. 	}
  16. 	private ParameterMapping buildParameterMapping(String content) {
  17. 		ParameterMapping parameterMapping = new ParameterMapping(content);
  18. 		return parameterMapping;
  19. 	}
  21. 	public List<ParameterMapping> getParameterMappings() {
  22. 		return parameterMappings;
  23. 	}
  25. 	public void setParameterMappings(List<ParameterMapping> parameterMappings) {
  26. 		this.parameterMappings = parameterMappings;
  27. 	}
  29. }

  2. package com.lagou.utils;
  4. /**
  5.  * @author Clinton Begin
  6.  */
  7. public interface TokenHandler {
  8.   String handleToken(String content);
  9. }

测试使用：

先生成jar包，执行mvn install命令。

mvn install



在使用端IPersistence_test中引入jar包：

  1.   <dependency>
  2.             <groupId>com.lagou</groupId>
  3.             <artifactId>IPersistence</artifactId>
  4.             <version>1.0-SNAPSHOT</version>
  5.         </dependency>

数据库建表：



测试：


  2. package com.lagou.test;
  4. import com.lagou.dao.IUserDao;
  5. import com.lagou.io.Resources;
  6. import com.lagou.sqlSession.SqlSession;
  7. import com.lagou.sqlSession.SqlSessionFactory;
  8. import com.lagou.sqlSession.SqlSessionFactoryBuilder;
  9. import org.dom4j.DocumentException;
  10. import org.junit.Before;
  11. import org.junit.Test;
  13. import java.beans.PropertyVetoException;
  14. import java.io.InputStream;
  16. /**
  17.  * @author liuyj
  18.  * @Title: IPersistenctTest
  19.  * @create 2020-05-27 15:08
  20.  * @ProjectName IPersistence
  21.  * @Description: TODO
  22.  */
  23. public class IPersistenctTest {
  25.       private  SqlSession sqlSession;
  26.     @Before
  27.     public void before() throws PropertyVetoException, DocumentException {
  28.         InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
  30.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
  32.          sqlSession = sqlSessionFactory.openSession();
  33.     }
  34.     @Test
  35.     public void test() throws Exception {
  37.         //调用
  38.         User user=new User();
  39.         user.setId(1);
  40.         user.setUsername("张三");
  41.         User user2 = sqlSession.selectOne("user.selectOne", user);
  42.         System.out.println(user2);
  44.     }
  45. }

运行结果：



大功告成。

下节我们来讲对于我们这个框架的一个优化。

深入理解Mybatis（第一讲）——手写ORM框架（简易版Mybatis）的更多相关文章

  1. 重学 Java 设计模式：实战中介者模式「按照Mybaits原理手写ORM框架，给JDBC方式操作数据库增加中介者场景」

    作者:小傅哥 博客:https://bugstack.cn - 原创系列专题文章 沉淀.分享.成长,让自己和他人都能有所收获! 一.前言 同龄人的差距是从什么时候拉开的 同样的幼儿园.同样的小学.一样 ...

  2. 基于springJDBC手写ORM框架

    一.添加MySQLjar包依赖 二.结构 三.文件内容 (一).bean包 1.ColumnInfo.java 2.javaFiledInfo.java 3.TableInfo.java 4.Conf ...

  3. 手写Spring框架，加深对Spring工作机制的理解！

    在我们的日常工作中,经常会用到Spring.Spring Boot.Spring Cloud.Struts.Mybatis.Hibernate等开源框架,有了这些框架的诞生,平时的开发工作量也是变得越 ...

  4. 要想精通Mybatis？从手写Mybatis框架开始吧！

    1.Mybatis组成 动态SQL Config配置 Mapper配置 2.核心源码分析 Configuration源码解析 SqlSessionFactory源码解析 SqlSession源码解析 ...

  5. 第一个手写Win32窗口程序

    第一个手写Win32窗口程序 一 Windows编程基础 1 Win32应用程序的基本类型 1.1 控制台程序 不需要完善的Windows窗口,可以使用DOS窗口 的方式显示. 1.2 Win32窗口 ...

  6. 手写DAO框架（一）-从“1”开始

    背景: 很久(4年)之前写了一个DAO框架-zxdata(https://github.com/shuimutong/zxdata),这是我写的第一个框架.因为没有使用文档,我现在如果要用的话,得从头 ...

  7. Spring 08: AOP面向切面编程 + 手写AOP框架

    核心解读 AOP:Aspect Oriented Programming,面向切面编程 核心1:将公共的,通用的,重复的代码单独开发,在需要时反织回去 核心2:面向接口编程,即设置接口类型的变量,传入 ...

  8. 手写一套迷你版HTTP服务器

    本文主要介绍如何通过netty来手写一套简单版的HTTP服务器,同时将关于netty的许多细小知识点进行了串联,用于巩固和提升对于netty框架的掌握程度. 服务器运行效果 服务器支持对静态文件css ...

  9. 手写DAO框架（二）-开发前的最后准备

    -------前篇:手写DAO框架(一)-从“1”开始 --------- 前言:前篇主要介绍了写此框架的动机,把主要功能点大致介绍了一下.此篇文章主要介绍开发前最后的一些准备.主要包括一些基础知识点 ...

随机推荐

  1. 威联通(NAS)应用篇：自建OwnCloud网盘(百度网盘，拜拜~~~）

    基础环境: 威联通一台 已安装好 ContainerStation 公网 IP(非必须) 自有公网域名 下载镜像文件 提醒:建议先把威联通的自带镜像源改为国内的阿里云镜像源,教程:https://ww ...

  2. 使用kubeadm部署k8s集群[v1.18.0]

    使用kubeadm部署k8s集群 环境 IP地址 主机名 节点 10.0.0.63 k8s-master1 master1 10.0.0.63 k8s-master2 master2 10.0.0.6 ...

  3. P1750 出栈序列

    这好像是普及难度的吧~ 感觉再次被小学生吊打了........ \(\color{Red}{----------------------=|(●'◡'●)|=我是手动的分割线------------- ...

  4. Tomcat服务器的下载与安装，修改端口号

    安装及简单配置Tomcat服务器: 1.登录www.apache.org 网站,之后点击Projects , 点击Project List,找到Tomcat. 2.点击Tomcat之后,之后进入Tom ...

  5. 聊聊 TypeScript 中的类型保护

    聊聊 TypeScript 中的类型保护 在 TypeScript 中使用联合类型时,往往会碰到这种尴尬的情况: interface Bird { // 独有方法 fly(); // 共有方法 lay ...

  6. Web_php_include

    0x01 函数分析 <?php show_source(__FILE__); echo $_GET['hello']; $page=$_GET['page']; while (strstr($p ...

  7. P3366【模板】最小生成树

    P3366[模板]最小生成树 Kruskal #include <bits/stdc++.h> using namespace std; typedef long long ll; ; ; ...

  8. mysql小白系列_06 备份与恢复

    1.使用mydumper工具全库备份. 1)源码编译安装 2)全库备份 2.误操作truncate table gyj_t1;利用mysqldump的备份和binlog日志对表gyj_t1做完全恢复. ...

  9. UVALive8518 Sum of xor sum

    题目链接:https://vjudge.net/problem/UVALive-8518 题目大意: 给定一个长度为 $N$ 的数字序列 $A$,进行 $Q$ 次询问,每次询问 $[L,R]$,需要回 ...

  10. ShoneSharp语言(S#)软件更新13.7版

    ShoneSharp语言(S#)编辑解析运行器 软件更新13.7版 作者:Shone 近期在写博客过程中对S#进行增强,把语法规则更新到2.0版,并同步更新软件到ShoneSharp.13.7.exe ...