前言
前两篇文章分别讲解了JDBC和Mybatis的基本知识，以及自定义持久层框架的设计思路，从这篇文章开始，我们正式来实现一个持久层框架。
新建一个项目
首先我们新建一个maven项目，将其命名为IPersistence，创建以下目录结构：
完成目录创建工作后，我们首先在pom.xml文件中引入相关依赖：
1 <?xml version="1.0" encoding="UTF-8"?> 2 <project xmlns="http://maven.apache.org/POM/4.0.0" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 5 <modelVersion>4.0.0</modelVersion> 6 7 <groupId>com.hardy</groupId> 8 <artifactId>IPersistence</artifactId> 9 <version>1.0-SNAPSHOT</version> 10 11 <properties> 12 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 13 <maven.compiler.encoding>UTF-8</maven.compiler.encoding> 14 <java.version>1.8</java.version> 15 <maven.compiler.source>1.8</maven.compiler.source> 16 <maven.compiler.target>1.8</maven.compiler.target> 17 </properties> 18 19 <dependencies> 20 <dependency> 21 <groupId>mysql</groupId> 22 <artifactId>mysql-connector-java</artifactId> 23 <version>8.0.19</version> 24 </dependency> 25 <dependency> 26 <groupId>c3p0</groupId> 27 <artifactId>c3p0</artifactId> 28 <version>0.9.1.2</version> 29 </dependency> 30 <dependency> 31 <groupId>log4j</groupId> 32 <artifactId>log4j</artifactId> 33 <version>1.2.16</version> 34 </dependency> 35 <dependency> 36 <groupId>junit</groupId> 37 <artifactId>junit</artifactId> 38 <version>4.12</version> 39 </dependency> 40 <dependency> 41 <groupId>dom4j</groupId> 42 <artifactId>dom4j</artifactId> 43 <version>1.6.1</version> 44 </dependency> 45 <dependency> 46 <groupId>jaxen</groupId> 47 <artifactId>jaxen</artifactId> 48 <version>1.1.6</version> 49 </dependency> 50 </dependencies> 51 52 </project>
下面，就可以开始正式的编码工作了。
读取配置文件
前面讲到了，第一步是要读取数据库配置的相关信息，以流的形式将其存放在内存中。那么首先我们就要在上图“io”包下创建一个Resources类，编写如下代码：
1 package com.hardy.io; 2 3 import java.io.InputStream; 4 5 public class Resources { 6 7 // 根据配置文件的路径，将配置文件加载成字节输入流，存储在内存中 8 public static InputStream getResourceAsStream(String path) { 9 InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path); 10 return resourceAsStream; 11 } 12 }
这个类的调用方法十分简单，直接传递配置文件的路径名作为参数即可。
解析配置文件
创建容器对象
上面读取完配置文件的信息后，仅仅是将其以输入流的形式存放在内存中，而我们在项目开发过程中，需要调用到这些配置信息中的很多不同属性，如果每次都从内存中读取数据流，是很不方便的。
这里我们将配置文件分为核心配置文件（提供存放数据库核心配置的信息）和映射配置文件（提供sql配置信息（包括sql语句、参数类型和返回类型））。因此，我们可以在“pojo”包下创建两个容器对象类，分别命名为Configuration（存放核心配置信息）和MappedStatement（存放映射配置信息），编写如下代码：
1 package com.hardy.pojo; 2 3 import javax.sql.DataSource; 4 import java.util.HashMap; 5 import java.util.Map; 6 7 /* 8 Configuration： 9 核心配置类，存放数据库基本信息 10 即sqlMapConfig.xml解析出来的内容 11 */ 12 public class Configuration { 13 14 private DataSource dataSource; 15 16 /* 17 key: statementId value: 封装好的mappedStatement对象 18 */ 19 Map<String, MappedStatement> mappedStatementMap = new HashMap<>(); 20 21 public DataSource getDataSource() { 22 return dataSource; 23 } 24 25 public void setDataSource(DataSource dataSource) { 26 this.dataSource = dataSource; 27 } 28 29 public Map<String, MappedStatement> getMappedStatementMap() { 30 return mappedStatementMap; 31 } 32 33 public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) { 34 this.mappedStatementMap = mappedStatementMap; 35 } 36 37 }
1 package com.hardy.pojo; 2 3 // Mapper.xml文件中一个select标签对应一个MappedStatement对象 4 5 /* 6 映射配置类： 7 存放sql语句、statement类型、输入参数java类型、输出参数java类型 8 即Mapper.xml解析出来的内容 9 */ 10 public class MappedStatement { 11 12 // id标识 13 private String id; 14 15 // sql语句 16 private String sql; 17 18 // 输入参数值类型 19 private String parameterType; 20 21 // 返回结果集类型 22 private String resultType; 23 24 public String getId() { 25 return id; 26 } 27 28 public void setId(String id) { 29 this.id = id; 30 } 31 32 public String getSql() { 33 return sql; 34 } 35 36 public void setSql(String sql) { 37 this.sql = sql; 38 } 39 40 public String getParameterType() { 41 return parameterType; 42 } 43 44 public void setParameterType(String parameterType) { 45 this.parameterType = parameterType; 46 } 47 48 public String getResultType() { 49 return resultType; 50 } 51 52 public void setResultType(String resultType) { 53 this.resultType = resultType; 54 } 55 56 }
创建配置文件解析类
上面创建了存放配置文件信息的两个容器对象，但配置文件信息不会自动存放到容器对象中，因此我们还需要编写两个配置文件信息的解析类，可以在“config”包下分别创建XMLConfigBuilder和XMLMapperBuilder，编写以下代码：
1 package com.hardy.config; 2 3 import com.hardy.io.Resources; 4 import com.hardy.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; 10 11 import java.beans.PropertyVetoException; 12 import java.io.InputStream; 13 import java.util.List; 14 import java.util.Properties; 15 16 public class XMLConfigBuilder { 17 18 private Configuration configuration; 19 20 public XMLConfigBuilder(Configuration configuration) { 21 this.configuration = new Configuration(); 22 } 23 24 /* 25 该方法就是使用dom4j对配置文件进行解析，封装成Configuration 26 */ 27 public Configuration parseConfiguration(InputStream inputStream) throws DocumentException, PropertyVetoException, ClassNotFoundException { 28 29 // 1、解析sqlMapConfig.xml 30 /* 31 * 这里需要注意一下：Document和Element等类用的都是org.dom4j库中的类，而不是javax.swing的 32 * 若编译器自动导入了javax.swing，需要手动删除，否则会报错 33 * */ 34 Document document = new SAXReader().read(inputStream); 35 //<configuation> 36 Element rootElement = document.getRootElement(); 37 List<Element> propertyElements = 38 rootElement.selectNodes("//property"); 39 Properties properties = new Properties(); 40 for (Element propertyElement : propertyElements) { 41 String name = propertyElement.attributeValue("name"); 42 String value = propertyElement.attributeValue("value"); 43 properties.setProperty(name,value); 44 } 45 // 连接池 46 ComboPooledDataSource comboPooledDataSource = new 47 ComboPooledDataSource(); 48 comboPooledDataSource.setDriverClass(properties.getProperty("driverClass")); 49 comboPooledDataSource.setJdbcUrl(properties.getProperty("jdbcUrl")); 50 comboPooledDataSource.setUser(properties.getProperty("username")); 51 comboPooledDataSource.setPassword(properties.getProperty("password")); 52 53 // 填充configuration 54 configuration.setDataSource(comboPooledDataSource); 55 56 // 2、解析UserMapper.xml：拿到路径——获取字节输入流——使用dom4j进行解析 57 List<Element> mapperElements = rootElement.selectNodes("//mapper"); 58 XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration); 59 for (Element element : mapperElements) { 60 String mapperPath = element.attributeValue("resource"); 61 InputStream resourceAsStream = Resources.getResourceAsStream(mapperPath); 62 xmlMapperBuilder.parse(resourceAsStream); 63 } 64 65 return configuration; 66 } 67 }
1 package com.hardy.config; 2 3 import com.hardy.pojo.Configuration; 4 import com.hardy.pojo.MappedStatement; 5 import com.hardy.pojo.SqlOperationEnum; 6 import org.dom4j.Document; 7 import org.dom4j.DocumentException; 8 import org.dom4j.Element; 9 import org.dom4j.io.SAXReader; 10 11 import java.io.InputStream; 12 import java.util.List; 13 14 public class XMLMapperBuilder { 15 16 private Configuration configuration; 17 18 public XMLMapperBuilder(Configuration configuration) { 19 this.configuration = configuration; 20 } 21 22 // 解析mapper.xml文件 23 public void parse(InputStream inputStream) throws DocumentException { 24 Document document = new SAXReader().read(inputStream); 25 Element rootElement = document.getRootElement(); 26 27 String namespace = rootElement.attributeValue("namespace"); 28 29 List<Element> elementList = rootElement.elements(); 30 for (Element element : elementList) { 31 // id的值 32 String id = element.attributeValue("id"); 33 // 输入参数类型 34 String parameterType = element.attributeValue("parameterType"); 35 // 返回结果集类型 36 String resultType = element.attributeValue("resultType"); 37 // sql语句 38 String sqlText = element.getTextTrim(); 39 40 // 封装mappedStatement 41 MappedStatement mappedStatement = new MappedStatement(); 42 mappedStatement.setId(id); 43 mappedStatement.setParameterType(parameterType); 44 mappedStatement.setResultType(resultType); 45 mappedStatement.setSql(sqlText); 46 47 // 获取sql操作名，并将其转换为大写 48 String elementName = element.getName(); 49 mappedStatement.setSqlOperationEnum(SqlOperationEnum.valueOf(elementName.toUpperCase())); 50 51 // statementId 52 String key = namespace + "." + id; 53 54 //填充configuration 55 configuration.getMappedStatementMap().put(key, mappedStatement); 56 57 } 58 } 59 60 }
总结
本篇文章中，我们创建了IPersistence项目，做了一些必要的准备工作，然后完成了读取数据库配置信息及解析数据库配置信息的编码工作。
到这里，我们就可以调用我们自定义的工具来读取和解析数据库配置信息了，下一篇文章会讲解如何调用这些工具。