Система модулей Java

Description

Предисловие Часть I. Привет, модули Глава 1. Первый элемент головоломки 1.1. Что такое модульность 1.1.1. Визуализация ПО в виде графов 1.1.2. Влияние принципов проектирования 1.1.3. Что такое модульность 1.2. Уничтожение модулей до Java 9 1.3. Трудности до Java 9 1.3.1. Невыраженные зависимости между JAR-файлами 1.3.2. Затенение классов с одинаковыми именами 1.3.3. Конфликты разных версий на одном проекте 1.3.4. Сложная загрузка класса 1.3.5. Слабая инкапсуляция в JAR-файлах 1.3.6. Проверки безопасности должны быть сделаны вручную 1.3.7. Низкая производительность при запуске 1.3.8. Негибкое время выполнения в Java 1.4. Взгляд на модули с высоты птичьего полета 1.4.1. Все на свете — это модули 1.5. Ваш первый модуль 1.5.1. Система модулей в действии 1.5.2. Ваш немодульный проект будет в порядке — в целом 1.6. Цели системы модулей 1.6.1. Надежная настройка: не оставлять после себя JAR 1.6.2. Надежная инкапсуляция: делаем внутренний код модуля недоступным 1.6.3. Автоматическая безопасность и улучшенное удобство сопровождения 1.6.4. Улучшенная производительность при запуске 1.6.5. Масштабируемая платформа Java 1.6.6. Не цели 1.7. Навыки, старые и новые 1.7.1. Чему вы научитесь 1.7.2. Что нужно знать Резюме Глава 2. Структура модульного приложения 2.1. Знакомство с ServiceMonitor 2.2. Модуляризация ServiceMonitor 2.3. Разделение ServiceMonitor на модули 2.4. Организация файлов в структуре каталогов 2.5. Объявление и описание модулей 2.5.1. Объявление зависимостей от других модулей 2.5.2. Объявление публичных API модуля 2.5.3. Визуализация ServiceMonitor с помощью модульного графа 2.6. Компиляция и упаковка модулей 2.7. Запуск ServiceMonitor 2.8. Расширение модульной кодовой базы 2.9. Разбор полетов: эффекты системы модулей 2.9.1. Что система модулей делает для вас 2.9.2. Что еще модульная система может сделать для вас 2.9.3. Добавление необязательных зависимостей Резюме Глава 3. Определение модулей и их свойств 3.1. Модули: строительные блоки модульных приложений 3.1.1. Модули Java (JMOD), поставляемые с JDK 3.1.2. Модульные файлы JAR: доморощенные модули 3.1.3. Декларация модулей: определение свойств модулей 3.1.4. Множество типов модулей 3.2. Читабельность: соединяем части вместе 3.2.1. Достижение надежной настройки 3.2.2. Эксперименты с ненадежными настройками 3.3. Доступность: объявление публичных API 3.3.1. Обеспечение надежной инкапсуляции 3.3.2. Инкапсуляция переходных зависимостей 3.3.3. Столкновения инкапсуляций 3.4. Путь модуля: позвольте Java узнать о модулях 3.4.1. Регулирование модулей: анализ и верификация структуры приложения 3.4.2. Граф модуля: представление архитектуры приложения 3.4.3. Добавление модулей в граф 3.4.4. Добавление ребер в граф 3.4.5. Доступность — постоянное усилие Резюме Глава 4. Построение модулей от исходного кода до JAR 4.1. Структурирование проекта с помощью каталогов 4.1.1. Новое предложение — новое соглашение? 4.1.2. Созданная структура каталогов 4.1.3. Место для деклараций модулей 4.2. Компиляция отдельного модуля 4.2.1. Компиляция модульного кода 4.2.2. Модульное или немодульное? 4.3. Компиляция нескольких модулей 4.3.1. Безыскусный подход 4.3.2. Путь к исходнику модуля: информирование компилятора о структуре проекта 4.3.3. Звездочка как токен для имени модуля 4.3.4. Несколько путей к исходникам модулей 4.3.5. Настройка начального модуля 4.3.6. Стоит ли оно того? 4.4. Параметры компилятора 4.5. Упаковка модульного JAR-файла 4.5.1. Быстрый обзор jar 4.5.2. Анализ JAR 4.5.3. Объявление точки входа 4.5.4. Параметры архиватора Резюме Глава 5. Запуск и отладка модульных приложений 5.1. Запуск JVM с модулями 5.1.1. Определение основного класса 5.1.2. Что если начальный модуль и основной модуль — не один и тот же 5.1.3. Передача параметров приложению 5.2. Загрузка ресурсов из модулей 5.2.1. Загрузка ресурсов до Java 9 5.2.2. Загрузка ресурсов начиная с Java 9 и позже 5.2.3. Загрузка ресурсов за пределами модуля 5.3. Отладка модулей и модульных приложений 5.3.1. Анализ отдельных модулей 5.3.2. Проверка набора модулей 5.3.3. Проверка модульного графа 5.3.4. Перечисление обозреваемых модулей и зависимостей 5.3.5. Исключение модулей во время разрешения 5.3.6. Наблюдение за системой модулей с помощью ведения журнала 5.4. Параметры виртуальной машины Java Резюме Часть II. Адаптация под реальные проекты Глава 6. Проблемы совместимости при переходе на Java 9 и выше 6.1. Работа с модулями JEE 6.1.1. Что особенного в модулях JEE? 6.1.2. Разрешение модулей JEE вручную 6.1.3. Вмешиваемся в сторонние реализации модулей JEE 6.2. Приведение к URLClassLoader 6.2.1. Загрузчики классов приложения, тогда и сейчас 6.2.2. Обходимся без URLClassLoader 6.2.3. Поиск проблемных приведений 6.3. Обновленный макет каталога образов выполнения 6.4. Выбор, замена и расширение платформы 6.4.1. Компактных профилей больше нет 6.4.2. Удален механизм расширения 6.4.3. Удален механизм переопределения утвержденных стандартов 6.4.4. Удалены некоторые параметры пути к загрузочному классу 6.4.5. Компиляции для Java 5 больше нет 6.4.6. Удален выбор версии JRE 6.5. Мелочи, которые приводят к большим неприятностям 6.5.1. Новый формат версий 6.5.2. Исчезновение инструментов 6.5.3. Всякие мелочи 6.5.4. Новые устаревшие элементы в Java 9, 10 и 11 Резюме Глава 7. Повторяющиеся проблемы при переходе на Java 9 и выше 7.1. Инкапсуляция внутренних API 7.1.1. Внутренние API под микроскопом 7.1.2. Анализ зависимостей с помощью JDeps 7.1.3. Компиляция с помощью внутренних API 7.1.4. Выполнение с помощью внутренних API 7.1.5. Параметры компилятора и JVM для доступа к внутренним API 7.2. Улучшение разделенных пакетов 7.2.1. Что не так с разделенными пакетами 7.2.2. Эффекты разделенных пакетов 7.2.3. Множество способов справиться с разделенными пакетами 7.2.4. Исправление модулей: последнее средство для обработки разделенных пакетов 7.2.5. Поиск разделенных пакетов с помощью JDeps 7.2.6. Примечание о конфликте версий зависимостей Резюме Глава 8. Постепенная модуляризация существующих проектов 8.1. Почему наращивание модульности необязательно 8.1.1. Если бы каждый JAR должен был быть модульным 8.1.2. Смешивание и соединение простых JAR-файлов с модулями 8.1.3. Технические основы наращиваемой модульности 8.2. Безымянный модуль, он же путь к классу 8.2.1. Хаос пути к классам, захваченный безымянным модулем 8.2.2. Разрешение модулей для безымянного модуля 8.2.3. Зависимость от безымянного модуля 8.3. Автоматические модули: простые JAR в пути модуля 8.3.1. Имена автоматических модулей: мелочь, имеющая большое значение 8.3.2. Разрешение модулей для автоматических модулей 8.3.3. Все в автоматических модулях? 8.3.4. Зависимость от автоматических модулей Резюме Глава 9. Стратегии миграции и модуляризации 9.1. Стратегии миграции 9.1.1. Подготовительные обновления 9.1.2. Оценка усилий 9.1.3. Непрерывная интеграция в Java 9+ 9.1.4. Мысли о параметрах командной строки 9.2. Стратегии модуляризации 9.2.1. Восходящая модуляризация: когда все зависимости — модульные 9.2.2. Нисходящая модуляризация: когда нет времени дожидаться всех зависимостей 9.2.3. Модуляризация изнутри наружу: если проект находится в середине стека 9.2.4. Применение данных стратегий к проекту 9.3. Делаем JAR-файлы модульными 9.3.1. Открытые модули как промежуточный шаг 9.3.2. Генерация модульных деклараций с помощью JDeps 9.3.3. Взлом сторонних JAR-файлов 9.3.4. Публикация модульных JAR-файлов для Java 8 и выше Резюме Часть III. Расширенные функции системы модулей Глава 10. Использование сервисов для разделения модулей 10.1. Изучение потребности в сервисах 10.2. Сервисы в модульной системе платформы Java 10.2.1. Использование, предоставление и потребление услуг 10.2.2. Разрешение модулей для сервисов 10.3. Эффективное проектирование сервисов 10.3.1. Типы, которые могут стать сервисами 10.3.2. Использование фабрик в качестве сервисов 10.3.3. Изоляция потребителей от глобального состояния 10.3.4. Организация сервисов, потребителей и поставщиков в модули 10.3.5. Использование сервисов для разбиения циклических зависимостей 10.3.6. Объявление сервисов в разных версиях Java 10.4. Доступ к сервисам с помощью ServiceLoader API 10.4.1. Загрузка и доступ к сервисам 10.4.2. Особенности загрузки сервисов Резюме Глава 11. Уточнение API и зависимостей 11.1. Подразумеваемая читабельность: передача зависимостей 11.1.1. Выявление зависимостей модуля 11.1.2. Модификатор transitive: подразумеваемая читабельность зависимости 11.1.3. Когда использовать подразумеваемую читабельность 11.1.4. Когда стоит полагаться на подразумеваемую читабельность 11.1.5. Рефакторинг модулей с подразумеваемой читабельностью 11.1.6. Рефакторинг модулей путем их слияния 11.2. Необязательные зависимости 11.2.1. Загадка надежной конфигурации 11.2.2. Модификатор static: маркировка зависимостей как необязательных 11.2.3. Разрешение модулей для необязательных зависимостей 11.2.4. Написание кода с необязательной зависимостью 11.3. Квалифицированный экспорт: ограничение доступа к конкретным модулям 11.3.1. Предоставление внутренних API 11.3.2. Экспорт пакетов в модули 11.3.3. Когда использовать квалифицированный экспорт 11.3.4. Экспорт пакетов в командной строке Резюме Глава 12. Рефлексия в модульном мире 12.1. Почему директивы exports не подходят для рефлексии 12.1.1. Врываемся в немодульный код 12.1.2. Принудительная публикация внутренних типов 12.1.3. Квалифицированный экспорт создает связь с определенными модулями 12.1.4. Нет поддержки глубокой рефлексии 12.2. Открытые пакеты и модули: предназначены для использования с рефлексией 12.2.1. Открытие пакетов для доступа в режиме выполнения 12.2.2. Открытие пакетов для определенных модулей 12.2.3. Экспорт и открытие пакетов 12.2.4. Открытие модулей: закрытие рефлексии 12.3. Рефлексия модулей 12.3.1. Обновление рефлективного кода для модулей (или нет) 12.3.2. Использование обработчика переменных вместо рефлексии 12.3.3. Анализ свойств модуля с помощью рефлексии 12.3.4. Изменение свойств модуля с помощью рефлексии 12.3.5. Пересылка открытых пакетов 12.4. Динамическое создание диаграмм модулей со слоями 12.4.1. Что такое слои 12.4.2. Анализ слоев 12.4.3. Создание модульных слоев Резюме Глава 13. Версии и модули: возможное и невозможное 13.1. Отсутствие поддержки версий в JPMS 13.1.1. Нет поддержки нескольких версий 13.1.2. Нет поддержки выбора версии 13.1.3. Что может принести будущее 13.2. Запись информации о версии 13.2.1. Запись версий при сборке модулей 13.2.2. Доступ к версиям модуля 13.3. Запуск нескольких версий модуля в отдельных слоях 13.3.1. Зачем нужен стартер для раскрутки дополнительных слоев 13.3.2. Раскручивание слоев для вашего приложения, Apache Twill и Cassandra Java Driver Резюме Глава 14. Настройка образа выполнения с помощью jlink 14.1. Создание пользовательских образов выполнения 14.1.1. Начало работы с jlink 14.1.2. Содержание и структура образа 14.1.3. Включение сервисов в образы времени выполнения 14.1.4. Правильно подобранные образы с помощью jlink и jdeps 14.2. Создание автономных образов приложений 14.2.1. Включение модулей приложений в образы 14.2.2. Создание собственного средства запуска приложения 14.2.3. Безопасность, производительность и стабильность 14.3. Генерация образов в операционных системах 14.4. Использование плагинов jlink для оптимизации образов 14.4.1. Плагины для jlink 14.4.2. Уменьшение размера образа 14.4.3. Улучшение производительности во время выполнения 14.5. Параметры для jlink Резюме Глава 15. Собираем все вместе 15.1. Добавляем навороты в ServiceMonitor 15.1.1. Разнообразные зависимости 15.1.2. Снижение видимости 15.1.3. Отделение от сервисов 15.1.4. Загрузка кода со слоями во время выполнения 15.1.5. Обработка зависимостей от простых JAR-файлов 15.2. Советы для разработчиков модульных приложений 15.2.1. Модуль или нет? 15.2.2. Идеальный модуль 15.2.3. Позаботьтесь о декларациях модуля 15.2.4. Взлом кода путем редактирования модульных деклараций 15.3. Технологический ландшафт 15.3.1. Maven, Gradle и другие инструменты сборки 15.3.2. OSGi 15.3.3. Микросервисы 15.4. Мысли о модульной экосистеме Резюме Приложения Приложение А. Резюмируем путь класса A.1. Использование пути к классам для загрузки JAR-файлов приложений A.2. Путь к классам начиная с Java 9 Приложение Б. Высокоуровневое введение в API рефлексии Б.1. Основные типы и методы Б.2. Взлом API с помощью setAccessible Б.3. Аннотации помечают код для рефлексии Приложение В. Наблюдение за JVM с унифицированным ведением журнала В.1. Что такое унифицированное ведение журнала В.2. Определяем, какие сообщения должны отображаться В.3. Определяем, куда вывести сообщения В.4. Определяем, что выводить в сообщениях В.5. Настройка всего конвейера регистрации Приложение Г. Анализ зависимостей проекта с помощью JDeps Г.1. Знакомство с JDeps Г.2. Добавление зависимостей в анализ Г.3. Настройка вывода JDeps Г.4. Детализация в зависимости от вашего проекта Г.5. JDeps понимает модули Приложение Д. Ориентация на несколько версий Java с мультиверсионными JAR-файлами Д.1. Создание мультиверсионного JAR Д.2. Внутренняя работа МВ-JAR Д.3. Рекомендации по использованию Д.3.1. Организация исходного кода Д.3.2. Организация байт-кода Д.3.3. Когда использовать МВ-JAR Пролог Благодарности О книге Кому стоит прочитать эту книгу Структура книги Части и главы Выберите собственный путь Предостережение О коде О версии Java Оформление листингов Оформление имен методов Заместители во фрагментах кода Команды и их вывод Дискуссионный форум liveBook От издательства Об авторе Об обложке