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

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

Привет! Меня зовут Любовь Кулева, я руководитель отдела разработки и методологии Учебного центра IBS. В 2025 году мы выпустили три полноценные «дорожные карты развития» — для системного аналитика, для архитектора ПО и для бизнес-аналитика. В этой статье поговорим про джавистов: что на самом деле стоит за грейдами и какие компетенции формируют профессионала на каждом этапе.

Ключевые направления развития 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) и коллекции:

• Параметризация переменных, классов и интерфейсов, в т.ч. <? extends T> и <? super T>.
• Интерфейсы java.util.Comparator<T>, java.lang.Comparable<T> и параметризация коллекций.
• Интерфейсные пересечения.

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

• Применение интерфейсов из java.util.function (Predicate, Consumer, Function, BiFunction, Supplier и т. д.).
• Создание и применение ссылок на методы.
• Извлечение и обработка данных посредством методов map() и flatMa(), в том числе их примитивных специализаций.
• Методы findFirst(), anyMatch(), allMatch(), max()/min() и reduce(), включая применение Optional<T>.
• Сортировка коллекций с применением 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. Новые возможности».
13. Бенджамин Эванс и др. «Java для опытных разработчиков» («The Well-Grounded Java Developer»).
14. Джон Карнелл и др. «Микросервисы Spring в действии».
15. Лауренциу Спилкэ «Spring Security в действии».
16. Якуб Кораб «Понимание брокеров сообщений» («Understanding Message Brokers»).
17. Юсуф Айташ и др. «Освоение RabbitMQ» («Mastering RabbitMQ»).
18. Мирослав Венгнер «Практические шаблоны проектирования для Java-разработчиков».
19. Лауренциу Спилкэ «Java: устранение проблем» («Troubleshooting Java»).

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

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

А что вы считаете самым важным навыком для джависта? Делитесь в комментариях!

Источник