写程序这么精简真的好吗？

[wsy190]

我有一个同事写代码特别精简。。如：

public OutVoGlobal list(BatteryOrderDTO dto, UserInfo user) {

return new OutVoGlobal(EnumRetCode.SUCCESS).setData(orderMapper.list(dto.setBelong(user.getUserNo())));

}

之后这段代码有一些问题，让我来修改这段代码。。我就觉得这段代码的可读性特别的差。昨天和他讨论了一下，他觉得代码行数多影响阅读，他这样他看起来很舒服。以下是我加了判断后的：

public OutVoGlobal list(BatteryOrderDTO dto, UserInfo user) {

    OutVoGlobal outVoGlobal=new OutVoGlobal(EnumRetCode.SUCCESS);
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    if(!StringUtils.isEmpty(dto.getStartTime())){
        try {
            sdf.parse(dto.getStartTime());
            dto.setStartTime(dto.getStartTime()+" 00:00:00");
        } catch (ParseException e) {
            dto.setStartTime("");
        }
    }
    if(!StringUtils.isEmpty(dto.getEndTime())){
        try {
            sdf.parse(dto.getEndTime());
            dto.setEndTime(dto.getEndTime()+" 23:59:59");
        } catch (ParseException e) {
            dto.setEndTime("");
        }
    }
    dto.setBelong(user.getUserNo());
    PageHelper.startPage(dto.getPageNo(), dto.getPageSize());
    List<BatteryOrder> list=orderMapper.list(dto);
    outVoGlobal.setData(list);
    return outVoGlobal;

}

如果没有改动的话这段代码我一定会这么写：

public OutVoGlobal list(BatteryOrderDTO dto, UserInfo user) {

    OutVoGlobal outVoGlobal=new OutVoGlobal(EnumRetCode.SUCCESS);
    dto.setBelong(user.getUserNo());
    PageHelper.startPage(dto.getPageNo(), dto.getPageSize());
    List<BatteryOrder> list=orderMapper.list(dto);
    outVoGlobal.setData(list);
    return outVoGlobal;
}

确实是代码增加了很多行，但是我觉得这样写当我要进行断点调试的时候会很舒服。而且当别人要改我代码的时候也能一目了然。。 然后他说如果你要加上面的新需求的话可以这么写

public OutVoGlobal list(BatteryOrderDTO dto, UserInfo user) {

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    if(!StringUtils.isEmpty(dto.getStartTime())){
        try {
            sdf.parse(dto.getStartTime());
            dto.setStartTime(dto.getStartTime()+" 00:00:00");
        } catch (ParseException e) {
            dto.setStartTime("");
        }
    }
    if(!StringUtils.isEmpty(dto.getEndTime())){
        try {
            sdf.parse(dto.getEndTime());
            dto.setEndTime(dto.getEndTime()+" 23:59:59");
        } catch (ParseException e) {
            dto.setEndTime("");
        }
    }
   return new OutVoGlobal(EnumRetCode.SUCCESS).setData(orderMapper.list(dto.setBelong(user.getUserNo()))
}

我一想，这么写也可以呢。但是我还是觉得他最后那个 return 看起来太麻烦了，我又没有理由反驳他。 其实在写代码的过程中我发现他有好多的习惯我都不习惯。比如说我一般都是这么写：

OutVoGlobal outVoGlobal=new OutVoGlobal(EnumRetCode.SUCCESS);

…… if(StringUtils.isEmpty(XXX)){

outVoGlobal.setCode("1000");
outVoGlobal.setInfo(XXX+"不能为空");
// return outVoGlobal.setCode("1000").setInfo(XXX+"不能为空");
return outVoGlobal;

} if(StringUtils.isEmpty(SSSS)){

outVoGlobal.setCode("1000");
outVoGlobal.setInfo(SSS+"不能为空");
return outVoGlobal;

} …… return outVoGlobal;

如果我也用了插件的话我会这么写

OutVoGlobal outVoGlobal=new OutVoGlobal(EnumRetCode.SUCCESS);

…… if(StringUtils.isEmpty(XXX)){

return outVoGlobal.setCode("1000").setInfo(XXX+"不能为空");

} if(StringUtils.isEmpty(SSSS)){

 return outVoGlobal.setCode("1000").setInfo(SSS+"不能为空");

} …… return outVoGlobal;

他如果写的话会这么写：(加了 @Accessors(chain = true)的前提下)

…… if(StringUtils.isEmpty(XXX)){

return new OutVoGlobal().setInfo(XXX+"不能为空").setCode("1000");

} if(StringUtils.isEmpty(SSSS)){

 return new OutVoGlobal().setInfo(SSS+"不能为空").setCode("1000");

} …… return new OutVoGlobal(EnumRetCode.SUCCESS);

大家觉得是先把这个变量在开始的时候声明了好还是在用到的时候直接返回好呢？

然后还有别的：

if (userData == null) return outError(outVo, EnumRetCode.NO_REGISTER, "未查询到用户信息, userNo -->{}", user.getUserNo()); else if (!userData.getPwd().equals(pwd = encrypt(user.getUserNo(), user.getPwd())))

        return outError(outVo, EnumRetCode.ERROR_PWD, "密码错误, userNo -->{} | pwdData -->{} | pwdInput -->{}", user.getUserNo(), userData.getPwd(), pwd);

else if (!StringUtils.isEmpty(userData.getOpenId()) && !openid.equals(userData.getOpenId())) // 删除上一个用户信息

        redisUtil.delMapKey(param.getUserKey() + userData.getOpenId(), "userInfo", "null");

这种。。。if 和 else if 他后面都跟了一行，之后 他就省去了{} 他特别喜欢这么写代码。可是我每次看都要自己看一下才知道他是怎么做的。。虽然说他只写了一行，但是我看的时候还是会脑补成我写的那样。。

if (!"0000".equals(TokenUtil.verify(outVo, tokenMap).getCode()))

        return outVo;

他还喜欢把变量声明写在一行上。。

String openid = (String) tokenMap.get("openid"),userMapKey;

这样的代码我找 userMapKey 就很懵逼。。

再贴一段代码： if (userMap == null || userMap.get("userInfo") == null) {

        // 获取已绑定的用户信息
        if ((user = userInfoDao.getByOpenId(openid)) == null) return null;

        redisUtil.saveMapSecond(userMapKey, "userInfo", JSONObject.toJSONString(user), appParam.getCacheTime());

    } else

        user = JSONObject.parseObject(userMap.get("userInfo").toString(), UserInfo.class);

反正我是看不习惯。。。大家觉得呢。这么写是好还是不好呢。。

讲真，我是抱着讨论的态度来发的。
因为自己也不清楚到底哪种方法合适，因为我觉得他说的也有道理，但是我也觉得我这么写还行。
当然了帖子绝对有我个人的主观倾向，我更愿意大家说我这么写好，所以我要在帖子里让大家更同意我的观点。
我有问题就改。他有问题的话我就不去模仿。
其实我主观认为两个人都有问题，我写的代码逻辑多了也臃肿，他写的让别人维护和 debug 也挺麻烦，就和之前有人回帖那样似的。两个人中和一下，可以把大的功能写在单独的方法里。

[wsy190]

为了讨论这件事昨天还特意注册了一个账号。。。
第一发帖不太会用这个编辑器。。。

[delectate]

滥用语法糖、缩行、炫技的程序员，我们上次已经炖汤了，味道不错，就是肉有点塞牙。

下次再碰到这样的程序员，直接给我们送过来就行。

[iiicarus]

这样挺好的

[shawnbluce]

有一句话：“代码是写给人看的，顺便给机器执行”

[gwybiaim]

所有的目的是为了，可读性、可维护性。在很多代码规范里，长长的一行是不被推荐的。你也提到了，可读性差、不方便 debug，更关键的是，如果拆开多行，天然有变量名，对读代码来说，非常有利

[wsy190]

@shawnbluce 他是觉得这么写比写好多行看起来方便。。
而我是觉得看很多行方便容易理解，看他那一行很麻烦，还得挨个分析。。

[pingpingping]

据说古龙当初为了酒钱，老是分行分段么。。
还是金庸的排版好经典啊

[0x11901]

有的人总总觉得他有一点个人的理解，他要把他的那个理解给实现，他的理解就是小鱼人点四级跳，然后带个点金手来打架。这种理解他觉得很到位，其实没什么用的。你先把最普通的那种打法打好，再去尝试自己的想法……

[zhanggg]

建议让那个老哥看看人月神话，软件工程本质还是工程，自己一个人炫技不考虑其他人感受，完全就是 XX
当然一人全栈的项目除外，你爱咋写咋写

[IceChen]

链式调用，没什么问题。。
好的链式调用，连起来，就是一句话。。

[wsy190]

@0x11901
其实这是个 98 年的小同事写的。。（我 94。。）

[wysnylc]

链式调用,没任何问题啊
链式调用一样可以写注释
而且第二段代码和第一段完全不一样,第一段只是单纯的 set 第二段有大量的判断逻辑能一样比较?
链式调用也是炫技?我活在 2000?

[LuciferGo]

如果是刚开始写代码的人，还是建议改过来，代码的可读性、可维护性还是很重要的，长长的写一行自己看有时候都不方便看，更不要说交给后续接手的人了。

[wysnylc]

还有 SimpleDateFormat 高并发下存在问题,都已经禁用的东西你还敢用
你多久没有学过新技术?

[wsy190]

@IceChen
我是觉得这句话干的事情有点多。不过确实是没问题。。刚用阿里编码规范扫描了一下，都没问题。。。但是我觉得第一次读起来不算太习惯。。

new OutVoGlobal(EnumRetCode.SUCCESS).setData(orderMapper.list(dto.setBelong(user.getUserNo()))
1：新建了一个 OutVoGlobal
2：给 OutVoGlobal 赋了一个 EnumRetCode.SUCCESS 的值
3：给 OutVoGlobal 的 Date 赋值 A
4：A 是用 orderMapper.list(dto)查的
5：给 dto 设置了一个 belong,belong 的值是从 user 中拿的。。

我改他代码是因为他 dto 中的东西需要重新判断一下。
dto 里面有个开始时间和结束时间，前端有可能传过来的是汉字，我需要 try catch 一下，如果发生异常我把这个字段改为空字符串。确实是可以在他这句话之前加判断。
但是按照正常逻辑来讲应该是在他代码的第 5 步来判断吧。。

其实我还是坚持他这么写可读性不好。。但是确实是可以在他这句话之前加判断。（也不清楚是不是自己水平不行。。不过我总觉得再让我重新来一遍我还是得看到第五步。。）

[wsy190]

@wysnylc 小作坊公司。。。刚工作一年多。。技术确实是不到位。。大佬喜怒。。

[closedevice]

记住一句话,代码时写给人看的,顺便给机器执行.对于团队工程,通用的可阅读性是第一要义.

[wysnylc]

@wsy190 #16 非大佬,只是觉得你纠结的东西微不足道
写代码多写注释,代码千变万化注释一行足以
如果给你一个十万行代码的类,但是注释就一句 输入 1 返回 1 你觉得哪个更好?
代码只要不出错没并发就是好代码,写法因人而异
记住有一万个哈姆雷特,你只是其中一个罢了

[alphatoad]

没有可读性的代码就是屎山

[queuey]

没觉得第一个有啥问题啊，只要写好注释我认为第一个写的挺好的

[Heylion]

@wysnylc 他这里线程私有的，怎么有并发问题

[eGlhb2Jhb2Jhbw]

你给他的意见解决方法是“展开写”
他给你的意见解决方法是“条件语句或与当前方法主要逻辑无关的代码尽量抽离出另外一个方法”

你俩的问题不就都解决了吗？
不会因为展开写导致本方法的主要逻辑难读，也不会因为有人需要知道更详细的逻辑而难读。

[no1xsyzy]

@wysnylc 这个问题是：信息流的顺序和代码中的顺序不符，所以说了多少次，使用从左到右的书写的语言，函数调用不应该是 func(args) 而应该是 args|func，不然就必然导致分步执行容易理解，但对低级语言不友好还得栈上放东西。
但这涉及多参问题……柯里化的话这种情况反而变成 argn|(...|(arg2|(arg1|func))...) 就是倒序柯里化也不能解决括号问题如果具有主从参进行数据变换的话可能 lodash 那样的点链会更好，但 _.intersection 难受了我半天。
而且强迫症感到难受：到底求交集的时候哪个在前？
所以什么时候有图形化 dataflow graph 编程？

[inhzus]

我大概遵循的规则是：一行代码中，嵌套调用尽量不超过两层，链式调用尽量分行写。
炫技不炫技不重要，把代码写的即便没有注释也能轻松看懂就行了。

[guokeke]

什么是"可读性"？可读性有啥什么标准吗？自己看不顺眼的代码就是可读性差吗？

[wysnylc]

@Heylion #21 SimpleDateFormat 存在并发问题不建议使用甚至禁用,没有说他的代码会有问题
如果一个方法存在问题,那么在有代替品的情况下应当使用代替品
时间的格式化 java8 有 LocalDateTime java8 之前可以用 apache-dateUtils dateFormatUtils
所以 SimpleDateFormat 这种存在问题的类有必要使用?

[wsy190]

@guokeke
就是这个问题。。。
我认为写一行可读性差，他认为写很多可读性差
我也在想到底哪种方式写好呢，

[ccpp132]

第一个 case 写一行比较好。不拆开就觉得读起来困难的话可以多锻炼一下阅读代码的能力

[wsy190]

@ccpp132 也不是说读起来困难吧，只不过是觉得不能一目了然。在改的时候还要从头读。
不过这应该还是和读代码能力有关系的。

[wysnylc]

@no1xsyzy #23 比较长的链式嵌套确实存在阅读的困难,但是他这个链式写得一点都不多也不长还远远称不上"阅读困难"或者"语意不清"
比如使用 Stream.of(1,2,3).map().filter().flatMap()..... 这种大段的链式调用也有解决方案 在每一个调用后换行写注释即可
函数式编程核心就是纯粹的链式调用,其次是 builder,然而二者都是存在链式调用 所以链式调用没有任何问题
你把链式调用去了换成其他代码一样存在阅读困难,本质上不是代码怎么写,而是写代码的人的问题

[loginbygoogle]

就像一坨屎

[PriestTomb]

团队里的一个年龄较小的同事也是这种写法，链式一路到底。。
可能是我还没习惯，看他的代码真的很吃力，决心了好几次，都没看完他的代码。。

[leafre]

你看不惯，关人家什么事？你有资格评价别人的代码？

[zifangsky]

@wysnylc #14 当做局部变量可以用，没有线程安全问题。

[hundan]

功能复杂的时候 最多拆成一屏能读完的 三十行左右

[KyonLi]

拆开就会需要起很多变量名，这可是最烧脑的事情

[dsg001]

如果需要从两个人中裁掉一个，老板会认为裁掉谁比较好？

之前在类似问题下看到的回复

[specita]

我觉得两种写法都 OK 啊，可读性好不好，1、排版（链式分行） 2、链式的方法名称起得好不好
链式写得好的处理逻辑一目了然，但是还是不要链得太长了.. builder 这种除钱

[MMMMMMMMMMMMMMMM]

没问题啊，有注释就行了

没注释你让他自己改去

[Jex]

菜鸡互啄

[wsy190]

@leafre 又没说看不懂，团队协作提提意见怎么了？而且我也是抱着讨论的心思和他谈的
再说了，我和别人讨论，关你什么事？你有资格评论我的帖子？

[STRRL]

我在工作中喜欢用 chain 这种方式 稍微有些复杂的 try-catch 都会再写一个 private 方法装一下
然后无论拆不拆开 可加 fianal 的变量记得加 final...

[vmskipper]

越复杂的东西，越要写的简单，越少的依赖

[SuperMild]

如果没有裁判，是很难分清是非对错的。比如这种，必须有一个组长之类的人，和大家讨论后制定一份代码风格手册，类似于 Google、阿里做的那些 Java 风格手册，这样有规矩才能分对错。

不然的话谁都不服谁，两个地位相同的人讨论这种问题效率是很低的，你说的再有道理，但是他不服气呀，如果没有裁判，“道理”的力量很微弱。

[chanchan]

除了 if else 省略花括号,变量声明在一行.别的我觉得没问题

[Sapp]

链式调用要这么写

```

xx
.xxx() // 注释
.xxx() // 注释
.xxx(
oo.xx()
)
.xxx(
oo
.xx()
.xxx()
)

```

[sonxzjw]

你同事这样是一种变成风格，链式编程，有些语言哲学里很提倡例如 scala，确实阅读性不错。
我一度也很喜欢这种做法，但后来发现 java 中（其他的未生产上丰富的现实经验，但差不多吧）这样写很难快速的定位问题。每一个链相当于都会有异常，这样几乎无法精确捕获并处理。

所以后来我还是拆分开来写了，坑别人事小，坑自己事大，到最后有问题还是得分开来搞。

[jiezhi]

用 builder 会清爽很多吧

[passerbytiny]

我本来想看看楼主说得是啥，然而我根本看不下去主题描述。

只说一点，在不使用缩写、转义等替代描述的情况下，代码越少，可读性越高但可调整型（断点调试、后续追加代码）越低。“?:”三目描述符就是一个典型，可读性很高，但是当要调试，或者追加更多逻辑的时候，就不如“ if else ”方便。

[Sornets]

当我觉得这个代码以后不会我来维护并且我心情比较差的时候，会写成你同事这种。

其他情况，会写成你这种

[zzczzc]

我自己的话会喜欢用语法糖吧，工作还是尽量多考虑可读性好点

[karnaugh]

最近我也遇到类似的事情，我的思考结论是：
两个角度，因为是自己写的代码，每个东西是用来干啥的都知道，所以缩写成一条感觉看着很干净。。。
但是！！
到别人看的时候简直就是死了🐴了，难懂的雅痞，过个半年一年的，他再回来看着一条代码，估计他也得看半天

这种“我觉得”的负优化经常会有，只是因为自己的角度限制了思维，你可以自己写几个这样的代码让他看，他大概就知道自己写的这个代码有多屎了

[izoabr]

用过 Python 的觉得这些都是乱码，太乱太复杂了

[c0011]

我看你的你同事的代码头疼。

[pjzhong]

现在除了技术隔阂，还有风格隔阂了?

[tudouxiong]

@leafre 感谢 block

[jason19659]

设置为当日零点 dto.setStartTime(dto.getStartTime()+" 00:00:00"); 这么写真的没问题吗。。。万一时区不一样。。

[blackmirror]

这代码粘得看得我头痛

[WuMingyu]

链式的分行写 可以不

[Tink]

能写到一行并且出现问题能够很轻易判断问题在哪的程序员很厉害

[insaneguy]

强推代码规范检查可解：确定规范，强制执行。

[pain400]

@wysnylc 因为线程不安全，所以非多线程环境也不用吗。。。

[vkhsyj]

链式调用太长必须分行，不然可读性太低了

[susecjh]

又不是搞 acm，搞那么精简干啥

[good1uck]

小作坊..风格多

[kkeiko]

链式调用写法没问题，大部分情况下就是代码越少越好。说可读性差的只是个人问题。

[OHyn]

写的时候考虑一下过几个月自己是否看得懂就好了。。

[Beeethoven]

我写这种 SETGET 链经常出 NPE.. 后来再也不这么写了

[gkiwi]

写代码的时候都会走这个阶段，避免不了：

刚开始：拼拼凑凑能跑就行
然后：以代码量少为大佬的一个标准，并且努力执行（嗯，我也有段时间痴迷各种一行代码实现，没错，说的就是 python ）
之后：逻辑易读的代码，适量备注
之后：易于单测的易读代码（目前我大概是这个阶段）

再之后的还需要体会~~

[luopengfei14]

@wsy190 突然感觉我好老。。。

[zhuweiyou]

个人的原则是 能写一行 坚决不写两行

[JiafuYuan]

这样写会有无数 bug 吧，各种异常都没考虑

[yiyi11]

看情况的，很多东西没有绝对的对错，核心是以人(可读性)为本，多沟通，达成共识。比如 new().set()的用法，团队可以做一个规范，1.强制要求先 new，后 set。2.或者统一使用带参构造函数。3.或者不超过 1 个属性的时候可以使用连写的写法(因为较少属性的时候依然可以保持较高的可读性，不必排斥简短的写法)，否则使用 1 或 2 的写法。

[lighter]

可读和简洁之间，更喜欢可读性。

[Aumujun]

看 github 上的开源项目，代码基本都很精简。。 我个人认为精简是一种好习惯

[xuyaomin]

这个应该不能算是炫技

[DingSoung]

自己技术不行看不懂别人的代码，说别人代码可读性差。😂

[yiyi11]

@karnaugh 对，很多情况下都是“专家盲点”，一个人掌握了某些事物以后，就忘记了当初自己一窍不通的感觉。

[Jrue0011]

看情况，方法返回值没有重用的话就写一起，有重用的话就声明一个变量接收，太长的话也可以适当写成多行，但方法链一般会把每个 . 都换行

[pb941129]

一般 Python 我的原则是 性能和可读性至上
如果这个链式语句大量用到了某一个同一个中间函数或者需要反复计算一个中间数值
那就把这个中间函数提取出来单独计算成变量再进行链式语句的书写
如果没有 那我觉得持续用.来嵌套方法是没有什么问题的 尤其是一些很基本的方法 你知道这个方法的输入和输出大概是什么 如果这都要担心会不会翻车 或者没有把握 那 emmm
能少用变量名称就少用变量名称 我宁愿看一个长链式的语句也不愿意去猜你的那些个没有意义 用过了就扔了 中间变量乱七八糟的命名代表什么意思 我甚至还要费劲心思去考虑这段代码的关键变量和不重要的变量是什么 在这一点上 长链式读起来就很舒服 一下子就能知道你是怎么实现以及背后的算法逻辑是什么
的确拆开来写很稳 但是太稳了就是代码给人一种 nerd 的感觉...

[v2qwsdcv]

笑死我了，您怕是别用 java8 的 steam 了。

[ThomasZ]

又不是再搞那个最短代码比赛，这样写没有可读性，没有可调试性，单纯炫技不好

[519718366]

他这一行，到时候 npe 了，天知道是哪个对象 null 了....亲生感受
他要是牛逼，敢保证不会 npe，那你能怎么办，忍着呗，出了 bug，不要给你查就行

[yiyi11]

个人倾向链式分行，我是分行狂魔，看到链式调用哪怕只有 2 个很短的函数连着都要每个点起一行，而且点必须对齐。

[yiyi11]

sql 同理，只有 2 个字段的语句也必须一行一个字段。

[STRRL]

大家说到 NPE 的问题，建议使用 JSR 305 中提到的 @NonNul l 和 @CheckForNull 解决

[iblessyou]

看了一遍还没人从这个角度提过：

某些公司有代码统计的，这时注释和换行都能给你加代码量，你的写法可以加分。。。

[zkqiang]

虽然为了精简，嵌套太多，确实不容易看懂
但是一味的追求所谓“可读性”，反而导致代码冗长，一排重复的变量名，那不又是另一个极端？

[xpfd]

一年后让他再看这段代码 他会骂 这哪个傻逼写的 就不能写的简单点吗？ 非要转那么多弯

[Rwing]

```
public OutVoGlobal list(BatteryOrderDTO dto, UserInfo user) {

var outVoGlobal=new OutVoGlobal(EnumRetCode.SUCCESS);
var sdf = new SimpleDateFormat("yyyy-MM-dd");
if(!StringUtils.isEmpty(dto.StartTime)){
try {
sdf.parse(dto.StartTime);
dto.StartTime = dto.StartTime+" 00:00:00";
} catch (ParseException e) {
dto.StartTime = "";
}
}
if(!StringUtils.isEmpty(dto.EndTime)){
try {
sdf.parse(dto.EndTime);
dto.EndTime = dto.EndTime+" 23:59:59";
} catch (ParseException e) {
dto.EndTime = "";
}
}
dto.Belong = user.UserNo;
PageHelper.startPage(dto.PageNo, dto.PageSize);
List<BatteryOrder> list = orderMapper.list(dto);
outVoGlobal.Data = list;
return outVoGlobal;

}
```

有没有舒服点？

[blindie]

链式调用这么长不点号对齐写锤子啊，分分钟某个节点看漏

[Aixtuz]

凡事有度，过犹不及。

[Takamine]

只要是过了 code review 的，说明是符合团队风格的代码，不要慌。:doge:

[broadliyn]

@wysnylc
这里的 SimpleDateFormat 并没有竞态问题，为什么不能用？？
阿里规范是让你不要在线程不安全的情况下使用 SDF，而不是让你在并发环境下不要用 SDF。
你也是半桶水。

[BigDogWang]

你们都在这扯个啥，这不是链式不链式的问题，这是链式套链式啊，看的人恶心

[whp1473]

一、不赞同
1.String openid = (String) tokenMap.get("openid"),userMapKey;❌
2.省略{} if、else 不分行❌
二、争议
return new OutVoGlobal(EnumRetCode.SUCCESS).setData(orderMapper.list(dto.setBelong(user.getUserNo()))); ❌
这种类似风格，写的好很推崇，但写的差很容易写出屎一样的代码。我见过有 100 多行的链式，你读到后面就忘了前面，后来那个写的人也不知道了，哈哈。我觉得原则上支持链式，但是你要拆分的力度适中，5 个左右不超过 10 并且语义明了。
Java 中流式写法更适合数据处理。常用的实例：
widgets.stream()
.filter(b -> b.getColor() == RED)
.sorted((x,y) -> x.getWeight() - y.getWeight())
.mapToInt(Widget::getWeight)
.summaryStatistics();
或者
numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
你可以看到数据从第一行，到最后一行语义就是逻辑，是由顺序的。
三、分析
return new OutVoGlobal(EnumRetCode.SUCCESS).setData(orderMapper.list(dto.setBelong(user.getUserNo())));
写的问题在哪里，我们分析一下：
执行顺序：创建 OutVoGlobal 返回值——>setData 设置数据——>orderMapper.list 执行——>dto.setBelong 封装 userNo，同时要获取 userNo
在我们眼里的顺序是怎样的，获取 userNo ——>封装——>执行 list ——>封装返回 OutVoGlobal。可以看出它实际上需要逆着思维的顺序，user.getUserNo()这部分如果嵌套过多甚至你需要不断找。所以这种风格有点像用但是没用好的感觉。
四、改造
OrderParamBuilder.Builder().setUserNo(user.getUserNo()).build().list(orderMapper).ifNull(EnumRetCode.ERROR).else(EnumRetCode.SUCCESS);
或者
orderMapper.list(OrderParamBuilder.Builder().setUserNo(user.getUserNo()).build()).****

[rainymorn]

不喜欢分行,能写到一行的绝不写到多行
多行不利于阅读

[freebird1994]

链式不链式是一回事。入参不做校验么？一堆异常不给你抛？还是在 controller 层做了校验呢？
其实现在的 java 代码风格越来越偏向链式编程了。我也喜欢用

[wsy190]

@freebird1994 确实是，controller 层做了 try catch..

[wsy190]

@whp1473 非常感谢，受益匪浅。