«1. Введение

В этой статье мы рассмотрим, как мы можем реализовать шаблон разработки стратегии в Java 8.

Сначала мы дадим обзор шаблона и объясним, как он традиционно реализуется в Java 8. старые версии Java.

Далее мы попробуем шаблон снова, только на этот раз с лямбда-выражениями Java 8, что уменьшит многословие нашего кода.

2. Шаблон стратегии

По сути, шаблон стратегии позволяет нам изменять поведение алгоритма во время выполнения.

Обычно мы начинаем с интерфейса, который используется для применения алгоритма, а затем реализуем его несколько раз для каждого возможного алгоритма.

Допустим, у нас есть требование применять различные типы скидок к покупке в зависимости от того, будет ли это Рождество, Пасха или Новый год. Во-первых, давайте создадим интерфейс дискаунтера, который будет реализован каждой из наших стратегий: 

public interface Discounter {
    BigDecimal applyDiscount(BigDecimal amount);
}

Затем, допустим, мы хотим применить скидку 50% на Пасху и скидку 10% на Рождество. Давайте реализуем наш интерфейс для каждой из этих стратегий: 

public static class EasterDiscounter implements Discounter {
    @Override
    public BigDecimal applyDiscount(final BigDecimal amount) {
        return amount.multiply(BigDecimal.valueOf(0.5));
    }
}

public static class ChristmasDiscounter implements Discounter {
   @Override
   public BigDecimal applyDiscount(final BigDecimal amount) {
       return amount.multiply(BigDecimal.valueOf(0.9));
   }
}

Наконец, давайте попробуем стратегию в тесте: 

Discounter easterDiscounter = new EasterDiscounter();

BigDecimal discountedValue = easterDiscounter
  .applyDiscount(BigDecimal.valueOf(100));

assertThat(discountedValue)
  .isEqualByComparingTo(BigDecimal.valueOf(50));

Это работает довольно хорошо, но проблема в том, что это может быть немного болезненно. чтобы создать конкретный класс для каждой стратегии. Альтернативой может быть использование анонимных внутренних типов, но это все еще довольно многословно и не намного удобнее, чем предыдущее решение: 

Discounter easterDiscounter = new Discounter() {
    @Override
    public BigDecimal applyDiscount(final BigDecimal amount) {
        return amount.multiply(BigDecimal.valueOf(0.5));
    }
};

3. Использование Java 8

После выпуска Java 8 введение лямбда-выражений сделал анонимные внутренние типы более или менее избыточными. Это означает, что создавать стратегии в очереди теперь намного чище и проще.

Кроме того, декларативный стиль функционального программирования позволяет нам реализовывать шаблоны, которые раньше были невозможны.

3.1. Сокращение детализации кода

Давайте попробуем создать встроенный EasterDiscounter, только на этот раз с использованием лямбда-выражения: 

Discounter easterDiscounter = amount -> amount.multiply(BigDecimal.valueOf(0.5));

Как мы видим, наш код стал намного чище и удобнее в сопровождении, достигая того же уровня, что и раньше, но в одна линия. По сути, лямбду можно рассматривать как замену анонимному внутреннему типу.

Это преимущество становится более очевидным, когда мы хотим объявить еще больше Дисконтеров в очереди: 

List<Discounter> discounters = newArrayList(
  amount -> amount.multiply(BigDecimal.valueOf(0.9)),
  amount -> amount.multiply(BigDecimal.valueOf(0.8)),
  amount -> amount.multiply(BigDecimal.valueOf(0.5))
);

Когда мы хотим определить много Дисконтеров, мы можем объявить их всех статически в одном месте. Java 8 даже позволяет нам определять статические методы в интерфейсах, если мы этого хотим.

Итак, вместо того, чтобы выбирать между конкретными классами или анонимными внутренними типами, давайте попробуем создать все лямбда-выражения в одном классе: 

public interface Discounter {
    BigDecimal applyDiscount(BigDecimal amount);

    static Discounter christmasDiscounter() {
        return amount -> amount.multiply(BigDecimal.valueOf(0.9));
    }

    static Discounter newYearDiscounter() {
        return amount -> amount.multiply(BigDecimal.valueOf(0.8));
    }

    static Discounter easterDiscounter() {
        return amount -> amount.multiply(BigDecimal.valueOf(0.5));
    }
}

Как мы видим, мы достигли многого в небольшом коде.

3.2. Использование композиции функций

Давайте изменим наш интерфейс Discounter, чтобы он расширял интерфейс UnaryOperator, а затем добавим метод Combine(): 

public interface Discounter extends UnaryOperator<BigDecimal> {
    default Discounter combine(Discounter after) {
        return value -> after.apply(this.apply(value));
    }
}

По сути, мы реорганизуем наш Discounter и используем тот факт, что применение скидки является функция, которая преобразует экземпляр BigDecimal в другой экземпляр BigDecimal, позволяя нам получить доступ к предопределенным методам. Поскольку UnaryOperator поставляется с методом apply(), мы можем просто заменить им applyDiscount.

Метод comb() — это всего лишь абстракция, связанная с применением одного дискаунтера к результатам этого. Для этого используется встроенный функционал apply().

Теперь давайте попробуем применить несколько дискаунтеров кумулятивно к сумме. Мы сделаем это, используя функцию reduce() и нашу функцию Combine(): 

Discounter combinedDiscounter = discounters
  .stream()
  .reduce(v -> v, Discounter::combine);

combinedDiscounter.apply(...);

Обратите особое внимание на первый аргумент reduce. Когда скидки не предоставляются, нам нужно вернуть неизменное значение. Этого можно достичь, предоставив функцию идентификации в качестве дискаунтера по умолчанию.

Это полезная и менее подробная альтернатива стандартной итерации. Если мы рассмотрим методы, которые мы получаем из коробки для функциональной композиции, это также дает нам гораздо больше возможностей бесплатно.

4. Заключение

В этой статье мы объяснили шаблон стратегии, а также продемонстрировали, как мы можем использовать лямбда-выражения для его менее подробной реализации.

«Реализацию этих примеров можно найти на GitHub. Это проект на основе Maven, поэтому его легко запустить как есть.