Mybatis系列全解（一）：手写一套持久层框架

sqlSession包下SimpleExecutor

package com.panshenlian.sqlSession;

import com.mysql.jdbc.StringUtils;
import com.panshenlian.config.BoundSql;
import com.panshenlian.pojo.Configuration;
import com.panshenlian.pojo.MappedStatement;
import com.panshenlian.utils.GenericTokenParser;
import com.panshenlian.utils.ParameterMapping;
import com.panshenlian.utils.ParameterMappingTokenHandler;

import java.beans.ExceptionListener;
import java.beans.IntrospectionException;
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 {

    @Override
    public  List query(Configuration configuration,
 MappedStatement mappedStatement,
 Object... params) throws Exception {

 // 1、注册驱动 , 获取数据库连接
 Connection connection = configuration.getDataSource().getConnection();

 // 2、获取sql语句： select * from user where id = #{id}
 //    转换sql语句： select * from user where id = ?
 //    转换的过程，还需要对#{}里面的值进行解析存储
 String sql = mappedStatement.getSql();
 BoundSql bounSql = getBoundSql(sql);

 // 3、获取预处理对象: preparedStatement
 PreparedStatement preparedStatement =
  connection.prepareStatement(bounSql.getSqlText());

 // 4、设置参数，通过反射机制获取到参数
 String parameterType = mappedStatement.getParameterType();
 Class<?> parameterTypeClass = getClassType(parameterType);

 List parameterMappingList =
  bounSql.getParameterMappingList();
 for (int i = 0; i < parameterMappingList.size(); i++) {
     ParameterMapping parameterMapping = parameterMappingList.get(i);
     String filedName = parameterMapping.getContent();

     // 反射
     Field declaredField = parameterTypeClass.getDeclaredField(filedName);
     // 暴力访问
     declaredField.setAccessible(true);
     Object declaredFieldValue = declaredField.get(params[0]); // params[0] 是对象
     preparedStatement.setObject(i+1,declaredFieldValue);
 }

 // 5、执行SQL
 ResultSet resultSet = preparedStatement.executeQuery();
 String resultType = mappedStatement.getResultType();
 Class<?> resultTypeClass = getClassType(resultType);
 List objects = new ArrayList();

 // 6、封装返回结果集
 while (resultSet.next()){
     Object o = resultTypeClass.newInstance();
     // 元数据
     ResultSetmetaData metaData = resultSet.getmetaData();
     for (int i = 1; i <= metaData.getColumnCount(); i++) {
  // 字段名
  String columnName = metaData.getColumnName(i);
  // 字段值
  Object columnValue = resultSet.getObject(columnName);

  // 使用内省（反射），根据数据库表和实体的对应关系，完成封装
  PropertyDescriptor propertyDescriptor =
   new PropertyDescriptor(columnName, resultTypeClass);
  Method writeMethod = propertyDescriptor.getWriteMethod();
  writeMethod.invoke(o,columnValue);
     }
     objects.add(o);
 }
 return (List)objects;
    }

    
    private Class<?> getClassType(String parameterType) throws ClassNotFoundException {
 if (StringUtils.isNullOrEmpty(parameterType)) {
     return null;
 }
 Class<?> clazz = Class.forName(parameterType);
 return clazz;
    }

    
    private BoundSql getBoundSql(String sql) {

 // 标记处理类，配置标记解析器来完成对占位符的解析处理工作
 ParameterMappingTokenHandler parameterMappingTokenHandler
  = new ParameterMappingTokenHandler();
 GenericTokenParser genericTokenParser =
  new GenericTokenParser("#{","}",
   parameterMappingTokenHandler);

 // 解析出来的sql
 String parseSql = genericTokenParser.parse(sql);
 // 解析出来的参数名称
 List parameterMappings =
  parameterMappingTokenHandler.getParameterMappings();

 // 封装成为通配sql返回结果
 BoundSql boundSql = new BoundSql(parseSql, parameterMappings);
 return boundSql;
    }
}

package com.panshenlian.sqlSession;

import java.util.List;


public interface SqlSession {

    
    public  List selectList(String statementId , Object ... params) throws Exception;

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

    
    public int update(String statementId , Object ... params);

    
    public int delete(String statementId , Object ... params);

    
    public  T getMapper(Class<?> mapperClass);

}

package com.panshenlian.sqlSession;


public interface SqlSessionFactory {

    public SqlSession openSession();
}

package com.panshenlian.sqlSession;

import com.panshenlian.config.XMLConfigBuilder;
import com.panshenlian.pojo.Configuration;

import java.io.InputStream;


public class SqlSessionFactoryBuilder {

    public SqlSessionFactory build(InputStream inputStream) throws Exception {

 // 第一步：用dom4j解析配置文件，将解析出来的内容封装到Configuration中
 XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
 Configuration configuration = xmlConfigBuilder.parseConfig(inputStream);

 // 第二步：创建SqlSessionFactory对象，生产sqlSession会话对象（工厂模式）
 DefaultSqlSessionFactory defaultSqlSessionFactory =
  new DefaultSqlSessionFactory(configuration);

 return defaultSqlSessionFactory;
    }
}

package com.panshenlian.utils;


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;
  }

  
  public String parse(String text) {
    // 验证参数问题，如果是null，就返回空字符串。
    if (text == null || text.isEmpty()) {
      return "";
    }

    // 下面继续验证是否包含开始标签，如果不包含，默认不是占位符，直接原样返回即可，否则继续执行。
    int start = text.indexOf(openToken, 0);
    if (start == -1) {
      return text;
    }

   // 把text转成字符数组src，并且定义默认偏移量offset=0、存储最终需要返回字符串的变量builder，
    // text变量中占位符对应的变量名expression。判断start是否大于-1(即text中是否存在openToken)，如果存在就执行下面代码
    char[] src = text.toCharArray();
    int offset = 0;
    final StringBuilder builder = new StringBuilder();
    StringBuilder expression = null;
    while (start > -1) {
     // 判断如果开始标记前如果有转义字符，就不作为openToken进行处理，否则继续处理
      if (start > 0 && src[start - 1] == '\') {
 builder.append(src, offset, start - offset - 1).append(openToken);
 offset = start + openToken.length();
      } else {
 //重置expression变量，避免空指针或者老数据干扰。
 if (expression == null) {
   expression = new StringBuilder();
 } else {
   expression.setLength(0);
 }
 builder.append(src, offset, start - offset);
 offset = start + openToken.length();
 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.append(src, offset, end - offset);
     offset = end + closeToken.length();
     break;
   }
 }
 if (end == -1) {
   // close token was not found.
   builder.append(src, start, src.length - start);
   offset = src.length;
 } else {
   //首先根据参数的key（即expression）进行参数处理，返回?作为占位符
   builder.append(handler.handleToken(expression.toString()));
   offset = end + closeToken.length();
 }
      }
      start = text.indexOf(openToken, offset);
    }
    if (offset < src.length) {
      builder.append(src, offset, src.length - offset);
    }
    return builder.toString();
  }
}

package com.panshenlian.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.panshenlian.utils;

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


public class ParameterMappingTokenHandler implements TokenHandler {
	private List parameterMappings = new ArrayList();

	// context是参数名称 #{id} #{username}

	public String handleToken(String content) {
		parameterMappings.add(buildParameterMapping(content));
		return "?";
	}

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

	public List getParameterMappings() {
		return parameterMappings;
	}

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

}

package com.panshenlian.utils;


public interface TokenHandler {
  String handleToken(String content);
}

<?xml version="1.0" encoding="UTF-8"?>
4.0.0com.panshenlianMyPersistenceTest1.0-SNAPSHOTUTF-8UTF-81.81.81.8com.panshenlianMyPersistence1.0-SNAPSHOT

 select * from user
    
 select * from user
 where id= #{id} and username = #{username}
 and password= #{password} and birthday = #{birthday}
    

package com.panshenlian.dao;

import com.panshenlian.pojo.User;

import java.util.List;


public interface IUserDao {

    
    public List findAll() throws Exception;

    
    public User findByCondition(User user) throws Exception;

}

package com.panshenlian.pojo;


public class User {

    private Integer id;
    private String username;
    private String password;
    private String birthday;

    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;
    }

    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 + ''' +
  ", password='" + password + ''' +
  ", birthday='" + birthday + ''' +
  '}';
    }
}

package com.panshenlian.test;

import com.panshenlian.dao.IUserDao;
import com.panshenlian.io.Resource;
import com.panshenlian.pojo.User;
import com.panshenlian.sqlSession.SqlSession;
import com.panshenlian.sqlSession.SqlSessionFactory;
import com.panshenlian.sqlSession.SqlSessionFactoryBuilder;
import org.junit.Test;

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


public class MyPersistenceTest {

    @Test
    public void test() throws Exception {
 InputStream resourceAsStream =
  Resource.getResourceAsStream("sqlMapConfig.xml");
 SqlSessionFactory sqlSessionFactory =
  new SqlSessionFactoryBuilder().build(resourceAsStream);
 SqlSession sqlSession = sqlSessionFactory.openSession();

 // 一、传统DAO方式调用
 User user = new User();
 user.setId(3);
 user.setUsername("panshenlian");
 user.setBirthday("2020-11-12");
 user.setPassword("123456");
 User dbUser = sqlSession.selectOne("com.panshenlian.dao.IUserDao.findByCondition",user);
 System.out.println(dbUser);
 List userList = sqlSession.selectList("com.panshenlian.dao.IUserDao.findAll", user);
 for (User db : userList) {
     System.out.println(db);
 }

 // 二、代理模式调用
 IUserDao userDao = sqlSession.getMapper(IUserDao.class);
 List users = userDao.findAll();
 for (User db : users) {
     System.out.println("代理调用=" + db);
 }

    }
}