Java без розовых очков: какие знания отделяют грейды

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

В этой статье поговорим про джавистов: что на самом деле стоит за грейдами и какие компетенции формируют профессионала на каждом этапе.

Ключевые направления развития Java-разработчика

1. От синтаксиса к инженерному мышлению: Java Core
Путь любого Java-разработчика начинается с базы: переменные, типы данных, операторы, условия, циклы, массивы. Но на уровне профессии это не про «знаю синтаксис», а про понимание того, как устроена модель языка. Что такое объект, где граница ответственности класса, зачем нужен интерфейс и когда абстрактный класс предпочтительнее. Важны исключения и их корректная обработка, работа со строками и коллекциями, generics, базовые алгоритмы, java.time, ввод-вывод. Все это формирует фундамент, без которого фреймворки остаются «магией».

Middle-разработчик уже не просто пользуется инструментами, а понимает их устройство и ограничения. Он глубже проектирует классы, осознанно применяет generics и Stream API, разбирается в многопоточности — не только на уровне ExecutorService, но и с точки зрения гонок, синхронизации и видимости памяти. Он начинает замечать, как выбор структуры данных влияет на производительность, и способен оптимизировать работу с памятью и файлами.

Senior выходит на уровень платформы. Его зона внимания — производительность, асинхронность и реактивность. Он умеет работать с CompletableFuture, понимает реактивный стек (Reactor, WebFlux), профилирует код, настраивает JVM, анализирует потребление CPU и памяти. Это уже не просто «разработка фич», а управление поведением системы под нагрузкой.

 2. ООП и качество кода: от «работает» к «поддерживается»
На базовом уровне важно научиться писать читаемый код: соблюдать соглашения, грамотно именовать сущности, документировать сложные места, создавать собственные исключения и корректно логировать ошибки. Понимание SOLID, DRY и KISS — не как лозунгов, а как практических ориентиров — отличает аккуратного разработчика от хаотичного.

Middle начинает применять паттерны проектирования осознанно. Singleton, Factory, Adapter, Strategy и другие решения перестают быть словами из книжки и становятся инструментами. Появляется внимание к модульности, к повторному использованию кода, к статическому анализу качества (Sonar, Checkstyle). Мидл уже думает о том, как код будет жить через год.

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

3. Spring, REST и данные: от CRUD к распределенным системам
Современный Java-разработчик практически неизбежно работает со Spring. На базовом уровне важно понимать принципы IoC и DI, устройство бинов и контекста, уметь создать REST-сервис, работать с JSON и HTTP, использовать Spring Boot и Spring Data. Не менее важно владеть SQL, понимать проектирование реляционных баз данных — ключи, индексы, нормализацию — и использовать JPA/Hibernate. Git и Maven/Gradle становятся рабочими инструментами, а не «чем-то для DevOps».

Middle-разработчик начинает осознанно выбирать архитектурный стиль. Он понимает, когда достаточно монолита, а когда оправданы микросервисы. Он работает с брокерами сообщений (Kafka, RabbitMQ), глубже разбирается в ORM и при необходимости может обратиться к JDBC напрямую. В его практике появляются модульные тесты с JUnit и Mockito — как инструмент гарантии качества.

Senior выходит на уровень распределенных систем. Он проектирует микросервисную архитектуру с учетом отказоустойчивости и масштабируемости, использует Spring Cloud, настраивает безопасность через Spring Security (OAuth2, JWT), внедряет circuit breaker и распределенный трейсинг. Контейнеризация (Docker) и оркестрация (Kubernetes) становятся частью повседневной работы. Здесь же — продвинутые практики тестирования, интеграция CI/CD и мониторинг.

4. Web, DevOps и эксплуатация
Понимание HTTP, сервлетов, контейнеров вроде Tomcat или Jetty — это базовый слой, который позволяет видеть, как приложение живет вне IDE. Middle подключается к контейнеризации и автоматизации сборки, а Senior проектирует отказоустойчивую инфраструктуру, учитывая деплой, масштабирование и наблюдаемость системы.

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

Разница в уровне проявляется в степени ответственности. Junior учится формулировать вопросы и эскалировать проблемы. Middle берет на себя технические решения в рамках своей зоны. Senior влияет на архитектуру, наставляет коллег и видит систему в целом — с точки зрения бизнеса и развития продукта.

Карта компетенций эталонного Java-разработчика

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



Вы можете скачать и сохранить для себя эту карту в PDF-формате по ссылке.

Сертификация: где иллюзии встречаются с реальностью

Чтобы понять, какие компетенции проседают, полезно пройти независимую сертификацию. Результаты порой удивляют даже очень опытных разработчиков.

По данным Учебного центра IBS за 2024 год:

Базовый уровень: 19 участников, 6 получили сертификат. Средний балл — 65%. Еще 6 человек набрали 60%+, но не дотянули до проходного порога в 70%.

Специалист (Middle): 5 участников, 2 получили сертификат. Средний балл — 61%.

Профессионал (Senior): 29 участников, 13 получили сертификат. Средний балл — 66,25%.

Средний балл по всем уровням — 66,92% при проходном 70%.



Где чаще всего ошибаются?

На базовом уровне — «Методы и инкапсуляция». Слишком много тонкостей, которые в работе всплывают не сразу.

На уровне «Специалист» — I/O, Java8 Date/Time API и многопоточность. Эти темы редко используют «на все 100%», но экзамен спрашивает глубоко.

На уровне «Профессионал» — работа с СУБД через JDBC. Она спрятана под капотом фреймворков, но иногда именно прямой доступ дает самое простое решение.

Как я обычно говорю: сертификация — зверь обманчиво простой. Люди думают: «Я пишу на Java, значит, знаю язык». На базовом уровне многие ходят в розовых очках и не подозревают, сколько в Java нюансов. Опыт работы не гарантирует сдачу экзамена. К нему нужно готовиться — решать сотни микрозадач, систематизировать знания, выходить за пределы повседневных задач.

Как устроена сертификация

Чтобы проверять знания системно, в IBS сертификация разбита на три уровня: «Базовый» (Basic), «Специалист» (Specialist) и «Продвинутый» (Advanced). Все экзамены опираются на возможности Java 11 — версии, которая до сих пор широко используется в корпоративной разработке.

Базовый уровень ориентирован на компетенции Junior-разработчика. По содержанию он примерно на 90% совпадает с международным экзаменом Oracle Certified Professional Java SE 11 Programmer I (1Z0-815): проверяются фундаментальные темы Java Core. При этом вопросы, связанные с модульной системой, появившейся начиная с Java 9, вынесены на следующий уровень.

Экзамен уровня «Специалист», рассчитанный на Middle-разработчиков, уже заметно шире классических «оракловых» экзаменов. В отличие от 1Z0-816 (OCP Java SE 11 Programmer II), который сосредоточен исключительно на Java Core, здесь дополнительно проверяются инструменты и фреймворки, с которыми разработчик реально работает в повседневной практике.

Несколько лет назад Oracle объединила экзамены 1Z0-815 и 1Z0-816 в один — 1Z0-819, фактически смешав темы уровней Associate и Professional. В нашей модели это разделение сохранено. Такой подход позволяет проверять знания постепенно и избегать ситуации, когда один экзамен превращается в изнурительную проверку «всего и сразу».

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

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

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

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

Полный список навыков и компетенций современного Java-разработчика

Уровень «Базовый»
Основы языка Java:

Определение области действия переменных.

Структура класса в Java.

Создание исполнимых Java-приложений с методом main(); запуск Java-программы с командной строки, в том числе вывод в консоль.

Импорт Java-пакетов.

Сравнение и противопоставление таких характеристик языка Java, как платформенная независимость, объектно-ориентированный характер, инкапсуляция и другие.

Типы данных:

Объявление и инициализация переменных, включая приведение примитивных типов данных.

Дифференциация между ссылочными и примитивными переменными.

Чтение и запись полей объектов.

Жизненный цикл объекта (создание, переприсваивание ссылки и сборка мусора).

Разработка кода, использующего классы-оболочки, в частности Boolean, Double и Integer.

Операторы и структуры ветвления:

Применение операторов, включая переопределение приоритета.

Проверка идентичности строковых и др.объектов с использованием оператора == и метода equals().

Конструкции if и if-else, а также тернарный оператор.

Применение оператора switch.

Создание и применение массивов:

Объявление, инстанциация и применение одномерных массивов.

Объявление, инстанциация и применение многомерных массивов.

Работа с циклами:

Создание и применение циклов while.

Создание и применение циклов for, в том числе for-each.

Создание и применение циклов do-while.

Сравнение циклических конструкций.

Применение операторов break и continue.

Методы и инкапсуляция:

Создание методов, которые принимают аргументы и возвращают значения.

Создание и применение перегруженных методов.

Поведение объектных ссылок и примитивных переменных, передаваемых в методы.

Применение ключевого слова static к методам и полям.

Применение модификаторов доступа (public, protected, private) и реализация принципов инкапсуляции в классе.

Создание и перегрузка конструкторов, включая влияние на дефолтный конструктор.

Наследование:

Наследование и его преимущества.

Разработка кода, демонстрирующего полиморфизм, включая переопределение методов и противопоставление объектного типа ссылочному.

Необходимость в приведении типов.

Применение ключевых слов super и this для доступа к объектам и конструкторам.

Применение интерфейсов и абстрактных классов.

Обработка исключений:

Противопоставление контролируемых исключений неконтролируемым, в том числе ошибкам.

Создание блока try-catch и влияние исключений на штатный алгоритм работы программы.

Преимущества обработки исключений.

Создание и вызов метода, возбуждающего исключение.

Работа с типичными классами исключений (в частности, NullPointerException, ArithmeticException, ArrayIndexOutOfBoundsException, ClassCastException).

Избранные классы библиотеки Java API:

Манипуляция данными посредством класса StringBuilder и его методов.

Создание и манипуляция String-объектами.

Работа с календарными датами посредством классов java.time.LocalDate и java.time.LocalDateTime .

Объявление и применение коллекций ArrayList заданного типа.

Составление простого лямбда-выражения, которое потребляет Predicate.

Уровень «Специалист»
Углубленный дизайн Java-классов:

Создание внутренних классов, в том числе статических, нестатических, локальных и анонимных.

Перечисляемые типы, их методы и конструкторы.

Переопределение методов hashCode(), equals() и toString() из класса java.lang.Object.

Статические и дефолтные методы в интерфейсах.

Настраиваемые дата-типы (Generics) и коллекции:

Параметризация переменных, классов и интерфейсов, в т.ч. и .

Интерфейсы java.util.Comparator, java.lang.Comparable и параметризация коллекций.

Интерфейсные пересечения.

Лямбда-выражения, встроенные функциональные интерфейсы и Stream API:

Применение интерфейсов из java.util.function (Predicate, Consumer, Function, BiFunction, Supplier и т. д.).

Создание и применение ссылок на методы.

Извлечение и обработка данных посредством методов map() и flatMa(), в том числе их примитивных специализаций.

Методы findFirst(), anyMatch(), allMatch(), max()/min() и reduce(), включая применение Optional.

Сортировка коллекций с применением Stream API.

Сохранение результата, партицирование и классификация данных на группы с помощью класса Collectors.

Исключения и проверка инвариантов:

Конструкции для перехвата одного или нескольких исключений.

Конструкция «try с ресурсами», в т.ч. создание пользовательских исключений с AutoCloseable-ресурсами.

Проверка инвариантов посредством оператора assert.

Java SE 8 Date/Time API:

Работа с датами и временем в различных часовых поясах, в том числе с учетом перехода на летнее/зимнее время; форматирование календарных дат и времени.

Создание и управление событиями с привязкой к дате и времени посредством классов Instant, Period, Duration и TemporalUnit.

Основы Java Concurrency:

Создание рабочих подпроцессов (threads) на базе Runnable- и Callable-объектов.

Применение интерфейса ExecutorService для параллельного исполнения задач в пулах подпроцессов.

Применение ключевого слова synchronized к методам и критическим секциям.

Применение классов CyclicBarrier и AtomicInteger.

Создание и применение потокобезопасных коллекций (в частности, с помощью CopyOnWriteArrayList).

Основы ввода/вывода в Java:

Чтение и запись через консоль, применение классов File, BufferedReader/Writer, FileReader/Writer, FileInput/OutputStream и PrintWriter из пакета java.io.

Интерфейс java.io.Serializable и применение классов ObjectOutputStream и ObjectInputStream для сериализации и десериализации объектов.

Применение интерфейса Path и класса Files для работы с файлами и папками, в том числе управление метаданными.

Локализация:

Создание и изменение локали с помощью Locale-объекта.

Создание и чтение Properties-файла.

Формирование ResourceBundle-объекта для конкретной локали и загрузка таких ресурсов в приложение.

Основы git и сборка проектов с помощью Maven:

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

Создание, переключение, слияние веток и перебазирование в Git.

Описание и управление зависимостями в Maven, в том числе транзитивными.

Этапы и цели жизненных циклов Maven.

Работа с удаленным и локальным репозиториями Maven.

Работа с Maven-архетипами и плагинами.

Наследование, Effective POM и многомодульные Maven-проекты.

Основы работы с базами данных:

Индексы, первичные и внешние ключи, SQL-запросы и CRUD-операции.

Использование SELECT для извлечения данных.

Нормализация таблиц и ограничения в базах данных.

Объединение данных таблиц с помощью JOIN в SQL.

Типы данных для хранения строк и изображений в базе данных.

Интерфейсы, лежащие в основе JDBC, в частности Driver, Connection, Statement и ResultSet, и их связь с имплементацией вендором базы данных.

Компоненты, необходимые для подключения к базе данных с использованием класса DriverManager, в том числе JDBC URL.

Формирование запросов и чтение результатов из базы данных, в том числе создание и надлежащее закрытие ResultSet-, Statement- и Connection-объектов, а также итерация по результатам.

Основы работы со Spring и модулем Spring Boot:

Фреймворк Spring и внедрение зависимостей.

Конфигурирование Spring с помощью properties, YAML, Java-конфигурация.

Использование и активация профилей Spring.

Аннотации Spring, такие как @SpringBootApp, @Configuration и @Autowired.

Spring Data и JPA, включая классы сущностей, репозитории, сервисы и контроллеры.

Работа с транзакциями в Spring, применение аннотации @Transactional и откат транзакций.

Работа с базой данных в Spring, включая подключение базы данных и конфигурацию.

Работа с Spring Boot, включая зависимости pom-файлов и свойства приложения.

Аннотации @Controller, @RestController и @RequestMapping.

Основы работы с JPA/Hibernate и Spring Data:

JPA (Java Persistence API) и его аннотации, такие как @Entity, @Table и @Id.

Мэппинг между объектами и таблицами в JPA, включая использование аннотаций @OneToMany, @ManyToOne и @ManyToMany, а также использование mappedBy для указания владельца отношения.

Spring Data JPA и его функции, такие как интерфейсы репозитория, аннотации @Query и @Modifying.

Стратегии загрузки в JPA, включая нетерпеливую (eager) и ленивую (lazy) загрузку.

Стратегии предотвращения проблемы N+1, такие как использование JOIN FETCH в запросах JPQL.

Языки запросов JPA, включая JPQL (Java Persistence Query Language) и SQL.

Параметризация JPQL-запроса.

Механизмы блокировки JPA, включая оптимистическую блокировку с аннотацией @Version.

Основы работы со Spring REST:

Сопоставление запросов на основе аннотаций в Spring (@PostMapping, @GetMapping…), в том числе передача параметров (@PathVariable, @RequestParam…).

Коды состояния HTTP и их значения, например состояние 200 для успешного запроса.

Кэшируемость и отслеживание состояния REST-запросов.

Заголовки HTTP и их роли в REST-коммуникациях, такие как Cache-Control для кэширования и Content-Type для указания формата запроса или ответа.

Обработка исключений в Spring, включая использование @ControllerAdvice и @ExceptionHandler.

Сериализация и десериализация данных, в том числе использование @RequestBody и @ResponseBody.

Основы модульного тестирования на базе JUnit (версии 4 и 5):

Наиболее употребительные методы класса Assert (JUnit4) и Assertions (JUnit5).

Аннотации @Test, @Ignore/@Disabled, @Before/@BeforeEach, @BeforeClass/@BeforeAll, @Nested, @Suite.

Параметризуемые модульные тесты.

Создание и применение тестовых комплектов (test suites).

Модульная система в Java:

Принципы функционирования модульной системы в Java.

Структура и особенности модуляризованного JDK.

Декларация модулей и предоставление доступа.

Компиляция и запуск модуляризованного проекта.

Уровень «Продвинутый»
Продвинутые вопросы Java Concurrency:

Выявление потенциальных проблем многопоточного режима, в том числе взаимная блокировка (deadlock), зависание по недоступу к ресурсу (starvation), взаимная блокировка с зацикливанием (livelock), состояние гонки (race condition).

Применение CountDownLatch и Semaphore.

Организация параллелизма на базе Fork/Join Framework.

Модульное тестирование в связке c Mockito:

Принципы и разновидности мокирования (dummy objects, test stubs, test spies, fake objects).

Аннотации @Mock и @InjectMocks.

Методы when(), thenReturn(), verify(), doReturn(), doThrow(), doAnswer(), doNothing(), doCallRealMethod().

Продвинутые вопросы применения REST-сервисов:

Масштабирование и отказоустойчивость REST-сервисов.

Обработка ошибок и работа с исключениями при использовании REST-сервисов.

Кэширование HTTP для REST-сервисов, заголовки кэширования.

Валидация данных.

Сериализация данных в формат JSON, настройка Jackson, дополнительные инструменты (MapStruct).

Уровни зрелости REST-сервисов, самодокументирование сервисов с помощью HATEOAS.

Аннотация @CrossOrigin и ее роль в настройке совместного использования ресурсов.

Версионирование и проблема потерянных обновлений.

Документирование с помощью OpenAPI/Swagger.

Подходы и паттерны разработки микросервисов на Java:

Принципы архитектуры микросервисов и лучшие практики.

Декомпозиция на микросервисы в Java.

Обнаружение и регистрация сервисов.

Балансировка нагрузки.

Управление данными и согласованность данных в распределенных системах.

Мониторинг и логирование в микросервисах на Java.

Безопасность и аутентификация в микросервисах на Java.

Развертывание и масштабирование микросервисов в Java.

Оркестрация микросервисов.

Коммуникация микросервисов, синхронная и асинхронная.

CAP-теорема.

Шаблон API-шлюза.

Шаблон автоматического выключателя.

Шаблон CQRS (разделение ответственности за запросы команд).

Шаблон Сага.

Брокеры сообщений:

Виды коммуникации в брокерах сообщений: «точка-точка» и «публикация-подписка».

Преимущества использования брокера сообщений в распределенной системе.

Архитектуры брокеров сообщений: централизованная, децентрализованная и гибридная.

Протоколы брокера сообщений: AMQP, MQTT, JMS и другие.

Брокеры сообщений Kafka, RabbitMQ, ActiveMQ.

Постоянство (persistence) и долговечность (durability) сообщений.

Семантика доставки сообщений: не более одного раза, не менее одного раза и ровно один раз.

Маршрутизация и фильтрация сообщений.

Сравнение различных брокеров сообщений и вариантов их использования.

Интеграция брокеров сообщений с другими системами и технологиями.

Лучшие практики и шаблоны проектирования для эффективного использования брокеров сообщений.

Группы потребителей в Kafka, партиции в Kafka.

Продвинутые вопросы применения Spring:

Аспектно-ориентированное программирование в Spring.

Мониторинг приложения с помощью Spring Actuator.

Асинхронное программирование в Spring, использование CompletableFuture.

Реактивное программирование в Spring, применение WebFlux.

Тестирование Spring-приложений.

Жизненный цикл Spring-бинов.

Распространение транзакций в Spring.

Безопасность для REST-сервисов с помощью Spring Security:

Процессы, методы и технологии аутентификации и авторизации.

Платформа Spring Security и ее функции, такие как внедрение зависимостей, фильтры сервлетов и декларативная безопасность.

JWT (веб-токен JSON) и его использование для безопасной связи и авторизации.

Базовая HTTP-аутентификация и ее особенности.

CORS (Cross-Origin Resource Sharing) и его роль в ограничениях безопасности и доступа к данным.

Сертификаты HTTPS (защищенный протокол передачи гипертекста) и SSL (уровень защищенных сокетов) и их роль в безопасной связи.

Технологии шифрования и их использование в целях безопасности, такие как шифрование с открытым ключом и проверка подписи.

Декларативные функции безопасности Spring Security, такие как безопасность на основе URL, безопасность на основе методов и безопасность на основе объектов домена.

Обработка ошибок Spring Security и управление исключениями.

Принципы создания безопасного кода:

Разработка кода с учетом DoS-атак, инжекций, характера вводимой информации и требований к целостности данных.

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

Принципы SOLID и шаблоны проектирования:

Содержание принципов SOLID.

Выявление кода, нарушающего принципы SOLID.

Шаблоны: Factory, Builder, Strategy, Bridge, Adapter, Decorator, Command, Observer и Visitor.

Базовые аспекты настройки и мониторинга HotSpot JVM:

Стратегии сборки мусора, Minor / Major GC, STW-паузы.

Слабая гипотеза поколений.

Элементы корневого набора GC.

Основные особенности алгоритмов сборки мусора в Serial, Parallel / Throughput, CMS и G1 GC.

Журналирование GC.

Многоуровневая JIT-компиляция, виды JIT-оптимизаций.

Журналирование JIT-операций.

Утилиты jcmd и jstat; cоздание дампов памяти и подпроцессов.

Признаки утечек памяти, общие подходы к их выявлению с помощью jVisualVM, JMC/JFR.

Бонус: список литературы для подготовки к сертификации:
1. Хабибуллин И. Ш. «Java 7».
2. Кей Хорстманн «Java. Базовый курс»
3. Кэти Сьерра, Берт Бейтс «Подготовка к экзамену OCA Java SE 8 Programmer I».
4. Баладжи Варанаси, Судха Белида «Введение в Maven».
5. Скотт Чакон, Бен Штрауб «Git для профессионального программиста», 2-е издание.
6. Амутан Г. «Spring MVC для начинающих».
7. Фелипе Гутьеррес «Профессиональная разработка на Spring Boot 2» («Pro Spring Boot 2»), 2-е издание.
8. Джефф Линвуд, Дэйв Минтер «Hibernate: от новичка до профессионала» (“Beginning Hibernate»), 2-е издание.
9. Франк Аппель «Тестирование с JUnit».
10. Саймон Робертс «Подготовка к экзамену OCA Java SE 7 Programmer (1Z0-803). Видеокурс».
11. Брайан Гётц и др. «Java Concurrency на практике». 12. Мала Гупта. «Java 11 и Новые возможности».
12. Бенджамин Эванс и др. «Java для опытных разработчиков» («The Well-Grounded Java Developer»).
13. Джон Карнелл и др. «Микросервисы Spring в действии».
14. Лауренциу Спилкэ «Spring Security в действии».
15. Якуб Кораб «Понимание брокеров сообщений» («Understanding Message Brokers»).
16. Юсуф Айташ и др. «Освоение RabbitMQ» («Mastering RabbitMQ»).
17. Мирослав Венгнер «Практические шаблоны проектирования для Java-разработчиков».
18. Лауренциу Спилкэ «Java: устранение проблем» («Troubleshooting Java»).

Вместо заключения

Дорожная карта — это не список тем, а способ честно ответить себе на вопрос: «Где я сейчас и что дальше?». Java-экосистема огромна, и в ней легко застрять на комфортном уровне. Но рост начинается там, где заканчивается иллюзия «я и так все знаю» и появляется системное понимание языка, платформы и архитектуры.
Оригинал статьи на Хабре.