闭关修炼180天--手写持久层框架(mybatis简易版)
闭关修炼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); } } }
文章知识点输出来源:拉勾教育Java高薪训练营
我是帝莘,期待与你的技术交流和思想碰撞。