Почти каждый разработчик рано или поздно задается вопросом: «Я уже 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-экосистема огромна, и в ней легко застрять на комфортном уровне. Но рост начинается там, где заканчивается иллюзия «я и так все знаю» и появляется системное понимание языка, платформы и архитектуры.

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