Пять вещей, которые стоит попробовать как Java-разработчик

Вам не нужно отказываться от экосистемы Java, чтобы расширить свой набор навыков и узнать что-то новое.

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

Если вы дошли до этого момента, пора расшириться и узнать что-то новое. Во-первых, это хорошо для вашей карьеры. Конечно, сама Java - пока она существует некоторое время - вероятно, останется доминирующим языком и платформой еще какое-то время. И легко попасть в рутину, написав такие же корпоративные Java-приложения. Но то, что предлагает платформа Java, всегда будет развиваться. Вокруг вас происходят полезные и революционные инновации: реактивное программирование и функциональное программирование; новые, меньшие и более быстрые фреймворки; обработка больших данных; альтернативные языки JVM. Не обращайте на них внимания, рискуя собственной карьерой!

Во-вторых, это полезно для вашего мозга. Наука ясно, что изучение нового помогает вашему мозгу расти и оставаться здоровым. Конечно, вы можете научиться играть на гитаре, лазать по скалам, жонглировать или исполнять комедийные импровизации (все это было бы отличным навыком для овладения). Но если вы программист, почему бы не получить новые навыки, связанные с вашей деятельностью?

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

Тем не менее, как Java-программисты, мы не всегда хотим уходить слишком далеко от своей территории. Итак, ниже приведены несколько идей для изучения, которые все еще имеют некоторую связь со страной Java.

RxJava

В последнее время популярность реактивного программирования возросла. Это произошло в результате случайного роста по крайней мере двух других отраслевых тенденций:

Фреймворки веб-серверов на основе событийного цикла, такие как Node.js, а также некоторые фреймворки Java на основе Netty, упомянутые далее в этой статье.
Большие данные: пакетная обработка больших потоков данных

RxJava (что означает Reactive eXtensions для Java) тем временем стал одним из первых и самых популярных наборов инструментов Java для выполнения реактивного программирования. Стоит упомянуть, что после появления RxJava спецификация Java Реактивные потоки стала попыткой стандартизировать асинхронную обработку потоков в Java. Reactive Streams API несколько отличается от оригинального API RxJava; однако последние версии RxJava соответствуют новой спецификации.

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

По сути, реактивное программирование включает в себя программирование для асинхронных потоков, эффективно «реагируя» каждый раз, когда в поток поступает часть данных. Итак, я мог бы написать программу, которая говорит: «слушайте этот сокет и каждый раз, когда приходит новое соединение, выполняйте эту работу». Как мы указываем, что это за эта работа? Предоставляя обратный вызов.

Например, псевдо-Java-код для приведенного выше примера может выглядеть так:

Socket s = getSocket();
s.connect(new SocketCallback(SocketData d) {
 log.info(d.message);
});

В выдуманном API выше мы можем подключиться к экземпляру Socket и подключиться к нему, предоставив анонимный экземпляр SocketCallback для обработки данных, которые поступают в результате новых подключений. После выполнения вызова s.connect(…) наш код продолжит выполнение, и через некоторое время, когда будет установлено соединение, будет выполняться наш SocketCallback.

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

getSocket().connect(d -> log.info(d.message);

Но что, если нам нужно связать дополнительные реактивные вызовы для обработки данных сокета?

getSocket().connect(d -> {
  httpClient.sendAsyncRequest(d.message, resp -> {
    dbClient.save(resp.body, result -> {
      log.info("data saved");
    }
  }
});

Мы должны начать вложение наших обратных вызовов, и мы попадаем в «ад обратных вызовов». Три описанных выше обратных вызова все еще могут выглядеть управляемыми, но в реальном мире мы часто обнаруживаем, что связываем вместе гораздо больше реактивных вызовов.

Вот где на помощь приходит RxJava. Короче говоря, он позволяет нам объединять вызовы в цепочку таким образом, который больше похож на процедурное программирование:

getSocket.connect()
.map(d -> httpClient.sendAsyncRequest(d.message)
.map(result -> log.info("data saved"));

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

Как изучить RxJava

Есть несколько способов изучить RxJava. Для начала вы можете создать простой Java-проект, добавить последнюю зависимость RxJava, которая на данный момент выглядит следующим образом:

<dependency>
 <groupId>io.reactivex.rxjava2</groupId>
 <artifactId>rxjava</artifactId>
 <version>2.2.19</version>
</dependency>

Приступая к работе, имейте в виду, что на самом деле RxJava API состоит всего из нескольких основных частей:

Наблюдаемые. Они представляют данные, которые должны быть хорошо изучены и обработаны. Существует несколько различных типов: Observable<T>: основной тип, который представляет 0..n элементов; Single<T>: выдает один элемент (или ошибку); Maybe<T>: выдает один элемент, нет элементов или ошибку; и Completable: либо завершается, ничего не выдавая, либо возвращает ошибку (аналогично Runnable).
Подписчики. Они подписываются на один из наблюдаемых типов, упомянутых выше, и обрабатывают выданные элементы (или ошибки).
Функции обработки. Преобразуйте данные, которые испускаются наблюдаемыми типами, с помощью таких методов, как filter() и map(). Они делают это без изменения каких-либо данных, а, скорее, путем возврата измененных копий. В приведенном ниже примере мы начинаем с Observable из Strings, преобразуем его в новый Observable из Integers (с помощью метода map()), затем снова преобразуем его в новый Observable из Integers (с помощью метода filter()).

При этом вы можете написать и запустить свой первый бит кода RxJava следующим образом:

package rxdemo;
import io.reactivex.Observable;
public class RxDemo {
public static void main(String[] args) {
    Observable<String> obs = Observable.just(
          "foo", "bar", "baz", "monkey", "gamma", "onomatopoeia");
    obs.map(s -> new Integer(s.length()))
    .filter(i -> i > 3)
    .subscribe(len -> {
      System.out.println("Found a large string of length: "+ len);
    }, e -> {
      e.printStackTrace();
    });
  }
}

Оттуда найдите хороший учебник, чтобы начать работу. На веб-сайте ReactiveX есть страница, на которой перечислены несколько учебных пособий и руководство по началу работы. Имейте в виду, что ReactiveX - это не зависящий от языка зонтик реактивных расширений. Хотя концепции во всех реализациях языка очень похожи, вам нужно будет выбрать учебник, специфичный для RxJava, когда вы начнете.

Как только вы освоите код, скорее всего, вы сможете использовать RxJava в выбранной вами структуре. Например, RxJava обычно используется в приложениях для Android. Вы также можете легко добавить его в такие фреймворки, как Spring, и он изначально поддерживается в других фреймворках, таких как Vert.x.

Что вы получите от изучения RxJava

Изучив RxJava, вы сможете полностью погрузиться в реактивное программирование. Если вы мало что сделали, поначалу это может показаться вам немного сложным (в хорошем смысле). Но, вероятно, вам будет также интересно и весело. А благодаря тому, что многие веб-приложения будут переходить к модели реактивного API с циклом событий, вы приобретете навыки, которые пользуются все большим спросом.

Вы также получите относительно мягкое введение в некоторые основные концепции функционального программирования (которые, несмотря на то, что вы могли услышать, хотя и относятся к реактивному программированию, это не одно и то же). Примечательно, что RxJava построен вокруг функторов и монад. В частности, монады, как известно, трудно объяснить, но они удивительно просты, если вы их понимаете. Работа с наблюдаемыми типами RxJava поможет вам понять монады еще до того, как вы это поймете. Это даст вам хорошую возможность - если вы решите - попробовать чисто функциональное программирование (это еще один навык, спрос на который растет).

Scala

Scala - это альтернативный язык программирования для JVM. Его часто называют гибридным функционально-объектно-ориентированным языком. Другими словами, он предоставляет все функции, необходимые для функционального программирования, но также поддерживает объектно-ориентированное программирование. Это может облегчить программистам Java OO изучение Scala, чем, скажем, Clojure, который является чисто функциональным языком JVM.

С учетом сказанного, изучение и понимание Scala может быть трудным и потребовать некоторых усилий. Во-первых, хотя сочетание объектно-ориентированного программирования с функциональным программированием может облегчить изучение Scala, оно также увеличивает сложность языка. Более того, Scala предлагает множество различных способов делать что угодно. Scala также вводит ряд мощных конструкций (например, имплицитов), которые, будучи чрезвычайно полезными, могут сбивать с толку новичков. Наконец, даже документацию Scala может быть трудно читать, пока вы к ней не привыкнете.

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

Кроме того, помогает то, что Scala с самого начала разрабатывался для работы на JVM. Это означает, что вы не отклонитесь от экосистемы Java. Кроме того, Scala совместима с Java. Это означает, что вы можете вызывать код Scala из кода Java и наоборот (на самом деле, я делаю это довольно регулярно, когда зарабатываю на жизнь разработкой Scala).

Наконец, Scala, несомненно, мощный. С языком можно многое сделать. Изучение Scala может занять некоторое время, но при этом вы узнаете некоторые увлекательные и полезные конструкции и, возможно, даже задаетесь вопросом, когда Java начнет их реализовывать.

Как изучить Scala

Во-первых, не начинайте изучать Scala с изучения фреймворка Scala. Это в первую очередь потому, что благодаря мощным конструкциям и гибкому синтаксису Scala многие из его популярных фреймворков (например, фреймворк Play!) Фактически являются предметно-ориентированными языками (DSL). Многие из них требуют, чтобы вы изучили их собственный синтаксис, который может помочь, а может и не помочь в изучении Scala.

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

Когда у вас будет базовый синтаксис языка и конструкции, я бы рекомендовал сосредоточиться на чисто функциональной стороне Scala. В конце концов, как Java-разработчик, объектно-ориентированное программирование не должно быть для вас ничего нового. Я бы порекомендовал Упрощенное функциональное программирование: (Scala Edition) Элвина Александра.

Что вы получите от изучения Scala

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

Для начала вы приобретете опыт с основами функционального программирования. Среди прочего, это поможет вам лучше понять такие вещи, как Java Streams API, как с точки зрения того, почему он существует, как его лучше использовать, так и того, чего ему сейчас не хватает.

Вы также узнаете некоторые мощные конструкции, такие как:

Сопоставление с образцом, которое даст вам представление о функциональности, которой сильно не хватает Java, но которая будет приобретать все мелочи и мелочи.
для понимания, которая делает связанные вызовы функций более понятными.
Каррирование, общая полезная функция в Scala и других функциональных языках, которая также может быть реализована в Java.
Case-классы, которые не только устраняют необходимость в явных геттерах и сеттерах (и явных .equals() и .toString() методах и конструкторах), но также включают такие функции, как сопоставление с образцом

Да, и, может быть, вы поймете, насколько глупыми были дебаты о local var в Java 10.

Весна… или что-то, кроме весны

В мире серверной Java есть два типа программистов:

Те, которые используют Spring (или аналогичный фреймворк для внедрения зависимостей)
Все остальные

Spring, пожалуй, самый популярный серверный фреймворк Java. По своей сути, это фреймворк внедрения зависимостей, Spring превратился в де-факто Java-фреймворк почти для всей корпоративной Java-работы.

Он был выпущен почти два десятилетия назад якобы как реакция на более «тяжелую» версию Java Enterprise Edition (J2EE или, позже, Jave EE). Но даже в первые дни Spring использовала части Enterprise Java, в первую очередь модель сервлетов.

Тем не менее, Spring по-прежнему считается более легким (и открытым) из двух, поэтому он завоевал львиную долю рынка. И действительно, Spring пользуется заслуженной популярностью. Он мощный, простой, с последовательной моделью программирования и доказал свою способность адаптироваться к изменениям в отрасли. На самом деле настолько сильно, что многие программисты Spring полностью погрузились в эту структуру и никогда не удосужились изучить что-либо еще.

Но дело в том, что есть еще много чего. Возникло множество других фреймворков Java, которые набирают популярность. И хотя некоторые из этих фреймворков следуют базовым шаблонам Spring (внедрение зависимостей, многоуровневая архитектура, модель программирования поток за запрос *), многие из них предлагают совершенно разные парадигмы.

С учетом вышесказанного, возможно, вы один из тех, кто занимается серверной обработкой Java и не использует Spring. Учитывая, что Spring по-прежнему является самой популярной средой Java, почему бы не потратить некоторое время на ознакомление с ней? Возможно, вам не удастся переключиться на Spring как на де-факто фреймворк, но это поможет вам понять, почему он так популярен, а также его недостатки, которые привели к другие фреймворки.

* исторически. Spring 5 представил реактивную модель Webflux, хотя многие приложения Spring сегодня по-прежнему придерживаются модели «поток за запрос».

Что вы получите от изучения фреймворка, отличного от Spring

Если вы считаете себя разработчиком Spring, то вы, вероятно, привыкли к мысли, что внедрение зависимостей на основе конфигурации или аннотаций является абсолютной необходимостью для серьезной разработки приложений. Дизайн вашего приложения должен выглядеть как праздничный торт (с вкусным шоколадным слоем DAO внизу, восхитительным ванильным бизнесом / слоем домена в середине и вкусным клубничным слоем пользовательского интерфейса вверху). Каждый запрос должен выполняться в собственном потоке. И это нормально, если ваше приложение запускается за секунды или даже минуты.

В таком случае стоит оспорить эти предположения. Например, есть много новых приложений, которые избегают внедрения зависимостей - по крайней мере, тяжелого встроенного внедрения зависимостей, предоставляемого Spring, - и которые работают так же или более продуктивно, чем Spring.

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

И многие из этих фреймворков - поскольку им не хватает подключения Spring для внедрения зависимостей при запуске - запускаются в мгновение ока. Фактически, некоторые даже изначально поддерживают горячую перезагрузку, избегая необходимости цикла перекомпиляции / перезапуска для проверки изменений.

Вы вполне можете решить придерживаться Spring в качестве своего фактического фреймворка. Но изучение других фреймворков даст вам представление об имеющихся альтернативах.

Само по себе это расширит ваши навыки. Более того, это может быть вам спасением, если вы столкнетесь с вариантами использования, для которых Spring не является идеальным решением ... и столкнетесь с тем, что товарищи по команде задаются вопросом, нужно ли вообще использовать другой язык. Я неоднократно сталкивался с ситуациями, когда большое количество ожидаемых одновременных запросов приводило к размышлениям о том, что мы используем Node.js. Мое знакомство с фреймворком Vert.x, который сам заимствован из модели Node.js и дает преимущества по сравнению с Node, предоставил нам отличный вариант, который удерживал нас во вселенной Java.

Изучение фреймворка, отличного от Spring

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

Vert.x

Vert.x - один из моих любимых фреймворков, которые я использовал. Как и многие новые Java-фреймворки, он построен на Netty; он предлагает парадигму программирования на основе цикла событий и реактивный API, позволяя обрабатывать огромное количество запросов. Он также предлагает ряд полезных инновационных функций, в том числе:

Программирование полиглотов. При написании приложений Vert.x вы можете выбирать из множества языков, таких как Python, Scala, Kotlin, Javascript и, конечно же, Java. Вы даже можете смешивать языки в одном приложении. Так что, даже если вы можете придерживаться Java, вы можете баловаться другими языками ... или убедить своего товарища по команде, любящего Python, в том, что Vert.x - это правильный вариант для вашего следующего проекта.
Вертикальные статьи. Приложения Vert.x могут быть составлены с помощью вершин, которые представляют собой независимо развертываемые компоненты. Вертикальные статьи взаимодействуют друг с другом посредством передачи сообщений через шину событий (обсуждается далее). Это позволяет разделить вертикали друг от друга. Он также обеспечивает гибкую модель развертывания, в которой один и тот же набор вершин может работать либо в одном приложении, либо в разных приложениях.
Шина событий. Как следует из названия, шина событий Vert.x - это канал, через который сообщения могут публиковаться и использоваться. Это основной механизм, с помощью которого общаются разные статьи.
Горячая перезагрузка. В частности, когда принята вертикальная модель, изменения автоматически перезагружаются. Не нужно закрывать, перекомпилировать и перезапускать приложение.

Есть несколько способов изучить Vert.x. В Интернете вы найдете ряд учебных пособий (включая мое собственное), но вы также можете просто начать работу на vertx.io. Документация первоклассная, а на сайте есть ссылки на ряд инструкций и руководств.

Играть!

Игра! framework »был создан компанией Typesafe (теперь необъяснимо известной как Lightbend ) десять лет назад. Написанный на Scala, он быстро стал одним из самых популярных веб-фреймворков Scala. Однако он также предлагает первоклассный Java API, так что вы можете придерживаться своего языка в повседневной жизни.

Игра также построена на основе Netty и имеет реактивный API. Таким образом, он представляет собой отличное введение в разработку веб-приложений на основе цикла событий. Он также имеет быстрое время запуска и поддерживает горячую перезагрузку кода, что позволяет разработчикам избежать цикла перекомпиляции-перезапуска для проверки изменений.

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

Кваркус

Quarkus, один из новейших фреймворков Java (по крайней мере, на момент написания), является многообещающим фреймворком с почти революционными функциями. Как и большинство новых фреймворков Java, Quarkus построен на Netty. Фактически, он построен на основе Vert.x (описанного выше), который сам построен на Netty. Он также добавляет в Mutiny собственную реактивную библиотеку, которая значительно упрощает написание реактивного кода.

Но более того, Quarkus был создан с нуля с учетом Kubernetes и контейнеров. С самого начала целями были быстрый запуск, низкие накладные расходы на память и меньший размер приложения. Quarkus также был разработан для работы на GraalVM и может быть легко скомпилирован в собственный исполняемый файл.

Quarkus также рекламирует свое слияние императивного и реактивного программирования. Фактически, единственная причина, по которой я мог бы не рекомендовать Quarkus в качестве другого фреймворка для разработчиков Spring, заключается в том, что Quarkus на самом деле может быть немного слишком знакомым. С учетом сказанного, для разработчиков Spring, которые хотят попробовать что-то новое, но не хотят выходить слишком далеко за пределы своей зоны комфорта, Quarkus может быть как раз тем, что нужно.

Чтобы начать работу с Quarkus, вероятно, нет лучшего способа, чем перейти на страницу Начало работы Quarkus.

Что вы получите от изучения Spring

Если вы один из немногих Java-программистов, которые не знают и не используют Spring, вам действительно следует с ним ознакомиться. Spring - это де-факто фреймворк для внедрения зависимостей (в экосистеме Java, а также в остальной индустрии программного обеспечения). Понимание Spring поможет вам понять, насколько мощной может быть инъекция зависимостей.

Изучение Spring Framework

На данный момент существует бесчисленное множество ресурсов для изучения Spring. Кроме того, экосистема Spring стала достаточно обширной, и вам нужно будет решить, какой вариант приложения Spring вы хотите попробовать. Я бы порекомендовал сразу перейти к делу и создать приложение SpringMVC, построенное с помощью Spring Boot (среды быстрой разработки Spring для микросервисов). Просто перейдите на страницу Начало работы с Spring Boot.

Apache Beam

В наши дни большие данные - это большая новость. За прошедшие годы появился ряд фреймворков - Hadoop, Flink, Spark, Storm - для обработки больших объемов данных. Ни один из них не был супер-интуитивно понятным для обычного программиста. И они всегда боялись просто сесть и научиться как универсальный разработчик программного обеспечения.

Apache Beam отличается. Во-первых, Beam - это фреймворк для обработки данных более высокого уровня, который не зависит от исполнителя. Это означает, что вы можете написать свой код (Java - первоклассный гражданин в Beam, как и Python) и запускать его, используя множество различных бегунов. В некотором смысле Beam, как Java, позволяет выполнять однократную запись и запускать где угодно. Например, вы можете написать свой код обработки данных и легко запустить его локально, а затем, не меняя ни строчки кода, запустить его в Google Cloud Dataflow.

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

public class WordCounter {
public static void main(String[] args) {
    PipelineOptions options = PipelineOptionsFactory.create();
    Pipeline p = Pipeline.create(options);
    p.apply(TextIO.read().from("gs://apache-beam-samples/shakespeare/*"))
        .apply(
            FlatMapElements.into(TypeDescriptors.strings())
                .via((String line) -> Arrays.asList(line.split("[^\\p{L}]+"))))
        .apply(Filter.by((String word) -> !word.isEmpty()))
        .apply(Count.perElement())
        .apply(
            MapElements.into(TypeDescriptors.strings())
                .via(
                    (KV<String, Long> wc) ->
                        wc.getKey() + ": " + wc.getValue()))
        .apply(TextIO.write().to("wordcounts"));
    p.run().waitUntilFinish();
  }
}

и запустив его примерно так:

mvn compile exec:java -Dexec.mainClass=com.me.example.WordCounter -Dexec.args="--output=./output/"

Очевидно, что это базовый пример, когда все втиснуто в основной метод - вряд ли так, как вы написали бы настоящую программу. Но он показывает, насколько легко начать работу с простого примера Beam, а затем строить его по мере того, как вы узнаете все больше и больше.

Что вы получите от изучения Beam

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

Кроме того, изучая Beam, вы узнаете фреймворк, который можно запускать в нескольких средах. Как мы уже упоминали, Beam не зависит от бегунов. Таким образом, вы можете легко запускать свои приложения Beam локально, а также в Google Cloud Data Flow. Вы также можете запускать их на Spark, что означает, что (благодаря AWS EMR) вы можете запускать их на AWS (хотя и с немного большими усилиями).

Изучение Apache Beam

Пример Word Count кажется привет мир Apache Beam. Поэтому я бы порекомендовал перейти к руководству Beam Начало работы - WordCount, чтобы приступить к разработке и локальному запуску Beam. Более того, очень легко запустить тот же пример на Google Cloud Platform (GCP). Фактически, GCP предлагает собственное простое в использовании руководство, основанное на том же приложении WordCount. Итак, попробуйте одно - или попробуйте оба.

React.js

Как разработчики Java, мы любим объектно-ориентированный объект, строгую типизацию и скомпилированный код, и не зря. Поэтому может быть трудно принять язык программирования, который не предлагает ни компиляцию, ни строгую типизацию, ни - до недавнего времени - объекты.

И все же JavaScript - наряду с Java - один из самых популярных языков программирования. Вы можете возразить, что его популярность объясняется исключительно тем, что он является единственным языком, работающим во всех основных браузерах. Возможно, ты прав. Но это не меняет того факта, что JavaScript - чрезвычайно важный язык в отрасли.

Но как Java-разработчику совместить отвращение к языку и необходимость его выучить? Есть ответ, и этот ответ - React.js.

Вы, наверное, слышали о React. Но есть вероятность, что со стороны это просто кажется последним в длинной линейке фреймворков JavaScript, о которых говорит мир интерфейсных программ. Это не. И хотите верьте, хотите нет, но как Java-разработчик вам действительно может понравиться React.

Для этого есть ряд причин, таких как:

Это простая для понимания парадигма. По своей сути React - это создание компонентов. Эти компоненты затем объединяются в приложения пользовательского интерфейса. Конечно, вам понадобится немного JavaScript, но изучение React - это не изучение JavaScript; речь идет об изучении инфраструктуры веб-интерфейса.
JavaScript - это только часть уравнения. При работе с React вы будете разрабатывать компоненты, которые состоят из трех равных частей: стили презентации в форме каскадных таблиц стилей или CSS; разметка презентации в виде JSX (который очень похож на HTML) и логика представления в форме JavaScript.
JavaScript больше похож на клей. Как уже упоминалось, вы не будете работать только с JavaScript. Более того, когда вы пишете JavaScript, вы обычно будете использовать его как настоящий язык сценариев, по сути склеивая части приложения вместе. По сути, так, как он был предназначен для использования, когда он был впервые написан несколько десятилетий назад.
У него хорошая система сборки, которая может обнаруживать ошибки. Помните, как мы сказали, что, как разработчики Java, нам нравятся компиляторы? React предлагает один (ну, действительно, больше транспилятор), и он хороший. Помимо создания компактного, готового к эксплуатации кода, он будет обнаруживать определенные классы ошибок. Хотя он не такой надежный, как компилятор Java, он обеспечивает достойную защиту от ошибок, которые в противном случае могли бы возникнуть во время выполнения.
Пользовательские интерфейсы React легко создавать поверх приложений Java. Тот факт, что вы используете React, JavaScript и Node.js (на которых работает система сборки React), не означает, что вы не можете счастливо продолжайте создавать все свои серверные приложения на Java. Фактически, создавать пользовательские интерфейсы React, взаимодействующие с серверными модулями Java, очень просто. Более того, упаковав все в исполняемый файл uber-JAR, легко создать автономное веб-приложение на базе React и Java.
При желании вы можете использовать TypeScript. JavaScript отображается в React в виде управляемых небольших фрагментов. Но если вы действительно против JavaScript, вы всегда можете использовать TypeScript и язык со строгой и статической типизацией, который преобразуется в JavaScript. Честно говоря, TypeScript - довольно забавный и интересный язык с множеством функций, с которыми Java-разработчики знакомы (строгая типизация, богатая иерархия объектов), а также с некоторыми, которым разработчики Java могут немного позавидовать ( например, типы объединения, встроенные кортежи).

Как изучить React.js

Есть много хороших руководств по React.js, таких как этот. Большинство руководств предполагают некоторое знакомство с JavaScript. Но даже если вы никогда не работали с JavaScript, вы почти наверняка сможете справиться с некоторыми проблемами.

С учетом сказанного, одна проблема, с которой я постоянно сталкивался, когда изучал React (и которая до сих пор время от времени меня кусает), - это контекст JavaScript. Большая часть кода JavaScript, который вы напишете в React, будет иметь форму методов обратного вызова. Другими словами, вы напишете компонент, который может реагировать на какое-то событие (возвращается HTTP-запрос, пользователь нажимает кнопку и т. Д.). Вы запрограммируете метод обратного вызова в этом компоненте и зарегистрируете обратный вызов для обработки события. Любой Java-разработчик мог бы ожидать, что сможет использовать ключевое слово this для ссылки на Компонент ... в конце концов, именно там и определяется метод. Но вы не можете… если вы не сделаете одну странную вещь в конструкторе Component:

this.myCallback = this.myCallback.bind(this);

Не спрашивайте меня, почему. Это просто вещь. В большинстве руководств по JavaScript этот вопрос вкратце затрагивается; обязательно запомните, особенно когда в сообщении об ошибке React говорится о том, что ваш myCallback() метод пытается вызвать другой несуществующий метод.

Что вы получите от React.js

Изучив React.js, вы познакомитесь с одним из самых популярных фреймворков пользовательского интерфейса. Вы также научитесь изучать JavaScript. Более того, вы изучите интуитивно понятную парадигму веб-интерфейса, которая очень хорошо интегрируется с Java.

Пора расти

Я понял. Вам нравится Java, и вам нравится то, что вы делали в своей карьере. Но пребывание слишком в комфорте может нанести ущерб вашей карьере, вашей остроте ума и (возможно, по иронии судьбы) вашему удовлетворению карьерой. Существует более чем достаточно инновационных вещей, которые можно попробовать и изучить… даже не покидая экосистемы Java.