自定义持久层框架------从零到一手写一个mybatis

JDBC操作题目

JDBC代码

1. import java.sql.*;
2. import java.util.ArrayList;
3. import java.util.List;
5. public class JDBC {
6.     public static void main(String[] args) {
7.         Connection connection = null;
8.         PreparedStatement preparedStatement = null;
9.         ResultSet resultSet = null;
10.         try {
11.             //加载驱动
12.             Class.forName("com.mysql.jdbc.Driver");
13.             //创建连接
14.             connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", " root", " root");
15.             //写sql语句
16.             String sql = "select * from user where username = ?";
17.             //获取预处理对象
18.             preparedStatement = connection.prepareStatement(sql);
19.             //设置参数
20.             preparedStatement.setString(1, "tom");
21.             //执行sql，获取结果集
22.             resultSet = preparedStatement.executeQuery();
23.             //封装结果集
24.             List<User> userList = new ArrayList<>();
25.             while (resultSet.next()) {
26.                 User user = new User();
27.                 int id = resultSet.getInt("id");
28.                 String username = resultSet.getString("username");
29.                 user.setId(id);
30.                 user.setUsername(username);
31.                 userList.add(user);
32.             }
33.             System.out.println(userList);
34.         } catch (ClassNotFoundException e) {
35.             e.printStackTrace();
36.         } catch (SQLException e) {
37.             e.printStackTrace();
38.         } finally {
39.             //关闭资源
40.             if (resultSet != null) {
41.                 try {
42.                     resultSet.close();
43.                 } catch (SQLException e) {
44.                     e.printStackTrace();
45.                 }
46.             }
47.             if (preparedStatement != null) {
48.                 try {
49.                     preparedStatement.close();
50.                 } catch (SQLException e) {
51.                     e.printStackTrace();
52.                 }
53.             }
54.             if (connection != null) {
55.                 try {
56.                     connection.close();
57.                 } catch (SQLException e) {
58.                     e.printStackTrace();
59.                 }
60.             }
61.         }
62.     }
63. }

复制代码

JDBC题目总结

• 频繁创建、释放数据库连接，造成系统资源浪费
  
• sql语句在代码中硬编码，不易维护
  
• 传参存在硬编码，修改sql还要修改代码
  
• 手动解析结果集
  

JDBC题目办理思绪

• 利用数据库连接池初始化连接资源
  
• 将sql语句抽取到xml配置文件中
  
• 利用反射技能，将实体属性与表字段自动映射
  

自定义框架设计

利用端

提供核心配置文件：
sqlMapConfig.xml:存放数据源信息，引入Mapper.xml的全路径
Mapper.xml:sql语句的配置文件信息
框架端

• 读取配置文件
  

读取后以流的情势存在于内存中，后创建JavaBean存储
Configuration:存放数据库的根本信息、Map<唯一标识，Mapper>
唯一标识：namespace+“.”+id
MappedStatement:sql语句、statement类型、输入参数类型、输出参数类型

• 解析配置文件
  

创建SqlSessionFactoryBuilder类
方法：SqlSessionFactory build()
利用dom4j解析配置文件，将解析出来的内容封装到Configuration和MappedStatement
创建SqlSessionFactory的实现类DefaultSqlSessionFactory。

• 创建SqlSessionFactory
  

方法：openSession():获取sqlSession接口的实现类的实例对象

• 创建sqlSession接口及着实现类
  

方法：selectOne(String statementId,Object… params)
selectList(String statementId,Object… params)

• 创建Executor接口及着实现类
  

封装JDBC代码实现CRUD
** 设计模式：制作者模式、工厂模式、代理模式**
自定义框架实现

在利用端创建配置文件

1. <configuration>
2.     <dataSource>
3.         <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
4.         <property name="jdbcUrl" value="jdbc:mysql:///test"></property>
5.         <property name="username" value="root"></property>
6.         <property name="password" value="@wdlm212027"></property>
7.     </dataSource>
8.     <mapper resource="UserMapper.xml"></mapper>
9. </configuration>

复制代码

1. <mapper namespace="user">
2.     <select id="selectList" resultType="com.wdlm.pojo.User">
3.         select * from user
4.     </select>
5.     <select id="selectOne" resultType="com.wdlm.pojo.User" parameterType="com.wdlm.pojo.User">
6.         select * from user where id=#{id} and username=#{username}
7.     </select>
8. </mapper>

复制代码

在利用端创建实体类

1. public class User {
2.     private Integer id;
3.     private String username;
5.     public User() {
6.     }
8.     public User(Integer id, String username) {
9.         this.id = id;
10.         this.username = username;
11.     }
13.     public Integer getId() {
14.         return id;
15.     }
17.     public void setId(Integer id) {
18.         this.id = id;
19.     }
21.     public String getUsername() {
22.         return username;
23.     }
25.     public void setUsername(String username) {
26.         this.username = username;
27.     }
28. }

复制代码

在框架端导入Maven依赖

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>
7.     <groupId>com.wdlm.imybatis</groupId>
8.     <artifactId>Imybatis</artifactId>
9.     <version>1.0-SNAPSHOT</version>
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>
19.     <dependencies>
20.         <dependency>
21.             <groupId>mysql</groupId>
22.             <artifactId>mysql-connector-java</artifactId>
23.             <version>5.1.17</version>
24.         </dependency>
26.         <dependency>
27.             <groupId>c3p0</groupId>
28.             <artifactId>c3p0</artifactId>
29.             <version>0.9.1.2</version>
30.         </dependency>
32.         <dependency>
33.             <groupId>log4j</groupId>
34.             <artifactId>log4j</artifactId>
35.             <version>1.2.12</version>
36.         </dependency>
38.         <dependency>
39.             <groupId>junit</groupId>
40.             <artifactId>junit</artifactId>
41.             <version>4.10</version>
42.         </dependency>
44.         <dependency>
45.             <groupId>dom4j</groupId>
46.             <artifactId>dom4j</artifactId>
47.             <version>1.6.1</version>
48.         </dependency>
50.         <dependency>
51.             <groupId>jaxen</groupId>
52.             <artifactId>jaxen</artifactId>
53.             <version>1.1.6</version>
54.         </dependency>
55.     </dependencies>
57. </project>

复制代码

在框架端创建配置类

1. import javax.sql.DataSource;
2. import java.util.HashMap;
3. import java.util.Map;
5. public class Configuration {
6.     private DataSource dataSource;
7.     Map<String, MappedStatement> mappedStatementMap = new HashMap<String, MappedStatement>();
9.     public DataSource getDataSource() {
10.         return dataSource;
11.     }
13.     public void setDataSource(DataSource dataSource) {
14.         this.dataSource = dataSource;
15.     }
17.     public Map<String, MappedStatement> getMappedStatementMap() {
18.         return mappedStatementMap;
19.     }
21.     public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) {
22.         this.mappedStatementMap = mappedStatementMap;
23.     }
24. }

复制代码

1. public class MappedStatement {
2.     private String id;
3.     private String resultType;
4.     private String parameterType;
5.     private String sql;
7.     public String getId() {
8.         return id;
9.     }
11.     public void setId(String id) {
12.         this.id = id;
13.     }
15.     public String getResultType() {
16.         return resultType;
17.     }
19.     public void setResultType(String resultType) {
20.         this.resultType = resultType;
21.     }
23.     public String getParameterType() {
24.         return parameterType;
25.     }
27.     public void setParameterType(String paramterType) {
28.         this.parameterType = paramterType;
29.     }
31.     public String getSql() {
32.         return sql;
33.     }
35.     public void setSql(String sql) {
36.         this.sql = sql;
37.     }
38. }

复制代码

在框架端创建配置文件读取类

1. public class Resources {
2.     public static InputStream getResourceAsStream(String path) {
3.         InputStream resource = Resources.class.getClassLoader().getResourceAsStream(path);
4.         return resource;
5.     }
6. }

复制代码

在框架端创建SqlSessionFactoryBuilder

1. public class SqlSessionFactoryBuilder {
2.     public SqlSessionFactory build(InputStream resource) throws PropertyVetoException, DocumentException {
3.         XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
4.         Configuration configuration = xmlConfigBuilder.parseConfig(resource);
5.         DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);
6.         return defaultSqlSessionFactory;
7.     }
8. }

复制代码

在框架端创建解析类

1. public class XMLConfigBuilder {
2.     private Configuration configuration;
4.     public XMLConfigBuilder() {
5.         configuration = new Configuration();
6.     }
8.     public Configuration parseConfig(InputStream resource) throws DocumentException, PropertyVetoException {
9.         Document document = new SAXReader().read(resource);
10.         Element rootElement = document.getRootElement();
11.         List<Element> list = rootElement.selectNodes("//property");
12.         Properties properties = new Properties();
13.         for (Element element : list) {
14.             String name = element.attributeValue("name");
15.             String value = element.attributeValue("value");
16.             properties.setProperty(name, value);
17.         }
19.         ComboPooledDataSource dataSource = new ComboPooledDataSource();
20.         dataSource.setDriverClass(properties.getProperty("driverClass"));
21.         dataSource.setJdbcUrl(properties.getProperty("jdbcUrl"));
22.         dataSource.setUser(properties.getProperty("username"));
23.         dataSource.setPassword(properties.getProperty("password"));
25.         configuration.setDataSource(dataSource);
27.         List<Element> mapperList = rootElement.selectNodes("//mapper");
28.         for (Element element : mapperList) {
29.             String mapperPath = element.attributeValue("resource");
30.             InputStream mapperResource = Resources.getResourceAsStream(mapperPath);
31.             XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
32.             xmlMapperBuilder.parse(mapperResource);
33.         }
35.         return configuration;
37.     }
38. }

复制代码

1. public class XMLMapperBuilder {
2.     private Configuration configuration;
4.     public XMLMapperBuilder(Configuration configuration) {
5.         this.configuration = configuration;
6.     }
8.     public void parse(InputStream resource) throws DocumentException {
9.         Document document = new SAXReader().read(resource);
10.         Element rootElement = document.getRootElement();
11.         List<Element> list = rootElement.selectNodes("//select");
12.         String namespace = rootElement.attributeValue("namespace");
13.         for (Element element : list) {
14.             String id = element.attributeValue("id");
15.             String resultType = element.attributeValue("resultType");
16.             String parameterType = element.attributeValue("parameterType");
17.             String sql = element.getTextTrim();
18.             MappedStatement mappedStatement = new MappedStatement();
19.             mappedStatement.setId(id);
20.             mappedStatement.setParameterType(parameterType);
21.             mappedStatement.setResultType(resultType);
22.             mappedStatement.setSql(sql);
23.             String key = namespace + "." + id;
24.             configuration.getMappedStatementMap().put(key, mappedStatement);
25.         }
26.     }
27. }

复制代码

在框架端创建SqlSessionFactory接口及着实现类

1. public interface SqlSessionFactory {
2.     public SqlSession openSession();
3. }

复制代码

1. public class DefaultSqlSessionFactory implements SqlSessionFactory {
2.     private Configuration configuration;
4.     public DefaultSqlSessionFactory(Configuration configuration) {
5.         this.configuration = configuration;
6.     }
8.     @Override
9.     public SqlSession openSession() {
10.         return new DefaultSqlSession(configuration);
11.     }
12. }

复制代码

在框架端创建SqlSession接口及着实现类

1. public interface SqlSession {
2.     public <E> List<E> selectList(String statementId, Object... params);
4.     public <T> T selectOne(String statementId, Object... params) throws Exception;
6. }

复制代码

1. public class DefaultSqlSession implements SqlSession {
2.     private Configuration configuration;
4.     public DefaultSqlSession(Configuration configuration) {
5.         this.configuration = configuration;
6.     }
8.     @Override
9.     public <E> List<E> selectList(String statementId, Object... params) throws Exception {
10.         SimpleExecutor simpleExecutor = new SimpleExecutor();
11.         MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
12.         List<Object> list = simpleExecutor.query(configuration, mappedStatement, params);
13.         return (List<E>) list;
14.     }
16.     @Override
17.     public <T> T selectOne(String statementId, Object... params) throws Exception {
18.         List<Object> objects = selectList(statementId, params);
19.         if (objects.size()==1){
20.             return (T) objects.get(0);
21.         }else {
22.             throw new RuntimeException("查询结果为空或者过多");
23.         }
24.     }
25. }

复制代码

在框架端创建Executor接口及着实现类

1. public interface Executor {
2.     public <E>List<E> query(Configuration configuration, MappedStatement mappedStatement,Object... params);
3. }

复制代码

1. public class SimpleExecutor implements Executor {
2.     @Override
3.     public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception {
4.         DataSource dataSource = configuration.getDataSource();
5.         Connection connection = dataSource.getConnection();
6.         String sql = mappedStatement.getSql();
7.         BoundSql boundSql = getBoundSql(sql);
8.         PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSql());
9.         List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
10.         String parameterType = mappedStatement.getParameterType();
11.         Class<?> parameterClass = getClassType(parameterType);
12.         for (int i = 0; i < parameterMappingList.size(); i++) {
13.             ParameterMapping parameterMapping = parameterMappingList.get(i);
14.             String content = parameterMapping.getContent();
16.             Field declaredField = parameterClass.getDeclaredField(content);
17.             declaredField.setAccessible(true);
18.             Object o = declaredField.get(params[0]);
20.             preparedStatement.setObject(i + 1, o);
21.         }
23.         ResultSet resultSet = preparedStatement.executeQuery();
24.         String resultType = mappedStatement.getResultType();
25.         Class<?> resultTypeClass = getClassType(resultType);
26.         Object o = resultTypeClass.newInstance();
27.         ArrayList<Object> objects = new ArrayList<>();
28.         while (resultSet.next()) {
29.             ResultSetMetaData metaData = resultSet.getMetaData();
30.             for (int i = 1; i <= metaData.getColumnCount(); i++) {
31.                 String columnName = metaData.getColumnName(i);
32.                 Object value = resultSet.getObject(columnName);
33.                 PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass);
34.                 Method writeMethod = propertyDescriptor.getWriteMethod();
35.                 writeMethod.invoke(o,value);
36.                 objects.add(o);
37.             }
38.         }
39.         return (List<E>) objects;
40.     }
42.     private BoundSql getBoundSql(String sql) {
43.         ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
44.         GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
45.         String parseSql = genericTokenParser.parse(sql);
46.         List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
47.         BoundSql boundSql = new BoundSql(parseSql, parameterMappings);
48.         return boundSql;
49.     }
51.     private Class<?> getClassType(String parameterType) throws ClassNotFoundException {
52.         if (parameterType != null) {
53.             return Class.forName(parameterType);
54.         }
55.         return null;
56.     }
57. }

复制代码

在框架端创建Sql解析类

1. public class BoundSql {
2.     private String sql;
3.     private List<ParameterMapping> parameterMappingList = new ArrayList<>();
5.     public BoundSql() {
6.     }
8.     public BoundSql(String sql, List<ParameterMapping> parameterMappingList) {
9.         this.sql = sql;
10.         this.parameterMappingList = parameterMappingList;
11.     }
13.     public String getSql() {
14.         return sql;
15.     }
17.     public void setSql(String sql) {
18.         this.sql = sql;
19.     }
21.     public List<ParameterMapping> getParameterMappingList() {
22.         return parameterMappingList;
23.     }
25.     public void setParameterMappingList(List<ParameterMapping> parameterMappingList) {
26.         this.parameterMappingList = parameterMappingList;
27.     }
28. }

复制代码

在框架端创建Sql解析工具类

1. public interface TokenHandler {
2.     String handleToken(String content);
3. }

复制代码

1. public class GenericTokenParser {
3.   private final String openToken; //开始标记
4.   private final String closeToken; //结束标记
5.   private final com.wdlm.utils.TokenHandler handler; //标记处理器
7.   public GenericTokenParser(String openToken, String closeToken, com.wdlm.utils.TokenHandler handler) {
8.     this.openToken = openToken;
9.     this.closeToken = closeToken;
10.     this.handler = handler;
11.   }
13.   /**
14.    * 解析${}和#{}
15.    * @param text
16.    * @return
17.    * 该方法主要实现了配置文件、脚本等片段中占位符的解析、处理工作，并返回最终需要的数据。
18.    * 其中，解析工作由该方法完成，处理工作是由处理器handler的handleToken()方法来实现
19.    */
20.   public String parse(String text) {
21.     // 验证参数问题，如果是null，就返回空字符串。
22.     if (text == null || text.isEmpty()) {
23.       return "";
24.     }
26.     // 下面继续验证是否包含开始标签，如果不包含，默认不是占位符，直接原样返回即可，否则继续执行。
27.     int start = text.indexOf(openToken, 0);
28.     if (start == -1) {
29.       return text;
30.     }
32.    // 把text转成字符数组src，并且定义默认偏移量offset=0、存储最终需要返回字符串的变量builder，
33.     // text变量中占位符对应的变量名expression。判断start是否大于-1(即text中是否存在openToken)，如果存在就执行下面代码
34.     char[] src = text.toCharArray();
35.     int offset = 0;
36.     final StringBuilder builder = new StringBuilder();
37.     StringBuilder expression = null;
38.     while (start > -1) {
39.      // 判断如果开始标记前如果有转义字符，就不作为openToken进行处理，否则继续处理
40.       if (start > 0 && src[start - 1] == '\\') {
41.         builder.append(src, offset, start - offset - 1).append(openToken);
42.         offset = start + openToken.length();
43.       } else {
44.         //重置expression变量，避免空指针或者老数据干扰。
45.         if (expression == null) {
46.           expression = new StringBuilder();
47.         } else {
48.           expression.setLength(0);
49.         }
50.         builder.append(src, offset, start - offset);
51.         offset = start + openToken.length();
52.         int end = text.indexOf(closeToken, offset);
53.         while (end > -1) {存在结束标记时
54.           if (end > offset && src[end - 1] == '\\') {//如果结束标记前面有转义字符时
55.             // this close token is escaped. remove the backslash and continue.
56.             expression.append(src, offset, end - offset - 1).append(closeToken);
57.             offset = end + closeToken.length();
58.             end = text.indexOf(closeToken, offset);
59.           } else {//不存在转义字符，即需要作为参数进行处理
60.             expression.append(src, offset, end - offset);
61.             offset = end + closeToken.length();
62.             break;
63.           }
64.         }
65.         if (end == -1) {
66.           // close token was not found.
67.           builder.append(src, start, src.length - start);
68.           offset = src.length;
69.         } else {
70.           //首先根据参数的key（即expression）进行参数处理，返回?作为占位符
71.           builder.append(handler.handleToken(expression.toString()));
72.           offset = end + closeToken.length();
73.         }
74.       }
75.       start = text.indexOf(openToken, offset);
76.     }
77.     if (offset < src.length) {
78.       builder.append(src, offset, src.length - offset);
79.     }
80.     return builder.toString();
81.   }
82. }

复制代码

1. public class ParameterMapping {
3.     private String content;
5.     public ParameterMapping(String content) {
6.         this.content = content;
7.     }
9.     public String getContent() {
10.         return content;
11.     }
13.     public void setContent(String content) {
14.         this.content = content;
15.     }
16. }

复制代码

1. public class ParameterMappingTokenHandler implements com.wdlm.utils.TokenHandler {
2.         private List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();
4.         // context是参数名称 #{id} #{username}
6.         public String handleToken(String content) {
7.                 parameterMappings.add(buildParameterMapping(content));
8.                 return "?";
9.         }
11.         private ParameterMapping buildParameterMapping(String content) {
12.                 ParameterMapping parameterMapping = new ParameterMapping(content);
13.                 return parameterMapping;
14.         }
16.         public List<ParameterMapping> getParameterMappings() {
17.                 return parameterMappings;
18.         }
20.         public void setParameterMappings(List<ParameterMapping> parameterMappings) {
21.                 this.parameterMappings = parameterMappings;
22.         }
24. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。