代码优化记录

目录

20211117 更新

20211215 更新

20211227 更新

20220314 更新

20220330 更新

20220629 更新

20220714 更新

20220809 更新

---

优化目录

• 条件判断表达式比较长的情况下，可以封装成一个方法isXXX()，返回boolean，例如：

private boolean isGZFinance(Integer channelId) {
    return channelId == null || channelId <= 0 || channelId == AccidentChannel.CHANNEL_ID_101.getIndex().intValue();
}

• 一个方法只做一件事，可以将依赖数据传参传入，方法内通常不建议对入参做修改，如果需要修改入参，需要在方法名上加以体现AndSetXXX，例如：方法名称叫做计算总保费，那么理应只做计算操作，不应该有相应的查询（单一职责原则），那么出参应该是一个数值，而不应该返回其他信息
• 一个项目里，可以将关于日期时间操作的抽出来作为公共部分，例如日期格式化等等
• 定时任务一般要记录任务中成功多少，失败多少，用时间多少

int total = channelIdList.size();
int success = 0;
int fail = 0;
Stopwatch stopwatch = Stopwatch.createStarted();
//业务代码
stopwatch.stop();
log.info("XXXJob: XXX统计, total:{}, success:{}, fail:{}, time:{}", total, success, fail, stopwatch);

• 使用事务的时候注意事务是否能生效：事务不生效
• 代码分层：controller前端接口    --->    dubbo接口 -> service -> DAO数据操作
• 延时队列：调用第三方接口要考虑超时的可能，选择异步的方法，延时队列超时也会启动重试机制
• controller层返回给前端的实体类不要复用dubbo层的，目的：少依赖性，dubbo提供原始数据，controller转成需要的数据
• list 转 map

  Map<String,String> map = userList.stream().collect(Collectors.toMap(User::getId, User::getName));
  

• String 转 List<Integer>

  List<Integer> categoryIds = Arrays.stream(categoryPath.split(CATEGORY_SEPARATOR)).map(Integer::parseInt).collect(Collectors.toList());
  

• list取交集并集差集

  //交集
  listA.retainAll(listB);
  System.out.println(listA);
  
  //并集
  listA.addAll(listB);
  System.out.println(listA);
  
  //差集
  listA.removeAll(listB);
  System.out.println(listA);
  

20211117 更新

• 在定义常量前，先找找有没有全局的枚举或者常量；在命名项目专业名词前，先询问是否有命名字典
• 实体类属性命名不要紧贴业务，例如：可还货数量是xxx渠道的数量，反例：xxxSaleStock，需要考虑到如果后期渠道有变更怎么变，扩展性不好，正例：returnStock
• 函数的命名要体现做什么，而不是怎么做，函数命名应该提升抽象层次、体现业务语义。
• 局部变量 / 常量 定义使用基本类型，看齐源码，关于Java中基本类型与包装类型的使用可见：基本类型与包装类型的抉择？
• 三目运算符的替换

1 考虑是否能替换为 Math.min()  等价于 num1 >= num2 ?  num2 : num1

2 考虑是否能替换为 StringUtils.defaultIfBlank()  等价于 StringUtils.isBlank(str) ? "" : str

3 map中考虑是否能替换为 map.getOrDefault()

4 map中使用考虑是否能替换为 map.compute() 方法

例如：
     int num = 123;
     Integer value = myMap.get(key);
     myMap.put(key, Objects.isNull(value1) ? num : num + value1);

可替换为：
myMap.compute(key, (k, v) -> {
    if (Objects.isNull(v)) {
        return num;
    } else {
        return num + v;
    }
});

• 如果出现一层套一层的计算，先考虑能不能全局。例如：规则1过滤完需要再过滤规则2，那么先考虑全部排序，是所有数据在一个列表里是符合优先级的，再处理，这样一个大循环即可
• 多个优先级排序条件，创建多个Comparator，使用thenComparing。先根据规则1排序，如果规则1相等，再根据规则2排序，以此类推

list.stream()
.sorted(byRule1.thenComparing(byRule2).thenComparing(byRule3))
.collect(Collectors.toList());

• 返回类型为集合类型时，结果为空时，尽量不要返回null，返回Collections.emptyList()
• git开发分支命令，功能需求开发，分支名以 feature/ 开头，例如feature/return_goods；修改功能bug，分支名以 feature/fix_ 开头；紧急修改线上问题，分支名以 hotfix/ 开头

20211215 更新

场景：需要将List<UserDetail>的id，name，sex字段封装到List<UserInfo>

stream实现

List<UserInfo> userInfos= userDetailList.stream().map(userDetail ->
                 new UserInfo(userDetail.getId(), useDetail.getName(), useDetail.getSex())).collect(Collectors.toList());

20211227 更新

• 如果一次执行仅仅处理一条数据，那么数据库就查询limit 1
• list去重使用Collectors.toSet：distinct().collect(Collectors.toList()) 替换为 collect(Collectors.toSet())

//distinct().collect(Collectors.toList())
List<Integer> list = list.stream().XXX.distinct().collect(Collectors.toList());

//collect(Collectors.toSet())
List<Integer> list = list.stream().XXX.collect(Collectors.toSet());

•  list统计个数，使用 list.stream().collect(Collectors.groupingBy(..., Collectors.counting()))

20220314 更新

• 每层的命名，要看面向使用的对象来命名。例如dao层service，那就是根据数据库表来命名。在业务和技术上选择命名。命名需要站在不同层上去考虑，例如，底层可以偏技术，向外提供的可以偏业务，最终目的是好理解
• 一个大方法，需要用枚举或参数来进行不同的处理，那么需要拆分为多个方法
• toMap(某个字段，Function.identity()） 替换为 groupingBy(某个字段）

list.stream().collect(Collectors.toMap(ChannelOrgLevelConfigDO::getParentId, Lists::newArrayList,
                        (List<ChannelOrgLevelConfigDO> newList, List<ChannelOrgLevelConfigDO> oldList) -> {
                            oldList.addAll(newList);
                            return oldList;
                        }));


//替换为
list.stream().collect(Collectors.groupingBy(ChannelOrgLevelConfigDO::getChannel));

• 数据库字段is_XXX 表示是否的意思，可用tinyint(2)类型，使用mybatis生成实体类类型默认为Boolean。 0为false，1为true
• 接口命名，一般不用batch。可以通过参数去表示是否批量
• dao层service，数据库修改方法，返回统一 boolean，或者统一抛异常
• 业务层获取现在的时间为now，但对于下一层dao层来说，该时间只是一个时间，所以参数命名为long timestamp
• 当一个接口的参数有标识true/false的。那么考虑去掉
• 如果在调用一个方法前，都需要调用另一个方法。那么需要考虑能不能合并为一个方法。例如：根据路径查询时，都需要去组装路径，那么组装的方法需要放到查询路径方法中。
• 处理XXX，命名一般使用handle/process
• 判断XXX，命名一般使用check
• Result/Param类 名称的前缀应该是动词
• map的entrySet 一般可以替换keySet，无需再去map.get()

for (String channel : channelAndTopmostConfigMap.keySet()) {
    resultMap.put(channel, channelAndTopmostConfigMap.get(channel).stream().map(ChannelOrgLevelConfigDO::getOrg).collect(Collectors.toSet()));
}

//修改
for (Map.Entry<String, List<ChannelOrgLevelConfigDO>> entry : channelAndTopmostConfigMap.entrySet()) {
    resultMap.put(entry.getKey(), entry.getValue().stream().map(ChannelOrgLevelConfigDO::getOrg).collect(Collectors.toSet()));
}

20220330 更新

• 日期格式化，优先选择：DateTimeFormatter

//java 原生
java.time.format.DateTimeFormatter#ofPattern(java.lang.String)

//SimpleDateFormat，非线程安全。 

•  validData(..) => validate(..)
• 待计算：WAIT_CALCULATE  => PENDING
• 计算完成：COMPLETION => COMPLETED/SUCCEEDED/SUCCESS
• 已通知：SENT => NOTIFIED
• 已废弃：DISABLED => ABORT/CANCELLED
• 关于事务粒度，如果方法中没有涉及到多的IO（纯内存操作耗时可以忽略），则可以在大方法上添加事务，而不需要再向下抽象一层
• 发邮件时，需要根据业务场景考虑第三方是否可以处理大量数据（一次性一个附件10万行数据）
• 对接第三方接口时，对于我的上层，无需关注第三方接口的错误，所以一般来说我需要处理异常信息，并转为业务异常向上抛出。
• 组装数据时，可以使用流多次循环源数据组装，为了可读性无伤大雅。

20220629 更新

java.util.stream.Stream使用

Java8 Stream使用整理_zhangm2020的博客-CSDN博客

20220714 更新

1、一次请求数据过大，需要分批次请求：将list分割为几部分

Lists.partition()

public static <T> List<List<T>> partition(List<T> list, int size) {...}

2、java.util.Optional使用

Java8 Optional使用整理_zhangm2020的博客-CSDN博客

20220809 更新

比较两个对象时，使用JDK提供的Objects#equals来比较，避免NPE

前提：重写比较对象的equals方法

案例：

java.util.Objects#equals

public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}

//比较时，避免比较对象本身而非内容，需要重新equals方法
public boolean equals(Object obj) {
    return (this == obj);
}

demo

public static void main(String[] args) {
    String str = new String("123");
    String str1 = "123";
    System.out.println(str1.equals(str));//true
    System.out.println(Objects.equals(str1, str));//true
    System.out.println(str1 == str);//false
}

而String类重写了equals方法

反例

@AllArgsConstructor
public class MyUser {

    private Integer id;
    private String name;
}

public static void main(String[] args) {
    MyUser myUser = new MyUser(1, "张三");
    MyUser myUser1 = new MyUser(1, "张三");
    System.out.println(Objects.equals(myUser, myUser1));//false
}

没有重写对象的equals方法，调用的是Object的equals方法，比较对象本身

 加上@Data注解后

调用的是MyUser重写的equals方法