Кофе-брейк #109. Самые востребованные сейчас навыки в Java-разработке. 7 советов по Java Optional, чтобы избавиться от беспорядка в коде

Самые востребованные сейчас навыки в Java-разработке

Источник: Medium Java остается одним из самых популярных и востребованных языков программирования, несмотря на то, что ему почти четверть века. Поэтому разумно предположить, что популярность Java будет продолжать расти, и в будущем Java-разработчики увидят еще больший спрос со стороны работодателей. Чтобы создавать качественные продукты, разработчикам необходимо постоянно следить за выпуском новейших инструментов Java и повышать свои технические навыки и знания. Ниже мы представляем шесть основных навыков, обязательных для Java-разработчиков.

1. Отличное знание Java 8

Несмотря на то, что уже широко применяются более свежие версии Java, всем начинающим Java-разработчикам необходимы глубокие знания и опыт работы с Java 8. Некоторые из наиболее полезных функций Java 8 включают в себя:

• Стандартные и статические методы для создания интерфейсов с реализацией методов.
• Функциональный интерфейс, который имеет только один абстрактный метод и помогает разработчикам избежать добавления других абстрактных методов.
• Лямбда-выражения, помогающие создавать функциональные интерфейсы.
• Java Stream API для обеспечения параллельного и последовательного выполнения.
• Новые методы в Collection API.

Все эти функции делают Java 8 незаменимой для функционального программирования. Функциональное программирование обеспечивает параллелизм и краткость кода, а также помогает создавать высоконагруженные приложения с оптимизированным кодом. Java 8 также стала основой для оптимизации машинного кода, что позволило оптимизировать разработку на других языках, таких как Scala, Kotlin и Grails.

2. Опыт работы с тестированием

Модульное тестирование в Java — довольно спорная тема. Некоторые разработчики утверждают, что написание юнит-тестов — пустая трата времени, но мы твердо убеждены, что навыки юнит-тестирования обязательны для любого профессионального Java-разработчика. Модульное тестирование позволяет тестировать отдельные блоки кода и гарантирует, что конечный продукт будет работать без ошибок. Поэтому, если разработчик хочет повысить свои навыки и знания, ему необходимо научиться использовать самые популярные и эффективные инструменты тестирования. Основной средой тестирования, с которой вам нужно близко познакомиться, является библиотека JUnit 5. С список других инструментов входит:

• Robot Framework
• Mockito
• PowerMock

Помимо модульного тестирования, Java-разработчик не должен забывать о других методах тестирования (системное тестирование, приемочное тестирование и интеграционное тестирование). Это позволяет выполнить комплексное тестирование программного обеспечения и убедиться в отсутствии ошибок, багов или критических сбоев. Главное, что нужно помнить о тестировании: небольшие изменения приводят к большим результатам. Если вы, не колеблясь, потратите время и усилия на модульное тестирование, вы будете поражены повышением качества своей работы.

3. DevOps

Хотя это и не является обязательным пунктом, изучение DevOps и его принципов может быть полезным для вас как разработчика, так и для компании, в которой вы работаете. Гибкость и организация процессов DevOps позволяют компаниям оптимизировать качество своего продукта и рационализировать операции. а также повысить прозрачность процессов. DevOps в Java — это, по сути, приложение DevOps к разработке Java. К нему относится:

• Непрерывная доставка и интеграция.
• Работа с микросервисами вместо монолитов.
• Инфраструктура как код.
• Автоматизированное тестирование.

DevOps — обширная область, поэтому для ее изучения необходимо потратить значительное количество времени и ресурсов. Но если вы являетесь Java-разработчиком, изучение DevOps будет полезно, поскольку оно позволит вам в будущем стать инженером DevOps. Если вы не хотите становиться инженером DevOps или ваша компания не заинтересована в этом, то это тоже нормально. Просто имейте в виду, что DevOps становится все популярнее в сообществе Java.

4. Знание библиотек Java и API.

Поскольку Java является одним из ведущих языков программирования в мире, неудивительно, что он имеет огромное количество доступных API и библиотек для работы. Эти инструменты значительно облегчают процесс разработки и позволяют разработчикам быстро создавать надежное программное обеспечение. Ниже мы перечислили базовый набор инструментов, которые знает и может уверенно использовать любой хороший Java-разработчик. Эти инструменты помогают быстро собрать приложение и эффективно управлять данными и их хранилищем:

• Gradle (инструмент для сборки приложений);
• Maven (немного устарел, но все еще популярен, также используется для сборки приложений);
• Стандартные пакеты Java 8;
• Spring Фреймворки;
• JPA ORM (Hibernate, TopLink);
• Базы данных NoSQL (MongoDB, Cassandra).

Что касается API, то для работы с основным API Java разработчику необходимо хорошо знать OpenJDK, Android, Oracle и IS2T. Большим преимуществом этих инструментов является то, что все они поставляются с подробной и информативной документацией. Более того, разработчики всегда могут получить поддержку сообщества, что также является большим преимуществом.

5. Уверенное знание Spring и Spring Boot

Spring Framework является наиболее часто используемой средой для разработки приложений на основе Java, поэтому важно, чтобы разработчик знал, как с ней работать. Одним из ключевых преимуществ Spring является внедрение зависимостей, которое позволяет создавать слабо связанные приложения и предоставляет разработчикам большую гибкость. Spring также очень легкий, поддерживает конфигурации XML, аннотации и декларативное программирование. Поэтому, если вы хотите овладеть навыками разработки на Java, вы также должны освоить развертывание Spring. Spring Boot — это итерация Spring, которая представляет собой удобный инструмент для быстрого развертывания приложений. Можно с уверенностью сказать, что Spring Boot использует Spring в качестве основы и строит на нем свои собственные функции. В то время как Spring ориентирован на гибкость, Spring Boot помогает сократить код и упрощает процесс разработки. Он предлагает разработчикам готовые к работе функции, помогает создавать автономные приложения и в целом проще в запуске и управлении. Spring Boot отлично подходит для микросервисов и приложений, которые необходимо быстро создать, поскольку он обеспечивает быструю и простую настройку и запуск приложений для различных сред (производство, тестирование, качество, CI/CD). И Spring, и Spring Boot расширились за счет возможностей программирования React, что является еще одной горячей тенденцией в сообществе разработчиков. Spring 5, например, теперь имеет WebFlux для реализации реактивного подхода к программированию и разрешению сложных распределенных систем.

6. Опыт работы с Big Data

Big Data — это растущая тенденция, которой разработчики должны следовать и перенимать, чтобы соответствовать требованиям рынка. Основные инструменты, с которыми могут ознакомиться профессиональные Java-разработчики:

• Apache Spark
• Apache Kafka
• Hadoop (для пакетной обработки данных)

Apache Spark — это распределенная платформа для обработки Big Data, предоставляющая собственные привязки для Java. Этот фреймворк стал чрезвычайно популярным благодаря своим функциям и производительности и в настоящее время является наиболее предпочтительным инструментом для работы с большими данными в сообществе Java. Apache Spark может работать в автономном режиме кластера, и для этого вам понадобится только среда Apache Spark и JVM (для каждой машины в кластере). Spark также невероятно быстр и имеет очень удобный Spark API. Hadoop — это платформа для хранения данных, которая также хорошо известна разработчикам Java. Хотя Hadoop уступает по скорости выполнения Spark, он остается одним из самых популярных инструментов для работы с большими данными. Это также связано с тем, что Hadoop (и подобные решения) имеют большое количество плагинов, которые позволяют эффективно решать задачи обработки Big Data и в целом оптимизировать производительность Hadoop (включая поддержку потоковой обработки в реальном времени).

7 советов по Java Optional, чтобы избавиться от беспорядка в коде

Источник: Medium “У меня есть коллеги, которые не знают о существовании Optional”, — пишет один Java-разработчик на Reddit. Можно ли считать, что Optional улучшает “читабельность” кода? Стоит ли его постоянно использовать? Где применение Optional совершенно не нужно? Поскольку многие разработчики до сих пор не знают, как правильно использовать Optional, я приведу 7 примеров злоупотреблений Optional и что с ними делать.

1. Не используйте Optional для null check

Использование Optional вместо null check только добавляет беспорядок. Никакой пользы от этого нет. Ошибочно также применять Optional и методы isPresent и get. Разработчики считают, что get должен работать так, как от него ожидается. Затем они добавляют isPresent и возвращаются к null check. Помните, что Optional не исправляет ваши null check. В следующий раз, когда вы увидите isPresent и get (или ElseThrow) измените этот фрагмент кода. Используйте сопоставление (mapping) и orElse, чтобы удалить стандартные null check, и используйте Optional более избирательно. Вот один хороший пример:

var user = userService.getCurrentUser();
if(user == null) {
    return "(unknown)";
}
var username = user.getUsername();
if (username == null) {
    return "(unknown)";
}
return username;
vs

var user = userService.getCurrentUser();
if(user.isEmpty()) {
    return "(unknown)";
}
var username = user.orElseThrow().getUsername();
if (username == null) {
    return "(unknown)";
}
return username;
vs

return userService.getCurrentUser()
                  .map(User::getUsername)
                  .orElse("(unknown)");

Вы можете начать с цели Optional. Цель Optional состоит в том, чтобы представить необязательные, отсутствующие значения. Затем вернитесь к своей проблеме и посмотрите, подходит ли это вам. Еще один способ справиться с null check — использовать аннотации. Nullable или NotNull должны работать хорошо. Правда, они могут загрязнить ваш код, и они защищают только во время компиляции. Для проверки runtime используйте Objects.requireNonNull.

2. Выполняйте правильную обработку ошибок

Иногда null представляет исключения. И это неправильный способ сигнализировать об ошибках и исключениях. “Что-то пошло не так, и вот null”, — анти-шаблон, которого следует избегать. Кроме того, вы не должны использовать Optional для покрытия исключений. Вот пример.

public Optional<MyObject> getMyObject(final String jql) {
    try {
        return Optional.ofNullable(get(sql));
    } catch (final JqlParseException e) {
        return Optional.empty();
    }
}

Почему myObject пустой (empty)? Это либо ошибка, либо пустое значение. Поэтому вы бы снова получили неоднозначный результат и в результате стерли преимущества Optional. Этот код существует, поскольку люди пытаются использовать Optional для потока управления (control flow). Optional удалит некоторые нули в вашей кодовой базе. Но вам все еще нужно использовать конструкцию try-catch для обработки исключений. Используйте try-catch для правильной обработки исключений. Не удаляйте Optional при обработке ошибок, просто подождите, и он будет работать идеально. Но здесь есть одно исключение — empty catch. Когда вы не знаете, что возвращать в empty catch, пустое значение Optional должно работать нормально.

private int readExpirationAsInt(Milk milk)
{
  String expiration = milk.getExpiration();
  try {
    return Integer.parseInt(expiration);
  }
  catch(NumberFormatException ignored) {}
  
  return 0;
}


private OptionalInt readExpirationAsInt(Milk milk)
{ 
  String expiration = milk.getExpiration();
  
  try {
    return Optional.of(Integer.parseInt(expiration));
  }
  catch(NumberFormatException e) {
    return OptionalInt.empty();
  }
}

3. Не возвращайте null из методов Optional

public static Optional<POSType> getPOSType(String posName) {
    if (StringUtils.isNotBlank(posName)) {
        return Arrays.stream(POSType.values())
                .filter(type -> type.toString().equalsIgnoreCase(posName))
                .findFirst();
    }
    return null;
}

Это противоречит цели Optional. Это еще один пример плохой проверки. Поскольку ввод пуст, это означает, что нам нужен файл IllegalArgumentException. Кроме того, это ошибка. Никому не нужно проверять методы вызова Optional. Возвращайте пустой элемент Optional и никогда не проверяйте элемент Optional на null.

4. Не используйте Optional с коллекциями.

Нет необходимости оборачивать (wrap) коллекции в Optional. Более того, не помещайте Optionals в коллекции. Это только усложняет, добавляя бессмысленную boxing и дополнительное развертывание (unwrapping). Не добавляйте Optionals в коллекции. Видимой пользы от этого нет. Сохраняйте простоту и используйте Optional для отсутствующих значений.

5. Не привязывайтесь ради привязки (Don’t chain for the sake of chaining)

Optional.ofNullable(foo).ifPresent(value -> {
  //do something
})

Optional имеет подробные методы, которые могут помочь в этом. Вместо chain будет достаточно простого null check. Я знаю, что Optional есть хорошие методы и хорошая поддержка IDE. Вы можете их использовать.

6. Используйте примитивные оболочки значений

Это не очень большая проблема, но вы можете использовать OptionalInt или OptionalLong. Просто удалив ненужные дженерики, вы улучшите производительность и напишите более краткий код.

7. Вы должны знать о ofNullable

if (a==null){
  return Optional.empty();
} else {
  return Optional.of(a);
}

Такой код обычно пишут разработчики, которые не знают о Optional#ofNullable. Большинство разработчиков даже не понимают разницы между ofNullable и of. Они не понимают как Optional#of может иметь неприятные последствия. Большинство прибегло бы к ofNullable, опасаясь исключения NullPointerException в Optional#of. Опять же, это противоречит цели этих двух методов. Если мы используем только ofNullable, зачем вообще нужен Optional#of? Optional#of выкидывает NPE, когда вы проходите в null. Это происходит не просто так. Этот метод следует использовать, когда вы ожидаете, что значение будет присутствовать. Если его нет, он быстро выйдет из строя. Optional#ofNullable преобразует null в пустой Optional. Этот метод принимает null в качестве аргумента, который сопоставляется с пустым Optional.