前言

前两篇文章分别讲解了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项目，做了一些必要的准备工作，然后完成了读取数据库配置信息及解析数据库配置信息的编码工作。

到这里，我们就可以调用我们自定义的工具来读取和解析数据库配置信息了，下一篇文章会讲解如何调用这些工具。

巴特西

Mybatis学习之自定义持久层框架（三）自定义持久层框架：读取并解析配置文件

前言

新建一个项目

读取配置文件

解析配置文件

创建容器对象

创建配置文件解析类

总结

最新文章

热门文章

巴特西

Mybatis学习之自定义持久层框架（三） 自定义持久层框架：读取并解析配置文件

前言

新建一个项目

读取配置文件

解析配置文件

创建容器对象

创建配置文件解析类

总结

最新文章

热门文章

Mybatis学习之自定义持久层框架（三）自定义持久层框架：读取并解析配置文件