0
0

SpringBoot中间件—ORM(Mybatis)框架实现

源码地址（已开源）：https://gitee.com/sizhaohe/mini-mybatis.git 跟着源码及下述UML图来理解上手会更快，拒绝浮躁，沉下心来搞

定义：

  1.     ORM：Object Relational Mapping  -->  对象关系映射，是一种程序设计技术，用于实现面向对象编程语言里面不同类型系统的数据之间的转换

需求背景：

  1.     记不记得刚开始学JAVA时，编写一大串JDBC相关代码来进行与数据库的交互，日后我们接触到的MyBatis、MyBatisPlus等都是使用ORM组件来实现的框架。          
  3.     本篇文章提炼出mybatis【最】经典、【最】精简、【最】核心的代码设计，来实现一个【mini-mybatis】,从而**熟悉并掌握ORM框架的涉及实现。**

方案设计：

  1.     ![](https://img-blog.csdnimg.cn/0b815b8e2a094a09b54c21fa2264e688.png)
  • 中间的四部分处理是ORM框架的核心内容
  • 这个框架会提供出SqlSession工厂以及调用方式

代码展示

UML图

很重要，建议code前跟我一样，先将类UML图整理出来，整个类的依赖关系及代码执行流程会一目而然。

篇幅有限，展开观看

  • 以上为ORM框架实现核心类：加载mysql配置文件、对mapper-xml解析、获取数据库session、操作数据库及封装响应结果。

实现细节

1.定义sqlsession接口

对数据库的定义和处理，本篇我们只封装一个 T selectOne(Object param);

  1. public interface SqlSession {
  3.     <T> T selectOne(String statement, Object parameter);
  5.     void close();
  6. }

2.DefaultSqlSession(SqlSession的实现)

使用rt.jar包下（java.lang.sql包下）

Connection接口（负责与数据库进行连接）及PreparedStatement（执行具体sql）接口来实现

  1. public class DefaultSqlSession implements SqlSession{
  3.     private Connection connection;
  5.     private Map<String,XNode> mapperElement;
  7.     public DefaultSqlSession(Connection connection, Map<String, XNode> mapperElement) {
  8.         this.connection = connection;
  9.         this.mapperElement = mapperElement;
  10.     }
  12.     @Override
  13.     public <T> T selectOne(String statement, Object parameter) {
  14.         XNode xNode = mapperElement.get(statement);
  15.         Map<Integer, String> parameterMap = xNode.getParameter();
  16.         try {
  17.             PreparedStatement preparedStatement = connection.prepareStatement(xNode.getSql());
  18.             buildParameter(preparedStatement, parameter, parameterMap);
  19.             // SQL执行结果集的行数据
  20.             ResultSet resultSet = preparedStatement.executeQuery();
  21.             List<T> objects = resultSet2Obj(resultSet, Class.forName(xNode.getResultType()));
  22.             return objects.get(0);
  23.         } catch (Exception e) {
  24.             e.printStackTrace();
  25.         }
  26.         return null;
  27.     }
  29.     private <T> List<T> resultSet2Obj(ResultSet resultSet, Class<?> clazz) {
  30.         List<T> list = new ArrayList<>();
  31.         try {
  32.             ResultSetMetaData metaData = resultSet.getMetaData();
  33.             int columnCount = metaData.getColumnCount();
  34.             // 每次遍历行值
  35.             while (resultSet.next()) {
  36.                 T obj = (T) clazz.newInstance();
  37.                 for (int i = 1; i <= columnCount; i++) {
  38.                     Object value = resultSet.getObject(i);
  39.                     String columnName = metaData.getColumnName(i);
  40.                     String setMethod = "set" + columnName.substring(0, 1).toUpperCase() + columnName.substring(1);
  41.                     Method method;
  42.                     if (value instanceof Timestamp) {
  43.                         method = clazz.getMethod(setMethod, Date.class);
  44.                     } else {
  45.                         method = clazz.getMethod(setMethod, value.getClass());
  46.                     }
  47.                     method.invoke(obj, value);
  48.                 }
  49.                 list.add(obj);
  50.             }
  51.         } catch (Exception e) {
  52.             e.printStackTrace();
  53.         }
  54.         return list;
  55.     }
  56.     
  58.     @Override
  59.     public void close() {
  60.         if (null == connection) return;
  61.         try {
  62.             connection.close();
  63.         } catch (SQLException e) {
  64.             e.printStackTrace();
  65.         }
  66.     }
  68.     private void buildParameter(PreparedStatement preparedStatement, Object parameter, Map<Integer, String> parameterMap) throws SQLException, IllegalAccessException {
  70.         int size = parameterMap.size();
  71.         // 单个参数
  72.         if (parameter instanceof Long) {
  73.             for (int i = 1; i <= size; i++) {
  74.                 preparedStatement.setLong(i, Long.parseLong(parameter.toString()));
  75.             }
  76.             return;
  77.         }else{
  78.             // TODO 后面紧跟的章节继续补充其他类型的入参
  79.         }
  80.         
  81.     }
  82. }

3.定义SqlSessionFactory接口

  1.     每次执行一个SQL语句，应用程序都需要获取一个SqlSession对象。SqlSession对象是执行持久化操作的入口点，可以用于执行SQL语句、刷新缓存、提交事务等操作。建议在使用完SqlSession后，及时关闭它来释放资源。
  1. public interface SqlSessionFactory {
  3.     SqlSession openSession();
  4. }

4.DefaultSqlSessionFactory(上述接口实现类)

  1.     构造方法中向下传递了Configuration配置文件
  1. public class DefaultSqlSessionFactory implements SqlSessionFactory {
  3.     private final Configuration configuration;
  5.     public DefaultSqlSessionFactory(Configuration configuration) {
  6.         this.configuration = configuration;
  7.     }
  9.     @Override
  10.     public SqlSession openSession() {
  11.         return new DefaultSqlSession(configuration.getConnection(), configuration.getMapperElement());
  12.     }
  13. }

5.SqlSessionFactoryBuilder

  1.     数据库操作的核心类，负责解析Mapper文件（拿datasource，数据库连接信息，mapper文件中sql的各个信息如id，入返参类型，sql）
  1. public class SqlSessionFactoryBuilder {
  3.     public DefaultSqlSessionFactory build(Reader reader) {
  4.         SAXReader saxReader = new SAXReader();
  5.         Document document = null;
  6.         try {
  7.             document = saxReader.read(new InputSource(reader));
  8.             // 拿到根标签元素
  9.             Element rootElement = document.getRootElement();
  10.             Configuration configuration = parseConfiguration(rootElement);
  11.             return new DefaultSqlSessionFactory(configuration);
  12.         } catch (DocumentException e) {
  13.             e.printStackTrace();
  14.         }
  15.         return null;
  16.     }
  18.     public Configuration parseConfiguration(Element rootElement) {
  19.         Configuration configuration = new Configuration();
  20.         configuration.setDataSource(dataSource(rootElement.selectNodes("//dataSource")));
  21.         configuration.setConnection(connection(configuration.getDataSource()));
  22.         configuration.setMapperElement(mapperElement(rootElement.selectNodes("//mappers")));
  23.         return configuration;
  24.     }
  26.     private Map<String, String> dataSource(List<Element> list) {
  27.         Map<String, String> dataSource = new HashMap<>(4);
  28.         Element element = list.get(0);
  29.         List content = element.content();
  30.         for (Object o : content) {
  31.             Element e = (Element) o;
  32.             String name = e.attributeValue("name");
  33.             String value = e.attributeValue("value");
  34.             dataSource.put(name, value);
  35.         }
  36.         return dataSource;
  37.     }
  39.     private Connection connection(Map<String, String> dataSource) {
  40.         try {
  41.             return DriverManager.getConnection(dataSource.get("url"), dataSource.get("username"), dataSource.get("password"));
  42.         } catch (SQLException e) {
  43.             e.printStackTrace();
  44.         }
  45.         return null;
  46.     }
  48.     private Map<String, XNode> mapperElement(List<Element> list) {
  49.         Map<String, XNode> map = new HashMap<>();
  50.         Element element = list.get(0);
  51.         List content = element.content();
  52.         try {
  53.             for (Object o : content) {
  54.                 Element e = (Element) o;
  55.                 // 拿到mapper文件对应地址
  56.                 String resource = e.attributeValue("resource");
  57.                 Reader reader = Resources.getResourceAsReader(resource);
  58.                 SAXReader saxReader = new SAXReader();
  59.                 Document document = saxReader.read(new InputSource(reader));
  60.                 Element rootElement = document.getRootElement();
  61.                 String namespace = rootElement.attributeValue("namespace");
  62.                 List<Element> selectNodes = rootElement.selectNodes("select");
  63.                 for (Element ele : selectNodes) {
  64.                     String id = ele.attributeValue("id");
  65.                     String parameterType = ele.attributeValue("parameterType");
  66.                     String resultType = ele.attributeValue("resultType");
  67.                     String sql = ele.getText();
  68.                     // ? 匹配
  69.                     Map<Integer, String> parameter = new HashMap<>();
  70.                     Pattern pattern = Pattern.compile("(#\\{(.*?)})");
  71.                     Matcher matcher = pattern.matcher(sql);
  72.                     for (int i = 1; matcher.find(); i++) {
  73.                         String g1 = matcher.group(1);
  74.                         String g2 = matcher.group(2);
  75.                         parameter.put(i, g2);
  76.                         sql = sql.replace(g1, "?");
  77.                     }
  78.                     XNode xNode = new XNode();
  79.                     xNode.setId(id);
  80.                     xNode.setNameSpace(namespace);
  81.                     xNode.setParameterType(parameterType);
  82.                     xNode.setResultType(resultType);
  83.                     xNode.setSql(sql);
  84.                     xNode.setParameter(parameter);
  85.                     map.put(namespace + "." + id, xNode);
  86.                 }
  87.             }
  88.         }catch (Exception e){
  89.             e.printStackTrace();
  90.         }
  91.         return map;
  92.     }
  93. }

测试验证

建表

  1. DROP TABLE IF EXISTS `user`;
  2. CREATE TABLE `user` (
  3.   `id` bigint(20) NOT NULL COMMENT '自增id',
  4.   `userId` varchar(9) DEFAULT NULL COMMENT '用户ID',
  5.   `userNickName` varchar(32) DEFAULT NULL COMMENT '用户昵称',
  6.   `userHead` varchar(255) DEFAULT NULL COMMENT '用户头像',
  7.   `userPassword` varchar(255) DEFAULT NULL COMMENT '用户密码',
  8.   `createTime` datetime DEFAULT NULL COMMENT '创建时间',
  9.   `updateTime` datetime NOT NULL COMMENT '更新时间',
  10.   PRIMARY KEY (`id`)
  11. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  13. -- ----------------------------
  14. -- Records of user
  15. -- ----------------------------
  16. BEGIN;
  17. INSERT INTO `user` VALUES (1, '001', 'xxx', '001', '123', '2023-07-14 17:33:55', '2023-07-14 17:33:58');
  18. INSERT INTO `user` VALUES (2, '002', 'xxx2', '002', '123', '2023-07-14 17:33:55', '2023-07-14 17:33:58');
  19. COMMIT;
  21. SET FOREIGN_KEY_CHECKS = 1;

定义POJO及DAO

  1. @Data
  2. public class User {
  4.     private Long id;
  5.     private String userId;          // 用户ID
  6.     private String userNickName;    // 昵称
  7.     private String userHead;        // 头像
  8.     private String userPassword;    // 密码
  9.     private Date createTime;        // 创建时间
  10.     private Date updateTime;        // 更新时间
  11. }
  1. public interface IUserDao {
  2.      User queryUserInfoById(Long id);
  3. }

ORM配置文件--mybatis-config-datasource.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  3.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.     <environments default="development">
  7.         <environment id="development">
  8.             <transactionManager type="JDBC"/>
  9.             <dataSource type="POOLED">
  10.                 <property name="driver" value="com.mysql.jdbc.Driver"/>
  11.                 <property name="url" value="jdbc:mysql://172.17.1.245:3306/airticketbasedb?useUnicode=true"/>
  12.                 <property name="username" value="write"/>
  13.                 <property name="password" value="write123"/>
  14.             </dataSource>
  15.         </environment>
  16.     </environments>
  18.     <mappers>
  19.         <mapper resource="mapper/User_Mapper.xml"/>
  20.     </mappers>
  22. </configuration>

Mapper配置

UserMapper.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.example.minimybatis.dao.IUserDao">
  5.     <select id="queryUserInfoById" parameterType="java.lang.Long" resultType="com.example.minimybatis.po.User">
  6.         SELECT id, userId, userNickName, userHead, userPassword, createTime
  7.         FROM user
  8.         where id = #{id}
  9.     </select>
  11. </mapper>

测试类

  1. public class ApiTest {
  2.     @Test
  3.     public void test(){
  4.         String resouce = "mybatis-config-datasource.xml";
  5.         Reader reader;
  6.         try{
  7.             reader = Resources.getResourceAsReader(resouce);
  8.             SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
  9.             SqlSession sqlSession = sqlSessionFactory.openSession();
  10.             User user = sqlSession.selectOne(
  11.                     "com.example.minimybatis.dao.IUserDao.queryUserInfoById",
  12.                     1L);
  13.             System.out.println(JSONObject.toJSONString(user));
  14.         }catch (Exception e){
  15.             e.printStackTrace();
  16.         }
  17.     }
  18. }

总结

比mybatis小很多，取其(mybaits)精华来达到掌握ORM框架的目的

标签： spring boot 中间件 后端
本文转载自: https://blog.csdn.net/weixin_44758548/article/details/131754571
版权归原作者 看表该更新博客了 所有， 如有侵权，请联系我们删除。
登录后发布评论

“SpringBoot中间件—ORM(Mybatis)框架实现”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？