【进阶篇】Java 实际开发中积累的几个小技巧（一）

目录

前言

笔者目前从事一线 Java 开发今年是第 3 个年头了，从 0-1的 SaaS、PaaS 的项目做过，多租户下定制化开发项目也做过，项目的 PM 也做过...

在实际的开发中积累了一些技巧和经验，包括线上 bug 处理、日常业务开发、团队开发规范等等。现在在这里分享出来，作为成长的记录和知识的更新，希望与大家共勉。

免责声明：以下所有demo、代码和测试都是出自笔者本人的构思和实践，不涉及企业隐私和商业机密，属于个人的知识分享。

一、枚举类的注解

看起来很常见的枚举，可能也隐藏着使用上的问题：你有没有在代码里不小心做过改变枚举值的操作？或者为怎么合理规范地写构造方法/成员方法而烦恼？

那么不妨来看看我的示例，注释写得比较清楚了：

@Getter// 只允许对属性 get，不允许 set
@RequiredArgsConstructor// 为枚举的每个属性生成有参构造
public enum ProjectStatusEnum {
    SURVEY("已调研"),
    APPROVAL("已立项"),
    PROGRESSING("进行中"),
    COMPLETED("已完成");
    // 对该成员变量使用 final 来修饰，表明一旦赋值就不可变
    private final String name;
}

为什么要分享这个呢？团队里开发的时候还真有人在使用枚举的时候 set() 改变了枚举值，编译通过但运行在一定条件触发后，导致了 bug 排查了一下午。

二、RESTful 接口

本节的内容其实更像是一种规范，因为见过不少别的部门同事写的项目代码，接口的风格真是迥异（写什么的都有），当我接手重构的时候真是头皮发麻。

首先就是禁止使用 Swagger 和 Knife4j 接口文档生成工具，原因无它：代码侵入性太强和需要写的注解太多，而且还是公司安全漏洞扫描单上的常客。

其次可以使用开源的 smart-doc 来代替，只要遵循 Javadoc 的标准注释写法即可。

  • 请求方式和参数

    在 Controller 中一般只使用 GET 请求和 POST 请求，无需使用 PUT 和 DELETE。

    GET 请求一般只使用 @GetMapping，主要配合 @RequestParam、@PathVariable 使用，请求的拼接参数一般不超过 5 个。

    POST 请求一般只使用 @PostMapping，主要配合 @RequestBody 使用，请求参数统一使用 DTO 对象。

    如果入参需要带上请求头，可以加上 @RequestHeader 注解；如果是提交表单，可以加上 @Valid 做参数校验，如 @NotBlank 和 @NotNull 等。

  • 统一返回

    主要包括：返回体（返回码+信息+返回数据）+ 封装VO + 统一异常，这些基础的东西肯定是遵顼团队/公司的开发规范，不需要再自己造轮子。

一个简单的 Controller 示例如下：

/**
 * 测试接口
 */
@RestController
@RequestMapping("/study")
public class StudyController {

    @Resource
    private StudyService studyService;

    /**
     * 新增xx
     * @return 是否成功
     */
    @PostMapping("/add")
    //还可以加上其它必要注解，如：登录/权限/日志记录等
    public Response<Boolean> addStudy(@RequestBody @Valid StudyDTO studyDTO) {
        return ResultUtils.success(studyService.addStudy(studyDTO));
    }

    /**
     * xx列表（不分页）
     * @return 列表数据
     */
    @GetMapping("/list")
    public Response<List<StudyListVO>> getList(@RequestParam("id") String id) {
        return ResultUtils.success(studyService.getList(id));
    }
}

三、类属性转换

在实际 Java 开发中，关于 VO、Entity、DTO 等对象属性之间的赋值是我们经常遇见的，最简单使用 @Data 去逐个 .set() 或者 @Builder 链式 .build()，其实都是很靠谱的办法，而且可以控制颗粒度。但属性一多起来的话，比如二十个以上，那么代码就会显得很长。所以有没有办法一行代码就搞定类属性转换呢？

首先不推荐使用 BeanUtils.copyProperties() 作类属性的拷贝，以下是几个常见的坑：

  1. 同一字段分别使用包装类型和基本类型，会出现转换异常，不会灵活识别转换
  2. null 值覆盖导致数据异常，即源属性有值为 null，但是目标属性有正常值，拷贝后会被 null 覆盖
  3. 内部类属性无法正常拷贝，即使类型和字段名均相同也无法拷贝成功，这个真的很坑

推荐泛型 + JSON组合的方式来实现类属性的转换，具体步骤如下：

  • 定义一个父类 CommonBean，让项目里所有 VO、Entity、DTO 等类都继承该类，类里面就只定义一个公共的泛型方法即可：

    public class CommonBean implements Serializable {
    /**
     * @apiNote 全局类型转换方法：入参和返参均支持泛型
     * @param target
     * @return 目标类型
     * @param <T>
     */
    public <T> T copyProperties(Class<T> target) {
        //本质上就是进行了 Object -> json字符串 -> 到指定类型的转换
        return JSON.parseObject(JSON.toJSONString(this), target);
    }
}

  • 在需要转换的地方，直接调用上面定义的方法即可完成转换：

        @Test
    public void testCopyProperties(){
        //Worker 和 WorkerVO 都需要 extends 上述的 CommonBean
        Worker worker = new Worker();
        worker.setName("Alex");
        worker.setStatus(NumberUtils.INTEGER_ONE);
        //直接使用，得到需要的目标 VO 对象
        WorkerVO workerVO = worker.copyProperties(WorkerVO.class);
        log.info("转换结果：{}",workerVO);
    }

四、Stream 流

  • map() 流元素的映射、collect() 收集流，这两个就不展开讲了，几乎可以说是 Stream 流用的最多的方法，到处都是例子。

  • filter() 流按条件过滤和 sort() 流元素排序，这两个组合可以简单举个例子：

    /**
     * Stream 流的过滤与排序
     * @param id
     * @return 列表数据
     */
    @Override
    public List<StudyVO> getList(String id) {
       List<StudyVO> resultList = this.list(new LambdaQueryWrapper<Study>()
                .eq(Study::getIsDelete, NumberUtils.INTEGER_ZERO)).stream()
                .filter(e -> Constants.USER_ROLE_USER.equals(e.getUserRole()))
                .sorted(Comparator.comparing(Study::getAge).reversed())
                .map(e -> e.copyProperties(StudyVO.class)).collect(Collectors.toList());
        return Optional.of(resultList).orElse(null);
    }

像上述从MySQL 里查表数据的例子，其实能在数据库做的操作就没必要在 Stream 流里操作。像 .select()、.eq()、.gt()、.orderByDesc() 等都可以完成，非数据库语句查询的情况下，使用 Stream 操作集合还是有必要的。

  • anyMatch() 平时用的不多，但当遇到了之后，它的用法还是能让人眼前一亮的：
 /**
     * 测试 Stream 的 AnyMatch 方法
     * @return
     */
    public List<ArticleVO> testStreamAnyMatch(){
        List<Article> articleList = this.list(new LambdaQueryWrapper<Article>().eq(Article::getIsDelete, NumberUtils.INTEGER_ZERO));
        if (CollectionUtils.isNotEmpty(articleList)){
            //AnyMatch() 方法返回的是一个布尔，用来判断流中是否有满足条件的元素
            final boolean flag = articleList.parallelStream().anyMatch(e -> Objects.nonNull(e)
                    //文章要有内容
                    && Objects.nonNull(e.getContent())
                    //文章要有标题
                    && StringUtils.isNotBlank(e.getTitle()));
            if (flag){
                return articleList.parallelStream().map(e -> e.copyProperties(ArticleVO.class)).collect(Collectors.toList());
            }
        }
        return new ArrayList<>();
    }
  • skip() 跳过流的某些元素和 limit() 指定流元素的位置，组合起来使用可以实现自分页。这个在线上问题-如何避免集合内存溢出的文章中会拿出来单独讲一下。

五、判空和断言

5.1判空部分

首先什么情况下需要判空？基本是以下这 3 种情况：

  1. 当进行对象引用操作时

    为了避免 NPE 通常需要先判断该对象是否为 null。比如，在调用对象的方法或访问其属性之前，应该首先判断该对象不为 null 。

        @Test
    public void testNullMethod(){
        //以下对象为 null，即表示该对象的变量在内存中不引用任何对象地址
        Study study = null;
        //则下面调用该对象的 get() 方法试图获得其属性，则会导致 NPE
        String userName = study.getUserName();
        log.info("用户名称：{}", userName);
    }

  2. 从外部获取数据返回时

    比如：从数据库查询数据返回、调用另一个接口的方法返回的数据，有可能返回对象的结果为 null：

        @Override
    public StudyVO detail(String id) {
        //查 MySQL 返回的集合数据，即使 null 赋值也没有问题
        List<Study> resultList = this.list(new LambdaQueryWrapper<Study>()
                .eq(Study::getIsDelete, NumberUtils.INTEGER_ZERO)
                .orderByDesc(Study::getAge));
        //但是同样需要对集合对象进行判空，有值再进行下一步
        if (CollectionUtils.isNotEmpty(resultList))
        {
            return resultList.get(NumberUtils.INTEGER_ZERO).copyProperties(StudyVO.class);
        }
        return new StudyVO();
    }

  3. 当集合进行元素操作时

    由于集合本身并没有提供直接的判空机制，所以在进行元素操作之前，需要进行集合是否为空的判断：

        /**
     * 举个反例
     */
	@Override
    public StudyVO detail(String id) {
        //调用其它方法，并将返回结果赋值，是 null 也没问题
        List<StudyVO> voList = this.getList(id);
        //但在使用 get() 方法前不判断集合里有没有元素，那么会报数组越界
        return voList.get(NumberUtils.INTEGER_ZERO);
    }

那么，常用判空的工具有哪些呢？从我个人的开发经验来说主要有以下几种：

  • 对象的判空

    推荐统一使用 java.util 包的 Objects.nonNull() 等方法。

  • 集合的判空

    推荐统一使用 org.apache.commons.collections.CollectionUtils 包的 .isNotEmpty() 等方法。

  • Map 对象判空

    推荐统一使用 Map 自带的 .isEmpty() 、 .containsKey()、.equals() 这三者配合使用。

  • 字符串的判空

    推荐统一使用 org.apache.commons.lang3.StringUtils 包的 .isNotBlank() 等方法。

  • Optional类

     Optional
     //of(T value)方法用于创建一个包含指定值的 Optional 对象，该方法接收一个非 null 值作为参数
   .of()
     //ofNullable(T value)方法用于创建一个包含指定值的 Optional 对象，该方法接收一个可能为 null 的值作为参数
     .ofNullable()
     //isPresent()方法用于判断 Optional 对象中是否存在非 null 值，有值就返回 true ，否则返回 false
     .isPreset()
     //orElse(T other)方法顾名思义，泛型 T 表示其它的类型
     .orElse()
     //ifPresent(Consumer<? super T> consumer) 判断该对象是否值，有则调用传入的 Consumer 类型函数处理该值。否则，什么也不做
     .ifPresent()  
     //map(Function<? super T, ? extends U> mapper) 用于对 Optional 对象中的值进行映射，并返回一个新的 Optional 对象
     .map()
     //filter(Predicate<? super T> predicate) 用于过滤 Optional 对象中的值，只有当值满足特定条件时才保留
     .filter()

什么情况下可以不需要判空？

答：一般当方法允许直接返回 null 时，可以不对返回值进行判空。

5.2断言部分

断言的应用场景可能就比较单一了，我自己的理解是：在业务因为无数据且需要强制中断业务时，可以使用到断言。那么接口允许返回空、或者返回约定的状态码等这些情况除外。

一定程度上可以简化“先判断，再抛异常”的代码。即替换以下代码，三行变一行：

    if (Objects.nonNull(Object obj)){
        throw new BusinessException("obj error");
    }

//对象型断言：如果该对象为 null ，则抛出 String 类型的异常信息
Assert.notNull(@Nullable Object object, String message);

常用的断言如下：

//布尔型断言：如果布尔表达式为 false，则抛出 String 类型的异常信息
Assert.isTrue(boolean expression, String message);
    
//对象型断言：如果该对象为 null ，则抛出 String 类型的异常信息
Assert.notNull(@Nullable Object object, String message);

//字符串型断言：如果该字符串无内容，则抛出 String 类型的异常信息
Assert.hasText(@Nullable String text, String message)
    
//集合型断言：如果集合（包括 Map）对象无内容，则抛出 String 类型的异常信息
Assert.notEmpty(@Nullable Map<?, ?> map, String message);
Assert.notEmpty(@Nullable Collection<?> collection, String message);

文章小结

作为一个系列文章的开头，本文的内容偏基础。在之后的文章中我会分享一些关于真实项目中关于线上 bug 处理、缓存的使用、异步/解耦等内容，敬请期待。

那么 Java 实际开发中值得注意的几个小技巧的分享到这里就暂时结束了，如有不足和错误，还请大家指正。或者你有其它想说的，也欢迎大家在评论区交流！

posted @ 2024-02-04 15:19  CodeBlogMan  阅读(2692)  评论(18)  编辑  收藏  举报