Hystrix是Netflix开源的限流、熔断降级组件，去年发现Hystrix已经不再更新了，而在github主页上将我引导到了另一个替代项目——resilience4j，这个项目是基于Java 8开发的，并且只使用了vavr库，也就是我们今天要介绍的主角。
vavr：让你像写Scala一样写Java - 图1

Lambda表达式

既然要谈vavr，那么先要谈为什么要使用vavr，vavr是为了增强Java的函数式编程体验的，那么这里先介绍下Java中的函数式编程。

Java 8引入了函数式编程范式，思路是：将函数作为其他函数的参数传递，其实在Java 8之前，Java也支持类似的功能，但是需要使用接口实现多态，或者使用匿名类实现。不管是接口还是匿名类，都有很多模板代码，因此Java 8引入了Lambda表达式，正式支持函数式编程。

比方说，我们要实现一个比较器来比较两个对象的大小，在Java 8之前，只能使用下面的代码：

  1. Compartor<Apple> byWeight = new Comparator<Apple>() {
  2.   public int compare(Apple a1, Apple a2) {
  3.     return a1.getWeight().compareTo(a2.getWeight());
  4.   }
  5. }

上面的代码使用Lambda表达式可以写成下面这样（IDEA会提示你做代码的简化）：

  1. Comparator<Apple> byWeight = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

关于Lambda表达式，你需要掌握的知识点有：

  • Lambda表达式可以理解为是一种匿名函数：它没有名称，但是又参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表；
  • 函数式接口就是仅仅声明了一个抽象方法的接口；
  • @FunctionalInterface 注解对于函数式接口的作用，类似于@Override对于被重写的方法——不是必须的，但是用了有助于提升代码的可读性，因此如果你在开发中自己定义函数式接口，最好也使用这个注解修饰；
  • Java 8自带一些常用的函数式接口，放在java.util.function包里，包括Predicate、Function、Supplier、Consumer和BinaryOperator等等；

vavr

受限于 Java 标准库的通用性要求和二进制文件大小，Java 标准库对函数式编程的 API 支持相对比较有限。函数的声明只提供了 Function 和 BiFunction 两种，流上所支持的操作的数量也较少。基于这些原因，你也许需要vavr
来帮助你更好得使用Java 8进行函数式开发。

vavr是在尝试让Java拥有跟Scala类似的语法。vavr提供了不可变的集合框架；更好的函数式编程特性；元组。
vavr：让你像写Scala一样写Java - 图2

集合

Vavr实现了一套新的Java集合框架来匹配函数式编程范式，vavr提供的集合都是不可变的。在Java中使用Stream，需要显示得将集合转成steam的步骤，而在vavr中则免去了这样的步骤。

  1. vavr的List是不可变的链表，在该链表对象上的操作都会生成一个新的链表对象。
    使用Java 8的代码：
  1. Arrays.asList(1, 2, 3).stream().reduce((i, j) -> i + j);
  3. IntStream.of(1, 2, 3).sum();

使用vavr实现相同的功能，则更加直接：

  1. //io.vavr.collection.List
  2. List.of(1, 2, 3).sum();
  1. vavr的Stream是惰性链表，元素只有在必要的时候才会参与计算，因此大部分操作都可以在常量时间内完成。

函数（Functions）

Java 8提供了接受一个参数的函数式接口Function和接受两个参数的函数式接口BiFunction，vavr则提供了最多可以接受8个参数的函数式接口：Function0、Function1、Function2、Function3、Function4……Function8。
vavr：让你像写Scala一样写Java - 图3

vavr还提供了更多函数式编程的特性：

  • 组合（Composition）
    在数学上，函数组合可以用两个函数形成第三个函数，例如函数f:X->Y和函数g:Y->Z可以组合成h:g(f(x))，表示X->Z。这里看个组合的例子：
  1. public class VavrFunctionExample {
  3.     @Test
  4.     public void testCompose() {
  5.         //使用andThen
  6.         Function1<Integer, Integer> plusOne = a -> a + 1;
  7.         Function1<Integer, Integer> multiplyByTwo = a -> a * 2;
  8.         Function1<Integer, Integer> add1AndMultiplyBy2 = plusOne.andThen(multiplyByTwo);
  9.         Assert.assertEquals(6, add1AndMultiplyBy2.apply(2).intValue());
  11.         //使用compose
  12.         Function1<Integer, Integer> add1AndMultiplyBy2WithCompose = multiplyByTwo.compose(plusOne);
  13.         Assert.assertEquals(6, add1AndMultiplyBy2WithCompose.apply(2).intValue());
  14.     }
  15. }
  • Lifting
    你是不是常常写这种代码：调用一个函数，判断它的返回值是否符合需求，或者需要catch所有异常以防异常情况，甚至是catch(Throwable t)。Lifting特性就是为了解决这个问题而存在的，可以在内部处理异常情况，并将异常转换成一个特殊的结果None，这样函数外部就可以用统一的模式去处理函数结果。举个例子：
  1. public class VavrFunctionExample {
  2.     @Test
  3.     public void testLifting() {
  4.         Function2<Integer, Integer, Integer> divide = (a, b) -> a / b;
  5.         Function2<Integer, Integer, Option<Integer>> safeDivide = Function2.lift(divide);
  7.         // = None
  8.         Option<Integer> i1 = safeDivide.apply(1, 0);
  9.         Assert.assertEquals("None", i1.toString());
  11.         // = Some(2)
  12.         Option<Integer> i2 = safeDivide.apply(4, 2);
  13.         Assert.assertEquals(2, i2.get().intValue());
  14.     }
  15. }
  • 柯里化方法（Curring）
    柯里化(Currying)指的是将原来接受多个参数的函数变成新的接受一个参数的函数的过程。对于Java来说，可以方便得提供默认值方法，这里看个例子：
  1. public class VavrFunctionExample {
  2.     @Test
  3.     public void testCurried() {
  4.         Function2<Integer, Integer, Integer> sum = (a, b) -> a + b;
  5.         Function1<Integer, Integer> add2 = sum.curried().apply(2);
  7.         Assert.assertEquals(6, add2.apply(4).intValue());
  8.     }
  9. }
  • 记忆化方法（Memorization）
    这是一种缓存，某个方法只需要执行一次，后面都会返回第一次的结果；但是在实际应用中用到的地方应该不多。
  1. public class VavrFunctionExample {
  2.     @Test
  3.     public void testMemorize() {
  4.         Function0<Double> hashCache =
  5.             Function0.of(Math::random).memoized();
  7.         double randomValue1 = hashCache.apply();
  8.         double randomValue2 = hashCache.apply();
  10.         Assert.assertTrue(randomValue1 == randomValue1);
  11.     }
  12. }

模式匹配

模式匹配是函数式编程语言中的概念，目前Java中还不支持这个特性，使用vavr可以用Java写模式匹配的代码。Java中的switch…case语句只能针对常量起作用，而使用模式匹配则可以对另一个函数的返回结果起作用，功能非常抢到。下面的例子分别给出了使用if、switch…case、模式匹配三个语法实现同样功能的例子，可以看出，模式匹配有助于减少代码行数。

  1. import org.junit.Test;
  3. import static io.vavr.API.$;
  4. import static io.vavr.API.Case;
  5. import static io.vavr.API.Match;
  6. import static org.junit.Assert.assertEquals;
  8. public class VavrPatternExample {
  10.     @Test
  11.     public void whenIfWorksAsMatcher_thenCorrect() {
  12.         int input = 3;
  13.         String output;
  14.         if (input == 0) {
  15.             output = "zero";
  16.         }
  17.         if (input == 1) {
  18.             output = "one";
  19.         }
  20.         if (input == 2) {
  21.             output = "two";
  22.         }
  23.         if (input == 3) {
  24.             output = "three";
  25.         } else {
  26.             output = "unknown";
  27.         }
  29.         assertEquals("three", output);
  30.     }
  32.     @Test
  33.     public void whenSwitchWorksAsMatcher_thenCorrect() {
  34.         int input = 2;
  35.         String output;
  36.         switch (input) {
  37.             case 0:
  38.                 output = "zero";
  39.                 break;
  40.             case 1:
  41.                 output = "one";
  42.                 break;
  43.             case 2:
  44.                 output = "two";
  45.                 break;
  46.             case 3:
  47.                 output = "three";
  48.                 break;
  49.             default:
  50.                 output = "unknown";
  51.                 break;
  52.         }
  54.         assertEquals("two", output);
  55.     }
  57.     @Test
  58.     public void whenMatchworks_thenCorrect() {
  59.         int input = 2;
  60.         String output = Match(input).of(
  61.             Case($(1), "one"),
  62.             Case($(2), "two"),
  63.             Case($(3), "three"),
  64.             Case($(), "?"));
  66.         assertEquals("two", output);
  67.     }
  68. }

参考资料

  1. 《Java 8实战》
  2. https://github.com/resilience4j/resilience4j
  3. https://www.baeldung.com/vavr
  4. https://www.vavr.io/vavr-docs/

本号专注于后端技术、JVM问题排查和优化、Java面试题、个人成长和自我管理等主题，为读者提供一线开发者的工作和成长经验，期待你能在这里有所收获。
vavr：让你像写Scala一样写Java - 图4