开发小技巧系列 - 如何避免NPE，去掉if...else（四）

开发小技巧系列文章，是本人对过往平台系统的设计开发及踩坑的记录与总结，给初入平台系统开发的开发人员提供参考与帮助

在前面的三个章节中，对如何避免NPE，及程序中如果简化null != obj场景进行了讲解，及给出了解决方案，但回头去看写的Utils工具类，总感觉还缺少点什么，看着if ... else .... 总感觉不爽，那还有什么解决办法吗？

带着if ... else ... 的代码：

/**
     * 转换null值的模板方法
     * @param value
     *  输入的值
     * @param defaultValue
     *  默认值
     * @param <R>
     *     输入的对象的类型
     * @return
     */
    public static <R> R wrapNull(R value, R defaultValue){
   
        Optional optional = Optional.ofNullable(value);
        if(optional.isPresent()){
   
            return value;
        }
        return defaultValue;
    }
    /**
     * 转换输入的整数为null的情况
     * @param input
     *      输入数值
     * @param defaultValue
     *      指定默认值
     * @return
     *      如果是null，则返回 defaultValue
     */
    public static Integer nullInt(Integer input, Integer defaultValue){
   
        Optional optional = Optional.ofNullable(input);
        if(optional.isPresent()){
   
            return input;
        }
        return defaultValue;
    }

带着这个疑问，打开了Optional的源代码。

package java.util;
....
public final class Optional<T> {
   
  ...
  public static<T> Optional<T> empty() {
   
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
      /**
       * 返回一个值不为Null的 {@code Optional} 对象
.      *
       * @param <T> 对象的class
     * @param   非空的对象（值）
     * @return an {@code Optional} with the value present
     * @throws 如果值为NULL， 会抛出NullPointerException
     */
    public static <T> Optional<T> of(T value) {
   
        return new Optional<>(value);
    }    /**
     * 返回一个输入对象（值）的 {@code Optional} 对象（值）,
      * 如果值为空，则返回一个 empty {@code Optional}.
     *
     * @param <T> 对象（值）的class
     * @param 输入的值（对象）
     * @return 非空则返一个Optional的对象（值），传入的值为null，则返回一个EMPTY对象
     */
    public static <T> Optional<T> ofNullable(T value) {
   
        return value == null ? empty() : of(value);
    }
    //在往下看，还可以发现他还支持map, flatmap, orElse等方法
    public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
   
        Objects.requireNonNull(mapper);
        if (!isPresent()) 
           return empty();
        else {
   
            return Optional.ofNullable(mapper.apply(value));
        }
    }
        //值转化函数
    public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
   
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
   
            return Objects.requireNonNull(mapper.apply(value));
        }
    }    /**
     * 返回当前Optional中的值（对角）
     * 如果不存在，则返回 {@code other}.
     *
     * @param other 当前Optional的值不存在时，需要返回的值（一般用于默认赋值的场景）
     * @return 略
     */
      public T orElse(T other) {
   
        return value != null ? value : other;
      }

    ...省略
}

看到这里，在回头看原来写的if ... else ...， 原来还可以这样，在看修改的代码前，先来看下Optional的这几个api的说明与用途。

从Optional的源码上看，Optional是一个final类，不可能在被继承，而且它的构造函数是private（不可见的），不能直接通过new XXX(...)这样来创建一个新的对象。但它提供了3个public的静态构造方法，用来构造一个带真实值的Optional对象，和一个代表空值的对象EMPTY。即，of(T value)、ofNullable(T value)、 empty()，在这向个函数的内部都是调用内部的构造方法。

of(T value) ： 传入的 value 值或对角不能为Null，如果为Null，则会抛出NullPointerException的异常。
ofNullable(T value) : 可以传入任意的值或对象，包括Null，都不会抛出NullPointerException的异常。
empty() ：构造一个 value = null的空对象。

在往下看，可以看到它还有其他的api方法，如fliter(...)、map(...)、flatMap(...)、orElse(...)、orElseGet(...)、orElseThrow(...)等，从这些方法的定义上看，都是支持JDK1.8中的lamda表达式的语法。

数据转换：map(...), flatMap(...)
分支：orElse(...)、orElseGet(...)、orElseThrow(...)
过滤：filter(...），返回满足条件的数值，如果不满足，会返回empty

好了，通过对api的学习，原来还可以这样简单（见ValueUtils.java, ValueUtilsV2.java)，像

/**
     * 转换null值的模板方法
     * @param value
     *  输入的值
     * @param defaultValue
     *  默认值
     * @param <R>
     *     输入的对象的类型
     * @return
     */
    public static <R> R wrapNull(R value, R defaultValue){
   
        Optional optional = Optional.ofNullable(value);
        if(optional.isPresent()){
   
            return value;
        }
        return defaultValue;
    }

可以修改为

/**
     * 转换null值的模板方法
     * @param value
     *  输入的值
     * @param defaultValue
     *  默认值
     * @param <R>
     *     输入的对象的类型
     * @return
     */
    public static <R> R wrapNull(R value, R defaultValue){
   
        return Optional.ofNullable(value).orElse(defaultValue);
    }

像这样的

/**
     * 转换BigDecimal（浮点数）数值可能为null的情况
     * @param value
     *      输入数值
     * @param scale
     *      指定小数位
     * @param defaultValue
     *      指定默认值
     * @return
     *      默认四舍五入
     *      如果为null，则返回 defaultValue
     */
    public static BigDecimal wrapNull(BigDecimal value, int scale, BigDecimal defaultValue){
   
        Optional optional = Optional.ofNullable(value);
        if(optional.isPresent()){
   
            return value.setScale(scale, BigDecimal.ROUND_HALF_UP);
        }
        return defaultValue;
    }

可以改成

/**
     * 转换BigDecimal（浮点数）数值可能为null的情况
     * @param value
     *      输入数值
     * @param scale
     *      指定小数位
     * @param defaultValue
     *      指定默认值
     * @return
     *      默认四舍五入
     *      如果为null，则返回 defaultValue
     */
    public static BigDecimal wrapNull(BigDecimal value, int scale, BigDecimal defaultValue){
   
        return Optional.ofNullable(value).map(e->e.setScale(scale, BigDecimal.ROUND_HALF_UP))                .orElse(defaultValue);
    }

OptionalUtils.java中的修改:

/**
     * 属性互转模板方法
     * @param source
     *  原对象（需要比较的对象）
     * @param function
     *  对象E->R的赋值过程
     * @param defaultObject
     *  默认值
     * @param <E>
     *      原始对象
     * @param <R>
     *      结果对象
     * @return
     */
    public static <E, R> R transfer(E source, Function<E, R> function, R defaultObject){
   
        //旧的逻辑处理逻辑
        //Optional<E> optional = Optional.ofNullable(source);
        //if(optional.isPresent()){
   
        //return function.apply(optional.get());
        //}
        //return defaultObject;
        //利用orElse后的处理逻辑
        return Optional.ofNullable(source).map(e->function.apply(e)).orElse(defaultObject);
    }

代码调整完了，看看单元测试的结果

/**
     * 测试正常情况下的调用（非null）
     */
    @Test
    public void optionalTest(){
   
        // 声明一个会员
        Member member = new Member();
        member.setId(1);
        member.setMemberId(1000);
        member.setNickName("测试");
        member.setGender(1);        MemberDTO memberDTO = memberService.transferByOptional(member, null);
        log.debug("{}", memberDTO);
        //声明一个部门
        Dept dept = new Dept();
        dept.setId(1);
        dept.setDeptId(100);
        dept.setParentId(0);
        dept.setDeptName("部门");
        DeptDTO deptDTO = OptionalUtils.transfer(dept, MemberService::cover, null);
        log.debug("deptDTO : {}", deptDTO);
    }
17:03:16.645 [main] DEBUG net.jhelp.demo.OptionalTest - MemberDTO(memberId=1000, nickName=测试, realName=null, gender=1, genderName=男)
17:03:16.674 [main] DEBUG net.jhelp.demo.OptionalTest - deptDTO : DeptDTO(deptId=100, parentId=0, deptName=部门)
/**
     *  测试传入对象是null的情况
     */
    @Test
    public void optionalWithNullTest2(){
   
        MemberDTO2 memberDTO = memberService.transferByOptional2(null, MemberDTO2.EMPTY_MEMBER);
        log.debug("optionalWithNullTest2：{}", memberDTO);
        log.debug("是否是空对象：{}", memberDTO.isEmpty());
    }
17:04:42.572 [main] DEBUG net.jhelp.demo.OptionalTest - optionalWithNullTest2：MemberDTO2(memberId=null, nickName=null, realName=null, gender=null, genderName=null)
17:04:42.583 [main] DEBUG net.jhelp.demo.OptionalTest - 是否是空对象：true

具体的代码调整，可以下载测试的demo程序。

https://gitee.com/TianXiaoSe_admin/java-npe-demo.git

总结一下

由于Optional中加了lamda的新特性，代码是简化，但可能不易理解，还是要根据实际的需要来使用。

思考、偿试比结论重要，希望你能从中有所收获。

开发小技巧系列文章：

1､开发小技巧系列 - 库存超卖，库存扣成负数？
2､开发小技巧系列 - 重复生成订单
3､开发小技巧系统 - Java实现树形结构的方式有那些？
4､开发小技巧系列 - 如何避免NullPointerException？（一）
5､开发小技巧系列 - 如何避免NullPointerException？（二）
6.开发小技巧系列 - 如何避免NPE，巧用Optional重构三元表达式？（三）