衣服自己洗

在最近的 Sping boot 项目里，想要一次性返回多个对象，按照过去 .Net的经验，很容易想到的就是使用元组 Tuple，但是第一下居然没有找到，不过有 HashMap，看起来似乎也是不错的选择，但是存在需要强制转换的情况，某些场景下可能会出错。

不是很死心，于是就搜索了一下，找到了 vavr 这个库，比较简单，大家可以凑活使用。

首先是在 pom.xml 里添加依赖：

<!-- https://mvnrepository.com/artifact/io.vavr/vavr -->
<dependency>
    <groupId>io.vavr</groupId>
    <artifactId>vavr</artifactId>
    <version>0.10.6</version>
</dependency>

使用 Tuple.of 来创建对象代码示例：

Tuple2<String, LocalDateTime> element = Tuple.of("Name", LocalDateTime.now());

创建两个元素的是 Tuple2，三个元素就是 Tuple3，这个命名方式有点特别，哈哈。

更新元组里的内容：element.update1(“名称”); 也就是 update[1-n]的方式。

读取元组元素的内容，element._1() 是获取第一个值，element._2()就是获取第二个值，以此类推。

这个库是 Apache 协议，可以商用，不错。

我又继续搜索了下，元组只是其支持的一个功能，函数式编程也支持，andThen、compose 看起来好高级哇。

异常处理的写法也不错，我简单地复制下代码：

Try result = Try.of(() -> 0)
                .map((a) -> 10 / a) //即使此处抛出异常，不会导致当前线程结束。这里无需使用 try{}catch()对代码进行捕获
                .andThen(() -> System.out.printf("--抛出异常此处不会执行--")) //执行一个动作，不修改结果
                .map(i -> {
                    System.out.println("当前值：" + i);
                    return i + 10;
                })
                .onFailure(e -> e.printStackTrace())//失败时会触发onFailure
                .recover(ArithmeticException.class, 1000) //如果遇到 Exception类型的异常,则返回1000
                .map((a) -> a + 1);

        System.out.println("是否抛出异常：" + result.isFailure());
        System.out.println("执行结果:" + result.getOrElse(100)); //如果有异常发生，则返回100

延迟计算，这个也高级，但是潜意识感觉，如果用的不好，很容易给自己挖坑。

Lazy<Double> lazy = Lazy.of(Math::random)
                .map(i -> {
                    System.out.println("-----正在进行计算，此处只会执行一次------");
                    return i * 100;
                });
        System.out.println(lazy.isEvaluated());
        System.out.println(lazy.get()); //触发计算
        System.out.println(lazy.isEvaluated());
        System.out.println(lazy.get());//不会重新计算，返回上次结果

还有另外一种线程操作的写法：

System.out.println("当前线程名称：" + Thread.currentThread().getName());
        Integer result = Future.of(() -> {
            System.out.println("future线程名称：" + Thread.currentThread().getName());
            Thread.sleep(2000);
            return 100;
        })
                .map(i -> i * 10)
                .await(3000, TimeUnit.MILLISECONDS) //等待线程执行3000毫秒
                .onFailure(e -> e.printStackTrace())
                .getValue() //返回Optional<Try<Integer>>类型结果
                .getOrElse(Try.of(() -> 100)) //如果Option 为 empty时，则返回Try(100)
                .get();
        System.out.println(result); // 1000

大家放心用吧，一用一个不吱声。