闭关修炼180天--手写持久层框架（mybatis简易版）
抛砖引玉
首先先看一段传统的JDBC编码的代码实现：
//传统的JDBC实现
public static void main(String[] args) {
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","root");
//定义sql语句
String sql = "select * from user where username = ?";
//获取预处理对象statement
preparedStatement = connection.prepareStatement(sql);
//设置参数，第一个参数为sql语句中的参数的序号(从1开始)，第二个参数为设置的参数值
preparedStatement.setString(1,"tom");
//像数据库发出sql执行查询，查询出结果集
resultSet = preparedStatement.executeQuery();
while (resultSet.next()){
int id = resultSet.getInt("id");
String username = resultSet.getString("username");
String password = resultSet.getString("password");
//将查询出的结果集封装进实体中
User user = new User();
user.setId(id);
user.setUsername(username);
user.setPassword(password);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
//释放资源
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
通过以上传统的JDBC操作数据库的代码可以发现，我们能总结出来以下几条问题：
每执行一次sql都要建立一次数据库连接，数据库连接创建、释放频繁造成系统资源浪费，从而影响系统性能。
Sql编写在了代码中存在硬编码问题，实际上工作中sql变化是比较大的，每次都要修改代码，sql语句不易维护。
使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能 多也可能少，修改sql还要修改代码，系统不易维护。
对结果集解析存在硬编码(查询列名)，sql变化导致解析代码变化，系统不易维护，如果能将数据库 记录自动封装成pojo对象解析比较方便。
针对以上的几条JDBC问题，我们可以大致的延伸出以下几点的解决思路：
使用数据库连接池初始化连接资源。
将sql语句写在xml文件中，在代码中剥离出来单独维护。
使用反射内省等技术，完成数据库的表字段和实体的属性的自动映射。
深入剖析
本次完成持久层框架的自定义编写便是从以上几个方面入手，来解决传统的JDBC存在的问题，在编写之前，我们首先要明白，框架属于开发的一个半成品，是我们在开发过程中可以直接拿来用的东西，我们在自定义编写时，什么代码是框架中所有的，什么代码属于使用端（一般开发人员）提供的，这点要想明白。经分析，大体划分如下：
使用端
提供核心配置文件：
sqlMapConfig.xml文件，配置数据源等信息，同时引入Mapper.xml。
Mapper.xml文件，配置sql语句等信息。
框架端
读取配置文件，将配置文件加载成字节输入流存放在内存中，准备好两个javaBean用来存储以后解析配置文件出来的数据。
Configuration:存放数据源信息dataBase、Map<String,MappedStatement>、key为唯一标识：namespace+id，value是sql相关信息实体。
MappedStatement:存放sql相关信息，包含id,sql语句，入参类型，返回值类型等。
解析配置文件，创建SqlSessionFactoryBuild类，提供build(InputStream in)方法，用于构建SqlSessionFactory。
使用dom4j技术解析xml配置文件，将解析出来的数据存放到javaBean中。
创建SqlSessionFactory的实现类DefaultSqlSessionFactory
生产会话对象。在SqlSessionFactory中提供openSession()方法，用于生产SqlSession。
创建SqlSession接口及其实现类，用于封装crud方法。
selectList(String statementId,Object... param) 查询全部
selectOne(String statementId,Object... param) 查询单个
执行实际的JDBC操作。创建Executor接口及其实现类SimpleExecutor，提供query(Configuration configuration, MappedStatement mappedStatement, Object... params）方法，完成实际的与数据库交互的工作。
从连接池中获取连接
处理sql语句
设置参数
封装结果集
涉及到的设计模式
构建者模式
工厂模式
代理模式
代码实现
这里只贴出核心代码，全部代码请看我的码云：https://gitee.com/zang-chuanlei/FrameMyBatis.git
在这里需要创建两个项目：FrameMyBatistest和FrameMyBatis，其中FrameMyBatis_test代表的是使用端，FrameMyBatis代表的是框架端，项目结构如下：
1.在FrameMyBatis_test下面的resources目录下添加两个配置文件sqlMapConfig.xml和UserMapper.xml
<configuration>
<dataSource>
<property name="dataDriver" value="com.mysql.jdbc.Driver"></property>
<property name="dataUrl" value="jdbc:mysql:///mybatis"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</dataSource>
<!--加载UserMapper.xml配置文件-->
<mapper resource="UserMapper.xml"></mapper>
</configuration>
<mapper namespace="com.zae.dao.UserDao">
<select id="findAll" resultType="com.zae.entity.User">
select * from users
</select>
<select id="findOne" resultType="com.zae.entity.User" paramterType="com.zae.entity.User">
select * from users where id=#{id} and username=#{username}
</select>
</mapper>
2.给FrameMyBatis引入一些需要的坐标
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.17</version>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
</dependency>
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1.6</version>
</dependency> </dependencies>
3.在FrameMyBatis下创建Resources类，用于加载字节输入流。
import java.io.InputStream;
public class Resources {
/**
* 根据xml路径将xml文件加载成字节流，存放在内存中
* @param path
* @return
*/
public static InputStream getInputStreamByXml(String path){
InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path);
return resourceAsStream;
}
}
4.创建两个bean，Configuration和MappedStatement
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map; /**
* javaBean之一：用来装sqlMapConfig.xml文件的内容
*/
public class Configuration { /**
* 存储数据源连接信息
*/
private DataSource dataSource; /**
* 存储加载进来的mapper.xml里面的数据
* key = statementId = namespace+"."+id
* value = mapperStatement
*/
private Map<String,MapperStatement> mapperStatementMap = new HashMap<String, MapperStatement>(); public DataSource getDataSource() {
return dataSource;
} public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
} public Map<String, MapperStatement> getMapperStatementMap() {
return mapperStatementMap;
} public void setMapperStatementMap(Map<String, MapperStatement> mapperStatementMap) {
this.mapperStatementMap = mapperStatementMap;
}
}
/**
* javaBean-2用来装载mapper.xml的数据
* 一条sql语句信息封装在一个MapperStatement对象中
*/
public class MapperStatement { private String id; private String resultType; private String paramterType; private String sql; public String getId() {
return id;
} public void setId(String id) {
this.id = id;
} public String getResultType() {
return resultType;
} public void setResultType(String resultType) {
this.resultType = resultType;
} public String getParamterType() {
return paramterType;
} public void setParamterType(String paramterType) {
this.paramterType = paramterType;
} public String getSql() {
return sql;
} public void setSql(String sql) {
this.sql = sql;
}
}
5.创建SqlSessionFactoryBuild
import com.zae.config.XmlConfigBuilder;
import com.zae.pojo.Configuration; import java.io.InputStream; public class SqlSessionFactoryBuilder { /**
* 构建SqlSessionFactory工厂
* @param inputStream
* @return
*/
public SqlSessionFactory build(InputStream inputStream) throws Exception{
//完成xml文件的解析
XmlConfigBuilder xmlConfigBuilder = new XmlConfigBuilder();
Configuration configuration = xmlConfigBuilder.parasConfig(inputStream); DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);
return defaultSqlSessionFactory;
}
}
6.创建解析XML文件的两个专属类XmlConfigBuilder和XmlMapperBuilder
import com.mchange.v2.c3p0.ComboPooledDataSource;
import com.zae.io.Resources;
import com.zae.pojo.Configuration;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader; import java.io.InputStream;
import java.util.List;
import java.util.Properties; /**
* 解析sqlMapConfig.xml文件存放在javaBean中
*/
public class XmlConfigBuilder { private Configuration configuration; public XmlConfigBuilder(){
this.configuration = new Configuration();
} /**
* 解析sqlMapConfig.xml文件
* @param inputStream
* @return
*/
public Configuration parasConfig(InputStream inputStream) throws Exception{
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(inputStream);
//获取根标签里面的内容
Element rootElement = document.getRootElement();
//获取所有的property标签里面的内容
List<Element> list = rootElement.selectNodes("//property");
//将数据库连接信息读取到properties文件中
Properties properties = new Properties();
for (Element element : list) {
//获取子标签里面的属性
String name = element.attributeValue("name");
String value = element.attributeValue("value");
properties.setProperty(name,value);
}
//创建数据库连接池
ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
comboPooledDataSource.setDriverClass(properties.getProperty("dataDriver"));
comboPooledDataSource.setJdbcUrl(properties.getProperty("dataUrl"));
comboPooledDataSource.setUser(properties.getProperty("username"));
comboPooledDataSource.setPassword(properties.getProperty("password"));
//给configuration里面的数据源属性赋值
configuration.setDataSource(comboPooledDataSource); //解析xl文件的数据
List<Element> mapperList = rootElement.selectNodes("//mapper");
for (Element element : mapperList) {
//获取到mapper.xml文件的路径
String resource = element.attributeValue("resource");
//获取mapper文件的输入流
InputStream mapperInputStream = Resources.getInputStreamByXml(resource);
XmlMapperBuilder xmlMapperBuilder = new XmlMapperBuilder(configuration);
xmlMapperBuilder.parasMapper(mapperInputStream);
} return configuration;
}
}
import com.zae.pojo.Configuration;
import com.zae.pojo.MapperStatement;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader; import java.io.InputStream;
import java.util.List;
/**
* 解析mapper.xml数据存放到javaBean中
*/
public class XmlMapperBuilder { private Configuration configuration; public XmlMapperBuilder(Configuration configuration){
this.configuration = configuration;
} public void parasMapper(InputStream mapperInputStream) throws Exception {
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(mapperInputStream);
//获取根标签的数据-mapper
Element rootElement = document.getRootElement();
//获取命名空间
String namespace = rootElement.attributeValue("namespace");
//获取所有的select标签的内容
List<Element> elementList = rootElement.selectNodes("//select");
for (Element element : elementList) {
String id = element.attributeValue("id");
String resultType = element.attributeValue("resultType");
String paramterType = element.attributeValue("paramterType");
String sql = element.getTextTrim();
MapperStatement mapperStatement = new MapperStatement();
mapperStatement.setId(id);
mapperStatement.setResultType(resultType);
mapperStatement.setParamterType(paramterType);
mapperStatement.setSql(sql);
String key = namespace+"."+id;
configuration.getMapperStatementMap().put(key,mapperStatement);
}
}
}
7.创建sqlSessionFactory接口及DefaultSqlSessionFactory 实现类
public interface SqlSessionFactory {
SqlSession openSqlSession();
}
import com.zae.pojo.Configuration;
public class DefaultSqlSessionFactory implements SqlSessionFactory {
private Configuration configuration;
public DefaultSqlSessionFactory(Configuration configuration){
this.configuration = configuration;
}
public SqlSession openSqlSession() {
return new DefaultSqlSession(configuration);
}
}
8.创建sqlSession 接口及DefaultSqlSession 实现类
import java.util.List;
public interface SqlSession {
<E> List<E> findAll(String statementId,Object ... params) throws Exception;
<T> T findOne(String statement,Object ...params)throws Exception;
<T> T getMapper(Class<?> mapperClass);
}
import com.zae.pojo.Configuration;
import com.zae.pojo.MapperStatement; import java.lang.reflect.*;
import java.util.List;
import java.util.Map; public class DefaultSqlSession implements SqlSession {
private Configuration configuration; public DefaultSqlSession(Configuration configuration){
this.configuration = configuration;
} public <E> List<E> findAll(String statementId, Object... params) throws Exception{
Map<String, MapperStatement> statementMap = configuration.getMapperStatementMap();
MapperStatement mapperStatement = statementMap.get(statementId);
Executor executor = new SimpleExecutor();
List<Object> execute = executor.execute(configuration,mapperStatement,params);
return (List<E>) execute;
} public <T> T findOne(String statement, Object... params) throws Exception{
List<Object> objectList = findAll(statement, params);
if(objectList.size() == 1){
return (T) objectList.get(0);
}else{
throw new RuntimeException("返回参数不唯一或者为空");
}
} public <T> T getMapper(Class<?> aclass) {
Object object = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{aclass}, new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//获取执行方法名
String methodName = method.getName();
//获取全限类名
String className = method.getDeclaringClass().getName();
//statementId
String statementId = className+"."+methodName;
//参数泛型化
Type type = method.getGenericReturnType();
if(type instanceof ParameterizedType){
//存在泛型，则调用findAll
List<Object> all = findAll(statementId, args);
return all;
}
return findOne(statementId,args);
}
}); return (T) object;
}
}
9.创建Executor接口及SimpleExecutor实现类，创建BoundSql实体，引入工具类。
import com.zae.pojo.Configuration;
import com.zae.pojo.MapperStatement; import java.util.List; public interface Executor {
/**
* jdbc处理方法
* @param configuration
* @param mapperStatement
* @param params
* @param <E>
* @return
*/
<E> List<E> execute(Configuration configuration, MapperStatement mapperStatement, Object ...params) throws Exception;
}
import com.zae.pojo.BorundSql;
import com.zae.pojo.Configuration;
import com.zae.pojo.MapperStatement;
import com.zae.utils.GenericTokenParser;
import com.zae.utils.ParameterMapping;
import com.zae.utils.ParameterMappingTokenHandler; import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List; public class SimpleExecutor implements Executor {
public <E> List<E> execute(Configuration configuration, MapperStatement mapperStatement, Object... params) throws Exception{
//1.获取连接对象
Connection connection = configuration.getDataSource().getConnection();
//2.处理sql语句
String sql = mapperStatement.getSql();
BorundSql borundSql = dealSql(sql);
String sqlNow = borundSql.getSql();
List<ParameterMapping> mappingList = borundSql.getParameterMappingList();
//3.获取预处理对象
PreparedStatement preparedStatement = connection.prepareStatement(sqlNow);
//4.设置参数
Class<?> classByType = getClassByType(mapperStatement.getParamterType());
for(int i = 0;i<mappingList.size();i++){
String content = mappingList.get(i).getContent();
//根据属性名获取该属性信息
Field declaredField = classByType.getDeclaredField(content);
//设置暴力访问
declaredField.setAccessible(true);
//获取参数里面的值
Object value = declaredField.get(params[0]);
//设置参数
preparedStatement.setObject(i+1,value);
}
//5.处理返回结果集
ResultSet resultSet = preparedStatement.executeQuery();
Class<?> resultClass = getClassByType(mapperStatement.getResultType());
List resultList = new ArrayList();
while (resultSet.next()){
//生成该类的实例对象
Object object = resultClass.newInstance();
ResultSetMetaData metaData = resultSet.getMetaData();
for(int i = 1;i<=metaData.getColumnCount();i++){
//获取列的名称
String columnName = metaData.getColumnName(i);
//根据列的名称获取内容
Object value = resultSet.getObject(columnName);
//使用反射或内省，完成字段和数据库的映射
PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName,resultClass);
//获取写入方法
Method writeMethod = propertyDescriptor.getWriteMethod();
//调用invoke方法，将数据写入实体
writeMethod.invoke(object,value);
}
resultList.add(object);
}
return resultList;
} /**
* 处理sql，将sql中的#{}处理成?,并把#{}里面的字段保存下来
* @param sourceSql
* @return
*/
private BorundSql dealSql(String sourceSql){
ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
GenericTokenParser genericTokenParser = new GenericTokenParser("#{","}",parameterMappingTokenHandler);
String targetSql = genericTokenParser.parse(sourceSql);
List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
BorundSql borundSql = new BorundSql();
borundSql.setSql(targetSql);
borundSql.setParameterMappingList(parameterMappings);
return borundSql;
} /**
* 根据类的全路径获取类对象
* @param path
* @return
*/
private Class<?> getClassByType(String path) throws ClassNotFoundException {
if(path!=null){
Class<?> aClass = Class.forName(path);
return aClass;
}else{
return null;
}
}
}
import com.zae.utils.ParameterMapping;
import java.util.List;
public class BorundSql {
private String sql;
private List<ParameterMapping> parameterMappingList;
public String getSql() {
return sql;
}
public void setSql(String sql) {
this.sql = sql;
}
public List<ParameterMapping> getParameterMappingList() {
return parameterMappingList;
}
public void setParameterMappingList(List<ParameterMapping> parameterMappingList) {
this.parameterMappingList = parameterMappingList;
}
}
工具类如下：
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) {
// 验证参数问题，如果是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();
}
}
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;
}
}
import java.util.ArrayList;
import java.util.List; public class ParameterMappingTokenHandler implements TokenHandler {
private List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>(); // 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<ParameterMapping> getParameterMappings() {
return parameterMappings;
} public void setParameterMappings(List<ParameterMapping> parameterMappings) {
this.parameterMappings = parameterMappings;
} }
public interface TokenHandler {
String handleToken(String content);
}
10.在FrameMyBatis_test项目的pom文件中引入FrameMyBatis的坐标，在准备好的FrameMyBatis_test下编写测试类FrameTest
import com.zae.dao.UserDao;
import com.zae.entity.User;
import com.zae.io.Resources;
import com.zae.session.SqlSession;
import com.zae.session.SqlSessionFactory;
import com.zae.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test; import java.io.InputStream;
import java.util.List; public class FrameTest { private SqlSession sqlSession; private UserDao userDao; @Before
public void test1() throws Exception{
//获取字节输入流
InputStream inputStream = Resources.getInputStreamByXml("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
sqlSession = sqlSessionFactory.openSqlSession();
userDao = sqlSession.getMapper(UserDao.class);
} /**
* 全查
* @throws Exception
*/
@Test
public void test2()throws Exception{
List<User> all = sqlSession.findAll("com.zae.dao.UserDao.findAll");
for (User user : all) {
System.out.println(user);
}
} /**
* 单条
* @throws Exception
*/
@Test
public void test3() throws Exception{
User user = new User();
user.setId("1");
user.setUsername("sss");
User one = sqlSession.findOne("user.findOne", user);
System.out.println(one);
} /**
* 代理对象查询
* @throws Exception
*/
@Test
public void test4() throws Exception{
List<User> userList = userDao.findAll(null);
for (User user : userList) {
System.out.println(user);
}
}
}
我是帝莘，期待与你的技术交流和思想碰撞。
