一、前言

  1. 同龄人的差距是从什么时候拉开的

同样的幼儿园、同样的小学、一样的书本、一样的课堂，有人学习好、有人学习差。不只是上学，几乎人生处处都是赛道，发令枪响起的时刻，也就把人生的差距拉开。编程开发这条路也是很长很宽，有人跑得快有人跑得慢。那么你是否想起过，这一点点的差距到遥不可及的距离，是从哪一天开始的。摸摸肚子的肉，看看远处的路，别人讲的是故事，你想起的都是事故。

  1. 思想没有产品高才写出一片的ifelse

当你承接一个需求的时候，比如；交易、订单、营销、保险等各类场景。如果你不熟悉这个场景下的业务模式，以及将来的拓展方向，那么很难设计出良好可扩展的系统。再加上产品功能初建，说老板要的急，尽快上线。作为程序员的你更没有时间思考，整体一看现在的需求也不难，直接上手开干(一个方法两个if语句)，这样确实满足了当前需求。但老板的想法多呀，产品也跟着变化快，到你这就是改改改，加加加。当然你也不客气，回首掏就是1024个if语句！

  1. 日积月累的技术沉淀是为了厚积薄发

粗略的估算过，如果从上大学开始每天写200行，一个月是6000行，一年算10个月话，就是6万行，第三年出去实习的是时候就有20万行的代码量。如果你能做到这一点，找工作难？有时候很多事情就是靠时间积累出来的，想走捷径有时候真的没有。你的技术水平、你的业务能力、你身上的肉，都是一点点积累下来的，不要浪费看似很短的时间，一年年坚持下来，留下印刻青春的痕迹，多给自己武装上一些能力。

二、开发环境

  1. JDK 1.8
  2. Idea + Maven
  3. mysql 5.1.20
  4. 涉及工程一个，可以通过关注公众号：bugstack虫洞栈，回复源码下载获取(打开获取的链接，找到序号18) | 工程 | 描述 | | :—- | :—- | | itstack-demo-design-16-01 | 使用JDBC方式连接数据库 | | itstack-demo-design-16-02 | 手写ORM框架操作数据库 |

三、中介者模式介绍

第4节：中介者模式 (mybatis) - 图1

中介者模式要解决的就是复杂功能应用之间的重复调用，在这中间添加一层中介者包装服务，对外提供简单、通用、易扩展的服务能力。

这样的设计模式几乎在我们日常生活和实际业务开发中都会见到，例如；飞机🛬降落有小姐姐在塔台喊话、无论哪个方向来的候车都从站台上下、公司的系统中有一个中台专门为你包装所有接口和提供统一的服务等等，这些都运用了中介者模式。除此之外，你用到的一些中间件，他们包装了底层多种数据库的差异化，提供非常简单的方式进行使用。

四、案例场景模拟

第4节：中介者模式 (mybatis) - 图2

在本案例中我们通过模仿Mybatis手写ORM框架，通过这样操作数据库学习中介者运用场景

除了这样的中间件层使用场景外，对于一些外部接口，例如N种奖品服务，可以由中台系统进行统一包装对外提供服务能力。也是中介者模式的一种思想体现。

在本案例中我们会把jdbc层进行包装，让用户在使用数据库服务的时候，可以和使用mybatis一样简单方便，通过这样的源码方式学习中介者模式，也方便对源码知识的拓展学习，增强知识栈。

五、用一坨坨代码实现

  1. 这是一种关于数据库操作最初的方式

基本上每一个学习开发的人都学习过直接使用jdbc方式连接数据库，进行CRUD操作。以下的例子可以当做回忆。

1. 工程结构

  1. itstack-demo-design-16-01
  2. └── src
  3.     └── main
  4.         └── java
  5.             └── org.itstack.demo.design
  6.                 └── JDBCUtil.java
  • 这里的类比较简单只包括了一个数据库操作类。

2. 代码实现

  1. public class JDBCUtil {
  3.     private static Logger logger = LoggerFactory.getLogger(JDBCUtil.class);
  5.     public static final String URL = "jdbc:mysql://127.0.0.1:3306/itstack-demo-design";
  6.     public static final String USER = "root";
  7.     public static final String PASSWORD = "123456";
  9.     public static void main(String[] args) throws Exception {
  10.         //1. 加载驱动程序
  11.         Class.forName("com.mysql.jdbc.Driver");
  12.         //2. 获得数据库连接
  13.         Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
  14.         //3. 操作数据库
  15.         Statement stmt = conn.createStatement();
  16.         ResultSet resultSet = stmt.executeQuery("SELECT id, name, age, createTime, updateTime FROM user");
  17.         //4. 如果有数据 resultSet.next() 返回true
  18.         while (resultSet.next()) {
  19.             logger.info("测试结果 姓名：{} 年龄：{}", resultSet.getString("name"),resultSet.getInt("age"));
  20.         }
  21.     }
  23. }
  • 以上是使用JDBC的方式进行直接操作数据库，几乎大家都使用过这样的方式。

3. 测试结果

  1. 15:38:10.919 [main] INFO  org.itstack.demo.design.JDBCUtil - 测试结果 姓名：水水 年龄：18
  2. 15:38:10.922 [main] INFO  org.itstack.demo.design.JDBCUtil - 测试结果 姓名：豆豆 年龄：18
  3. 15:38:10.922 [main] INFO  org.itstack.demo.design.JDBCUtil - 测试结果 姓名：花花 年龄：19
  5. Process finished with exit code 0
  • 从测试结果可以看到这里已经查询到了数据库中的数据。只不过如果在全部的业务开发中都这样实现，会非常的麻烦。

六、中介模式开发ORM框架

`接下来就使用中介模式的思想完成模仿Mybatis的ORM框架开发~

1. 工程结构

  1. itstack-demo-design-16-02
  2. └── src
  3.     ├── main
  4.     │   ├── java
  5.     │   │   └── org.itstack.demo.design
  6.     │   │       ├── dao
  7.     │   │       │    ├── ISchool.java
  8.     │   │       │    └── IUserDao.java
  9.     │   │       ├── mediator
  10.     │   │       │    ├── Configuration.java
  11.     │   │       │    ├── DefaultSqlSession.java
  12.     │   │       │    ├── DefaultSqlSessionFactory.java
  13.     │   │       │    ├── Resources.java
  14.     │   │       │    ├── SqlSession.java
  15.     │   │       │    ├── SqlSessionFactory.java
  16.     │   │       │    ├── SqlSessionFactoryBuilder.java
  17.     │   │       │    └── SqlSessionFactoryBuilder.java
  18.     │   │       └── po
  19.     │   │             ├── School.java
  20.     │   │             └── User.java
  21.     │   └── resources
  22.     │       ├── mapper
  23.     │       │   ├── School_Mapper.xml
  24.     │       │   └── User_Mapper.xml
  25.     │       └── mybatis-config-datasource.xml
  26.     └── test
  27.          └── java
  28.              └── org.itstack.demo.design.test
  29.                  └── ApiTest.java

中介者模式模型结构

第4节：中介者模式 (mybatis) - 图3

  • 以上是对ORM框架实现的核心类，包括了；加载配置文件、对xml解析、获取数据库session、操作数据库以及结果返回。
  • 左上是对数据库的定义和处理，基本包括我们常用的方法；<T> T selectOne、<T> List<T> selectList等。
  • 右侧蓝色部分是对数据库配置的开启session的工厂处理类，这里的工厂会操作DefaultSqlSession
  • 之后是红色地方的SqlSessionFactoryBuilder，这个类是对数据库操作的核心类；处理工厂、解析文件、拿到session等。

接下来我们就分别介绍各个类的功能实现过程。

2. 代码实现

2.1 定义SqlSession接口

  1. public interface SqlSession {
  3.     <T> T selectOne(String statement);
  5.     <T> T selectOne(String statement, Object parameter);
  7.     <T> List<T> selectList(String statement);
  9.     <T> List<T> selectList(String statement, Object parameter);
  11.     void close();
  12. }
  • 这里定义了对数据库操作的查询接口，分为查询一个结果和查询多个结果，同时包括有参数和没有参数的方法。

2.2 SqlSession具体实现类

  1. public class DefaultSqlSession implements SqlSession {
  3.     private Connection connection;
  4.     private Map<String, XNode> mapperElement;
  6.     public DefaultSqlSession(Connection connection, Map<String, XNode> mapperElement) {
  7.         this.connection = connection;
  8.         this.mapperElement = mapperElement;
  9.     }
  11.     @Override
  12.     public <T> T selectOne(String statement) {
  13.         try {
  14.             XNode xNode = mapperElement.get(statement);
  15.             PreparedStatement preparedStatement = connection.prepareStatement(xNode.getSql());
  16.             ResultSet resultSet = preparedStatement.executeQuery();
  17.             List<T> objects = resultSet2Obj(resultSet, Class.forName(xNode.getResultType()));
  18.             return objects.get(0);
  19.         } catch (Exception e) {
  20.             e.printStackTrace();
  21.         }
  22.         return null;
  23.     }
  25.     @Override
  26.     public <T> List<T> selectList(String statement) {
  27.         XNode xNode = mapperElement.get(statement);
  28.         try {
  29.             PreparedStatement preparedStatement = connection.prepareStatement(xNode.getSql());
  30.             ResultSet resultSet = preparedStatement.executeQuery();
  31.             return resultSet2Obj(resultSet, Class.forName(xNode.getResultType()));
  32.         } catch (Exception e) {
  33.             e.printStackTrace();
  34.         }
  35.         return null;
  36.     }
  38.     // ...
  40.     private <T> List<T> resultSet2Obj(ResultSet resultSet, Class<?> clazz) {
  41.         List<T> list = new ArrayList<>();
  42.         try {
  43.             ResultSetMetaData metaData = resultSet.getMetaData();
  44.             int columnCount = metaData.getColumnCount();
  45.             // 每次遍历行值
  46.             while (resultSet.next()) {
  47.                 T obj = (T) clazz.newInstance();
  48.                 for (int i = 1; i <= columnCount; i++) {
  49.                     Object value = resultSet.getObject(i);
  50.                     String columnName = metaData.getColumnName(i);
  51.                     String setMethod = "set" + columnName.substring(0, 1).toUpperCase() + columnName.substring(1);
  52.                     Method method;
  53.                     if (value instanceof Timestamp) {
  54.                         method = clazz.getMethod(setMethod, Date.class);
  55.                     } else {
  56.                         method = clazz.getMethod(setMethod, value.getClass());
  57.                     }
  58.                     method.invoke(obj, value);
  59.                 }
  60.                 list.add(obj);
  61.             }
  62.         } catch (Exception e) {
  63.             e.printStackTrace();
  64.         }
  65.         return list;
  66.     }
  68.     @Override
  69.     public void close() {
  70.         if (null == connection) return;
  71.         try {
  72.             connection.close();
  73.         } catch (SQLException e) {
  74.             e.printStackTrace();
  75.         }
  76.     }
  77. }
  • 这里包括了接口定义的方法实现，也就是包装了jdbc层。
  • 通过这样的包装可以让对数据库的jdbc操作隐藏起来，外部调用的时候对入参、出参都有内部进行处理。

2.3 定义SqlSessionFactory接口

  1. public interface SqlSessionFactory {
  3.     SqlSession openSession();
  5. }
  • 开启一个SqlSession， 这几乎是大家在平时的使用中都需要进行操作的内容。虽然你看不见，但是当你有数据库操作的时候都会获取每一次执行的SqlSession。

2.4 SqlSessionFactory具体实现类

  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.connection, configuration.mapperElement);
  12.     }
  14. }
  • DefaultSqlSessionFactory，是使用mybatis最常用的类，这里我们简单的实现了一个版本。
  • 虽然是简单的版本，但是包括了最基本的核心思路。当开启SqlSession时会进行返回一个DefaultSqlSession
  • 这个构造函数中向下传递了Configuration配置文件，在这个配置文件中包括；Connection connection、Map<String, String> dataSource、Map<String, XNode> mapperElement。如果有你阅读过Mybatis源码，对这个就不会陌生。

2.5 SqlSessionFactoryBuilder实现

  1. public class SqlSessionFactoryBuilder {
  3.     public DefaultSqlSessionFactory build(Reader reader) {
  4.         SAXReader saxReader = new SAXReader();
  5.         try {
  6.             saxReader.setEntityResolver(new XMLMapperEntityResolver());
  7.             Document document = saxReader.read(new InputSource(reader));
  8.             Configuration configuration = parseConfiguration(document.getRootElement());
  9.             return new DefaultSqlSessionFactory(configuration);
  10.         } catch (DocumentException e) {
  11.             e.printStackTrace();
  12.         }
  13.         return null;
  14.     }
  16.     private Configuration parseConfiguration(Element root) {
  17.         Configuration configuration = new Configuration();
  18.         configuration.setDataSource(dataSource(root.selectNodes("//dataSource")));
  19.         configuration.setConnection(connection(configuration.dataSource));
  20.         configuration.setMapperElement(mapperElement(root.selectNodes("mappers")));
  21.         return configuration;
  22.     }
  24.     // 获取数据源配置信息
  25.     private Map<String, String> dataSource(List<Element> list) {
  26.         Map<String, String> dataSource = new HashMap<>(4);
  27.         Element element = list.get(0);
  28.         List content = element.content();
  29.         for (Object o : content) {
  30.             Element e = (Element) o;
  31.             String name = e.attributeValue("name");
  32.             String value = e.attributeValue("value");
  33.             dataSource.put(name, value);
  34.         }
  35.         return dataSource;
  36.     }
  38.     private Connection connection(Map<String, String> dataSource) {
  39.         try {
  40.             Class.forName(dataSource.get("driver"));
  41.             return DriverManager.getConnection(dataSource.get("url"), dataSource.get("username"), dataSource.get("password"));
  42.         } catch (ClassNotFoundException | SQLException e) {
  43.             e.printStackTrace();
  44.         }
  45.         return null;
  46.     }
  48.     // 获取SQL语句信息
  49.     private Map<String, XNode> mapperElement(List<Element> list) {
  50.         Map<String, XNode> map = new HashMap<>();
  52.         Element element = list.get(0);
  53.         List content = element.content();
  54.         for (Object o : content) {
  55.             Element e = (Element) o;
  56.             String resource = e.attributeValue("resource");
  58.             try {
  59.                 Reader reader = Resources.getResourceAsReader(resource);
  60.                 SAXReader saxReader = new SAXReader();
  61.                 Document document = saxReader.read(new InputSource(reader));
  62.                 Element root = document.getRootElement();
  63.                 //命名空间
  64.                 String namespace = root.attributeValue("namespace");
  66.                 // SELECT
  67.                 List<Element> selectNodes = root.selectNodes("select");
  68.                 for (Element node : selectNodes) {
  69.                     String id = node.attributeValue("id");
  70.                     String parameterType = node.attributeValue("parameterType");
  71.                     String resultType = node.attributeValue("resultType");
  72.                     String sql = node.getText();
  74.                     // ? 匹配
  75.                     Map<Integer, String> parameter = new HashMap<>();
  76.                     Pattern pattern = Pattern.compile("(#\\{(.*?)})");
  77.                     Matcher matcher = pattern.matcher(sql);
  78.                     for (int i = 1; matcher.find(); i++) {
  79.                         String g1 = matcher.group(1);
  80.                         String g2 = matcher.group(2);
  81.                         parameter.put(i, g2);
  82.                         sql = sql.replace(g1, "?");
  83.                     }
  85.                     XNode xNode = new XNode();
  86.                     xNode.setNamespace(namespace);
  87.                     xNode.setId(id);
  88.                     xNode.setParameterType(parameterType);
  89.                     xNode.setResultType(resultType);
  90.                     xNode.setSql(sql);
  91.                     xNode.setParameter(parameter);
  93.                     map.put(namespace + "." + id, xNode);
  94.                 }
  95.             } catch (Exception ex) {
  96.                 ex.printStackTrace();
  97.             }
  99.         }
  100.         return map;
  101.     }
  103. }
  • 在这个类中包括的核心方法有；build(构建实例化元素)、parseConfiguration(解析配置)、dataSource(获取数据库配置)、connection(Map<String, String> dataSource) (链接数据库)、mapperElement (解析sql语句)
  • 接下来我们分别介绍这样的几个核心方法。

build(构建实例化元素)

这个类主要用于创建解析xml文件的类，以及初始化SqlSession工厂类DefaultSqlSessionFactory。另外需要注意这段代码saxReader.setEntityResolver(new XMLMapperEntityResolver());，是为了保证在不联网的时候一样可以解析xml，否则会需要从互联网获取dtd文件。

parseConfiguration(解析配置)

是对xml中的元素进行获取，这里主要获取了；dataSource、mappers，而这两个配置一个是我们数据库的链接信息，另外一个是对数据库操作语句的解析。

connection(Map dataSource) (链接数据库)

链接数据库的地方和我们常见的方式是一样的；Class.forName(dataSource.get("driver"));，但是这样包装以后外部是不需要知道具体的操作。同时当我们需要链接多套数据库的时候，也是可以在这里扩展。

mapperElement (解析sql语句)

这部分代码块内容相对来说比较长，但是核心的点就是为了解析xml中的sql语句配置。在我们平常的使用中基本都会配置一些sql语句，也有一些入参的占位符。在这里我们使用正则表达式的方式进行解析操作。

解析完成的sql语句就有了一个名称和sql的映射关系，当我们进行数据库操作的时候，这个组件就可以通过映射关系获取到对应sql语句进行操作。

3. 测试验证

在测试之前需要导入sql语句到数据库中;

  • 库名：itstack-demo-design
  • 表名：user、school
  1. CREATE TABLE school ( id bigint NOT NULL AUTO_INCREMENT, name varchar(64), address varchar(256), createTime datetime, updateTime datetime, PRIMARY KEY (id) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  2. insert into school (id, name, address, createTime, updateTime) values (1, '北京大学', '北京市海淀区颐和园路5号', '2019-10-18 13:35:57', '2019-10-18 13:35:57');
  3. insert into school (id, name, address, createTime, updateTime) values (2, '南开大学', '中国天津市南开区卫津路94号', '2019-10-18 13:35:57', '2019-10-18 13:35:57');
  4. insert into school (id, name, address, createTime, updateTime) values (3, '同济大学', '上海市彰武路1号同济大厦A楼7楼7区', '2019-10-18 13:35:57', '2019-10-18 13:35:57');
  5. CREATE TABLE user ( id bigint(11) NOT NULL AUTO_INCREMENT, name varchar(32), age int(4), address varchar(128), entryTime datetime, remark varchar(64), createTime datetime, updateTime datetime, status int(4) DEFAULT '0', dateTime varchar(64), PRIMARY KEY (id), INDEX idx_name (name) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  6. insert into user (id, name, age, address, entryTime, remark, createTime, updateTime, status, dateTime) values (1, '水水', 18, '吉林省榆树市黑林镇尹家村5组', '2019-12-22 00:00:00', '无', '2019-12-22 00:00:00', '2019-12-22 00:00:00', 0, '20200309');
  7. insert into user (id, name, age, address, entryTime, remark, createTime, updateTime, status, dateTime) values (2, '豆豆', 18, '辽宁省大连市清河湾司马道407路', '2019-12-22 00:00:00', '无', '2019-12-22 00:00:00', '2019-12-22 00:00:00', 1, null);
  8. insert into user (id, name, age, address, entryTime, remark, createTime, updateTime, status, dateTime) values (3, '花花', 19, '辽宁省大连市清河湾司马道407路', '2019-12-22 00:00:00', '无', '2019-12-22 00:00:00', '2019-12-22 00:00:00', 0, '20200310');

3.1 创建数据库对象类

用户类

  1. public class User {
  3.     private Long id;
  4.     private String name;
  5.     private Integer age;
  6.     private Date createTime;
  7.     private Date updateTime;
  9.     // ... get/set
  10. }

学校类

  1. public class School {
  3.     private Long id;
  4.     private String name;
  5.     private String address;
  6.     private Date createTime;
  7.     private Date updateTime;  
  9.     // ... get/set
  10. }
  • 这两个类都非常简单，就是基本的数据库信息。

3.2 创建DAO包

用户Dao

  1. public interface IUserDao {
  3.      User queryUserInfoById(Long id);
  5. }

学校Dao

  1. public interface ISchoolDao {
  3.     School querySchoolInfoById(Long treeId);
  5. }

3.3 ORM配置文件

链接配置

  1. <configuration>
  2.     <environments default="development">
  3.         <environment id="development">
  4.             <transactionManager type="JDBC"/>
  5.             <dataSource type="POOLED">
  6.                 <property name="driver" value="com.mysql.jdbc.Driver"/>
  7.                 <property name="url" value="jdbc:mysql://127.0.0.1:3306/itstack_demo_design?useUnicode=true"/>
  8.                 <property name="username" value="root"/>
  9.                 <property name="password" value="123456"/>
  10.             </dataSource>
  11.         </environment>
  12.     </environments>
  14.     <mappers>
  15.         <mapper resource="mapper/User_Mapper.xml"/>
  16.         <mapper resource="mapper/School_Mapper.xml"/>
  17.     </mappers>
  19. </configuration>
  • 这个配置与我们平常使用的mybatis基本是一样的，包括了数据库的连接池信息以及需要引入的mapper映射文件。

操作配置(用户)

  1. <mapper namespace="org.itstack.demo.design.dao.IUserDao">
  3.     <select id="queryUserInfoById" parameterType="java.lang.Long" resultType="org.itstack.demo.design.po.User">
  4.         SELECT id, name, age, createTime, updateTime
  5.         FROM user
  6.         where id = #{id}
  7.     </select>
  9.     <select id="queryUserList" parameterType="org.itstack.demo.design.po.User" resultType="org.itstack.demo.design.po.User">
  10.         SELECT id, name, age, createTime, updateTime
  11.         FROM user
  12.         where age = #{age}
  13.     </select>
  15. </mapper>

操作配置(学校)

  1. <mapper namespace="org.itstack.demo.design.dao.ISchoolDao">
  3.     <select id="querySchoolInfoById" resultType="org.itstack.demo.design.po.School">
  4.         SELECT id, name, address, createTime, updateTime
  5.         FROM school
  6.         where id = #{id}
  7.     </select>
  9. </mapper>

3.4 单个结果查询测试

  1. @Test
  2. public void test_queryUserInfoById() {
  3.     String resource = "mybatis-config-datasource.xml";
  4.     Reader reader;
  5.     try {
  6.         reader = Resources.getResourceAsReader(resource);
  7.         SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
  8.         SqlSession session = sqlMapper.openSession();
  9.         try {
  10.             User user = session.selectOne("org.itstack.demo.design.dao.IUserDao.queryUserInfoById", 1L);
  11.             logger.info("测试结果：{}", JSON.toJSONString(user));
  12.         } finally {
  13.             session.close();
  14.             reader.close();
  15.         }
  16.     } catch (Exception e) {
  17.         e.printStackTrace();
  18.     }
  19. }
  • 这里的使用方式和Mybatis是一样的，都包括了；资源加载和解析、SqlSession工厂构建、开启SqlSession以及最后执行查询操作selectOne

测试结果

  1. 16:56:51.831 [main] INFO  org.itstack.demo.design.demo.ApiTest - 测试结果：{"age":18,"createTime":1576944000000,"id":1,"name":"水水","updateTime":1576944000000}
  3. Process finished with exit code 0
  • 从结果上看已经满足了我们的查询需求。

3.5 集合结果查询测试

  1. @Test
  2. public void test_queryUserList() {
  3.     String resource = "mybatis-config-datasource.xml";
  4.     Reader reader;
  5.     try {
  6.         reader = Resources.getResourceAsReader(resource);
  7.         SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
  8.         SqlSession session = sqlMapper.openSession();
  9.         try {
  10.             User req = new User();
  11.             req.setAge(18);
  12.             List<User> userList = session.selectList("org.itstack.demo.design.dao.IUserDao.queryUserList", req);
  13.             logger.info("测试结果：{}", JSON.toJSONString(userList));
  14.         } finally {
  15.             session.close();
  16.             reader.close();
  17.         }
  18.     } catch (Exception e) {
  19.         e.printStackTrace();
  20.     }
  21. }
  • 这个测试内容与以上只是查询方法有所不同；session.selectList，是查询一个集合结果。

测试结果

  1. 16:58:13.963 [main] INFO  org.itstack.demo.design.demo.ApiTest - 测试结果：[{"age":18,"createTime":1576944000000,"id":1,"name":"水水","updateTime":1576944000000},{"age":18,"createTime":1576944000000,"id":2,"name":"豆豆","updateTime":1576944000000}]
  3. Process finished with exit code 0
  • 测试验证集合的结果也是正常的，目前位置测试全部通过。

七、总结

  • 以上通过中介者模式的设计思想我们手写了一个ORM框架，隐去了对数据库操作的复杂度，让外部的调用方可以非常简单的进行操作数据库。这也是我们平常使用的Mybatis的原型，在我们日常的开发使用中，只需要按照配置即可非常简单的操作数据库。
  • 除了以上这种组件模式的开发外，还有服务接口的包装也可以使用中介者模式来实现。比如你们公司有很多的奖品接口需要在营销活动中对接，那么可以把这些奖品接口统一收到中台开发一个奖品中心，对外提供服务。这样就不需要每一个需要对接奖品的接口，都去找具体的提供者，而是找中台服务即可。
  • 在上述的实现和测试使用中可以看到，这种模式的设计满足了；单一职责和开闭原则，也就符合了迪米特原则，即越少人知道越好。外部的人只需要按照需求进行调用，不需要知道具体的是如何实现的，复杂的一面已经有组件合作服务平台处理。