经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » 设计模式 » 查看文章
做一个不复制粘贴的程序员[1]: 使用模板方法模式（1）- 分页查询实例
来源：cnblogs　　作者：thinkam　　时间：2019/7/29 9:11:20　　对本文有异议

对于重复的代码，如果是重复的字符串，我们会想到提出一个变量。如果是重复的代码块，我们会想到提取出一个方法。

但如果这重复的代码块中有一处或几处是会变化的，那么就没那么容易提取出一个方法。说起来有点抽象，下面看一个例子。

一、分页查询

写过CRUD的同学肯定写过很多分页查询，分页查询的主要步骤是先校验前端传过来的查询条件（包括哪一页以及每页显示记录数等），如果不合法则设置默认值。然后根据条件查询符合条件的总记录数，以及查询符合条件的一页记录，最后经过处理返回给前端。

这一段话中会变的部分，也就是每个分页查询不同的部分，就是两个查询。这不就是一个模板，对于不同的分页查询，只要往其中填两块代码。

不过有的同学可能会说平时用分页插件，不需要写查询总数的方法，不过有时还是需要自己写查询总数的方法来优化SQL滴。

二、Java8之前的方式

下面是一些核心类

  1. /**
  2.  * 分页查询结果对象
  3.  *
  4.  * @param <T> 分页查询对象类型
  5.  */
  6. @AllArgsConstructor
  7. @Getter
  8. @ToString
  9. public final class Page<T> implements Serializable {
  10.     /**
  11.      * 总记录数
  12.      */
  13.     @NonNull
  14.     private final Long total;
  15.     /**
  16.      * 当前记录集合
  17.      */
  18.     @NonNull
  19.     private final List<T> rows;
  20. }
  1. /**
  2.  * 分页查询模板（Java8之前的写法）
  3.  */
  4. public abstract class AbstractPageTemplate<E> {
  5.     /**
  6.      * "pageNumber"
  7.      */
  8.     public static final String PAGE_NUMBER = "pageNumber";
  9.     /**
  10.      * "pageSize"
  11.      */
  12.     public static final String PAGE_SIZE = "pageBegin";
  13.     /**
  14.      * "pageBegin"
  15.      */
  16.     private static final String PAGE_BEGIN = "pageBegin";
  18.     /**
  19.      * 获取分页结果对象
  20.      * <p>
  21.      * 示例:
  22.      *
  23.      * <pre>
  24.      * {@code
  25.      *      Page<FooDTO> fooDTOPage = PageUtil.page(mapper::selectPageCount1, mapper::selectPageEntities1, paramMap)
  26.      * }
  27.      * </pre>
  28.      *
  29.      * @param paramMap 分页查询参数（key需要包含”pageNumber“和”pageSize“，否则默认查询第一页的20条记录）
  30.      * @return 分页结果对象集合
  31.      */
  32.     public Page<E> page(Map<String, Object> paramMap) {
  33.         Objects.requireNonNull(paramMap);
  34.         // 获取页数
  35.         Integer pageNumber = (Integer) paramMap.get(PAGE_NUMBER);
  36.         // 校验页数，不合法则设置默认值
  37.         pageNumber = pageNumber == null || pageNumber <= 0 ? 1 : pageNumber;
  38.         // 获取页大小，不合法设置默认值
  39.         Integer pageSize = (Integer) paramMap.computeIfAbsent(PAGE_SIZE, k -> 20);
  40.         // 计算SQL中limit的offset（Mysql）
  41.         paramMap.put(PAGE_BEGIN, (pageNumber - 1) * pageSize);
  42.         // 查询符合条件的总记录数
  43.         long total = pageCount(paramMap);
  44.         if (total <= 0) {
  45.             return new Page<>(0L, new ArrayList<>());
  46.         } else {
  47.             // 查询符合条件的一页记录
  48.             return new Page<>(total, pageList(paramMap));
  49.         }
  50.     }
  52.     /**
  53.      * 查询符合条件的总记录数
  54.      *
  55.      * @param paramMap 分页查询参数（key需要包含”pageNumber“和”pageSize“，否则默认查询第一页的20条记录）
  56.      * @return 总记录数
  57.      */
  58.     abstract long pageCount(Map<String, Object> paramMap);
  60.     /**
  61.      * 查询符合条件的所有记录
  62.      *
  63.      * @param paramMap 分页查询参数（key需要包含”pageNumber“和”pageSize“，否则默认查询第一页的20条记录）
  64.      * @return 分页结果集合
  65.      */
  66.     abstract List<E> pageList(Map<String, Object> paramMap);
  67. }

下面是一些为demo准备的类

  1. @Data
  2. public class User {
  3. }
  1. public class UserDAO  {
  2.     public long pageCount(Map<String, Object> paramMap) {
  3.         // select count(*) from user where ...
  4.         return 0;
  5.     }
  7.     public List<User> pageList(Map<String, Object> paramMap) {
  8.         // select * from user where ... limit pageBegin, pageSize
  9.         return new ArrayList<>();
  10.     }
  11. }
  1. public class UserService extends AbstractPageTemplate<User> {
  2.     private UserDAO userDAO = new UserDAO();
  4.     @Override
  5.     public long pageCount(Map<String, Object> paramMap) {
  6.         return userDAO.pageCount(paramMap);
  7.     }
  9.     @Override
  10.     public List<User> pageList(Map<String, Object> paramMap) {
  11.         return userDAO.pageList(paramMap);
  12.     }
  13. }

下面是demo

  1. UserService userService = new UserService();
  3. Page<User> userPage = userService.page(ImmutableMap.of(
  4.                 PageUtil.PAGE_NUMBER, 1,
  5.                 PageUtil.PAGE_SIZE, 20
  6.                 // 其他参数...
  7.         ));

分析下上面这种传统的模板方法模式，我们把样板式的代码写到AbstractPageTemplate#page()方法中，当我们要写新的分页查询时，只要继承AbstractPageTemplate类，然后实现其中的两个方法，就可以很方便的获取到分页结果。

如果没有想到模板方法模式，项目中肯定会有大量的类似于AbstractPageTemplate#page()方法中的代码，而且每个人写的可能会不一样，如果后面要修改默认的每页大小，要找到所有的这些分页代码不是很容易，难免会有遗漏。模板方法模式为后期的重构、扩展提供了便利。

这种传统的方式写起来有点麻烦，一个模块有几个分页查询就要写几个Service类，去继承AbstractPageTemplate类。一个模块有多个service好像有点不合理，如果能把AbstractPageTemplate#pageCount方法和AbstractPageTemplate#pageList方法作为方法参数传入AbstractPageTemplate#page()方法中，那么就方便多了，不用再去写那么多Service类了。还好Java8之后有了lambda表达式，我们就可以把方法作为方法的参数。

三、Java8的方式

下面是核心类

  1. /**
  2.  * 分页查询工具类
  3.  */
  4. public class PageUtil {
  5.     /**
  6.      * "pageNumber"
  7.      */
  8.     public static final String PAGE_NUMBER = "pageNumber";
  9.     /**
  10.      * "pageSize"
  11.      */
  12.     public static final String PAGE_SIZE = "pageSize";
  14.     /**
  15.      * "pageBegin"
  16.      */
  17.     private static final String PAGE_BEGIN = "pageBegin";
  19.     private PageUtil() {
  20.     }
  22.     /**
  23.      * 获取分页结果对象
  24.      * <p>
  25.      * 示例:
  26.      *
  27.      * <pre>
  28.      * {@code
  29.      *      Page<FooDTO> fooDTOPage = PageUtil.page(mapper::selectPageCount1, mapper::selectPageEntities1, paramMap)
  30.      * }
  31.      * </pre>
  32.      *
  33.      * @param pageCountFunction     查询分页总数的方法（参数类型：{@code Map<String, Object>}；返回值类型：{@code int}）
  34.      * @param pageQueryListFunction 查询分页记录的方法（参数类型：{@code Map<String, Object>};；返回值类型：{@code List<E>}）
  35.      * @param paramMap              分页查询参数（key需要包含”pageNumber“和”pageSize“，否则默认查询第一页的20条记录）
  36.      * @return 分页结果对象集合
  37.      */
  38.     public static <E> Page<E> page(ToLongFunction<Map<String, Object>> pageCountFunction,
  39.                                    Function<Map<String, Object>, List<E>> pageQueryListFunction,
  40.                                    Map<String, Object> paramMap) {
  41.         Objects.requireNonNull(pageCountFunction);
  42.         Objects.requireNonNull(pageQueryListFunction);
  43.         Objects.requireNonNull(paramMap);
  44.         Integer pageNumber = (Integer) paramMap.get(PAGE_NUMBER);
  45.         pageNumber = pageNumber == null || pageNumber <= 0 ? 1 : pageNumber;
  46.         Integer pageSize = (Integer) paramMap.computeIfAbsent(PAGE_SIZE, k -> 20);
  47.         paramMap.put(PAGE_BEGIN, (pageNumber - 1) * pageSize);
  48.         long total = pageCountFunction.applyAsLong(paramMap);
  49.         if (total <= 0) {
  50.             return new Page<>(0L, new ArrayList<>());
  51.         } else {
  52.             return new Page<>(total, pageQueryListFunction.apply(paramMap));
  53.         }
  54.     }
  55. }

下面是demo

  1.  Page<User> userPage = PageUtil.page(userService::pageCount, userService::pageList, ImmutableMap.of(
  2.                 PageUtil.PAGE_NUMBER, 1,
  3.                 PageUtil.PAGE_SIZE, 20
  4.                 // 其他参数...
  5.         ));

分析下Java8以后的写法，对于一个模块有多个分页查询的情况，我们只要在Service中定义多个“查询符合条件的总记录数”和“查询符合条件的所有记录”的方法，然后在PageUtil#page方法中传入方法引用。

概括来说，Java8以后我们就可以把方法作为方法的参数传入方法中，从而省去了写很多类去继承抽象的模板类的麻烦。

四、模板方法模式

模板方法模式是一个在我们平时写代码中经常用到的模式，可以帮我们少写很多重复的代码，从而提高开发效率。在一些框架中也会经常看到，比如Spring的JdbcTemplate。GOF给模板方法模式下过以下定义：

定义一个操作中的算法骨架，而将一些步骤迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

如果你不明白这个定义也无所谓，只要你看懂了上面那个Java8的例子就可以了。在我看来，模板方法模式就是把方法传入方法中，有了lambda，就是把把方法作为方法参数传入方法中。


回到本系列的目录

原文链接：http://www.cnblogs.com/thinkam/p/11260726.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

设计模式热门文章

  • java设计模式-装饰者模式详解
  • 设计模式之迭代器与组合模式（四）
  • asp.net Core 中AuthorizationHandler 实现自定义授权
  • 高校宿舍管理系统详细需求分析说明书
  • 依赖注入与控制反转
  • 设计模式-工厂方法模式 实战演习 代码实现 - Code-CHAN
  • 报刊订阅管理系统的设计与实现
  • 深入浅出设计模式 PDF下载高清完整扫描原版
  • TypeScript实现设计模式——生成器模式
  • 小账本软件设计之数据库设计模式构建

    • 设计模式推荐文章

  • 设计模式：代理模式详解
  • 设计模式之工厂模式（学习笔记）
  • Java设计模式总结
  • Java面试题：Spring框架除了IOC和AOP，还有哪些好玩的设计模式？
  • 什么是设计模式？
  • 设计模式学习（一）单例模式的几种实现方式
  • 我们在SqlSugar开发框架中，用到的一些设计模式
  • 3分钟看懂设计模式01：策略模式
  • 设计模式浅析(三) &#183;装饰者模式
  • GOF23--23种设计模式（一）

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号