Java 9 – co nowego w modularności

Dlaczego modularność w Java 9 to przełom?

System modułów w Java 9 rozwiązuje problemy, z którymi programiści borykają się od lat. Obecnie każdy jar jest dostępny dla całej aplikacji, co prowadzi do „JAR hell” – konfliktów wersji bibliotek. Modularność wprowadza kontrolowaną widoczność i wymuszone deklarowanie zależności, co znacznie poprawia bezpieczeństwo i maintenance kodu.

System modułów Java (JPMS) – podstawowe koncepcje

Java Platform Module System (JPMS) wprowadza nowy poziom abstrakcji powyżej pakietów. Moduł to pojemnik na powiązane pakiety i zasoby, który:

• Enkapsuluje implementację – tylko wyeksportowane pakiety są dostępne
• Deklaruje zależności – wymuszone określenie wymaganych modułów
• Zapewnia silne enkapsulację – reflection nie omija granic modułów

Struktura pliku module-info.java

Każdy moduł musi zawierać plik module-info.java w głównym katalogu źródeł:

// src/main/java/module-info.java
module com.mycompany.userservice {
    // Eksportujemy pakiety dostępne dla innych modułów
    exports com.mycompany.userservice.api;
    exports com.mycompany.userservice.dto;
    
    // Wymagamy innych modułów
    requires java.base;          // automatycznie dodawane
    requires java.sql;
    requires com.mycompany.commons;
    
    // Opcjonalne zależności
    requires static lombok;       // compile-time only
    requires transitive gson;     // propaguje zależność
}

Tworzenie pierwszego modułu

Stwórzmy praktyczny przykład modularnej aplikacji z dwoma modułami:

Moduł commons (współdzielone utility)

// commons/src/main/java/module-info.java
module com.example.commons {
    exports com.example.commons.utils;
    exports com.example.commons.model;
}

// commons/src/main/java/com/example/commons/utils/StringUtils.java
package com.example.commons.utils;

public class StringUtils {
    public static boolean isNotEmpty(String str) {
        return str != null && !str.trim().isEmpty();
    }
    
    // Ta metoda NIE będzie dostępna z zewnątrz
    // bo pakiet internal nie jest exported
    static void internalMethod() {
        System.out.println("Internal utility");
    }
}

Moduł application (główna aplikacja)

// app/src/main/java/module-info.java
module com.example.application {
    requires com.example.commons;
    requires java.base;  // implicit, ale można dodać explicit
    
    // Ten moduł nie eksportuje niczego - to aplikacja końcowa
}

// app/src/main/java/com/example/application/Main.java
package com.example.application;

import com.example.commons.utils.StringUtils;

public class Main {
    public static void main(String[] args) {
        String input = "Hello Java 9 Modules!";
        
        if (StringUtils.isNotEmpty(input)) {
            System.out.println("Input is valid: " + input);
        }
        
        // To nie skompiluje się - metoda internal nie jest dostępna
        // StringUtils.internalMethod(); // BŁĄD KOMPILACJI
    }
}

Dyrektywy module-info.java – pełna lista

Service Provider Interface (SPI) w modułach

Java 9 ułatwia implementację wzorca SPI:

// Moduł API
module database.api {
    exports com.example.database.api;
}

// Interface
public interface DatabaseDriver {
    Connection connect(String url);
}

// Moduł implementacji
module database.mysql {
    requires database.api;
    provides com.example.database.api.DatabaseDriver 
        with com.example.database.mysql.MySQLDriver;
}

// Moduł klienta
module my.application {
    requires database.api;
    uses com.example.database.api.DatabaseDriver;
}

// Użycie w kodzie
ServiceLoader loader = ServiceLoader.load(DatabaseDriver.class);
DatabaseDriver driver = loader.findFirst().orElseThrow();

Narzędzia do pracy z modułami

jdeps – analiza zależności

Narzędzie jdeps pomaga w analizie istniejącego kodu i przygotowaniu do modularyzacji:

# Sprawdź zależności JAR-a
jdeps myapp.jar

# Sugerowane moduły dla istniejącego kodu
jdeps --generate-module-info . myapp.jar

# Sprawdź czy kod korzysta z internal JDK APIs
jdeps --jdk-internals myapp.jar

jlink – tworzenie runtime image

Nowe narzędzie jlink pozwala tworzyć minimalne runtime obrazy:

# Tworzenie custom runtime z tylko potrzebnymi modułami
jlink --module-path $JAVA_HOME/jmods:lib \
      --add-modules com.example.application \
      --output myapp-runtime \
      --launcher myapp=com.example.application/com.example.application.Main

# Rezultat - folder z kompletną, minimalną JVM + aplikacja
./myapp-runtime/bin/myapp

Migracja istniejących projektów

Strategia postupowa migracji

Nie musisz modularyzować całej aplikacji od razu. Java 9 wspiera trzy rodzaje „modułów”:

Krok po kroku: modularyzacja Maven projektu

    9
    9



    
        
            org.apache.maven.plugins
            maven-compiler-plugin
            3.6.1
            
                9
                9
            
        
    

Typowe problemy podczas migracji

// PROBLEM: ten sam pakiet w dwóch modułach
// modul1: com.example.utils.StringHelper
// modul2: com.example.utils.NumberHelper

// ROZWIĄZANIE: przenieś do osobnych pakietów
// modul1: com.example.string.StringHelper  
// modul2: com.example.number.NumberHelper

Best practices dla modularności

Zasady projektowania modułów

1. Pojedyncza odpowiedzialność – jeden moduł = jedna funkcjonalność biznesowa
2. Minimalne API – eksportuj tylko to co naprawdę potrzebne
3. Unikaj cyklicznych zależności – projektuj hierarchię modułów
4. Stabilne interfaces – zmiany w eksportowanych API wpływają na wszystkich klientów

Wzorce architektoniczne

// Wzorzec: API + Implementation
module myapp.api {
    exports com.example.myapp.api;
}

module myapp.impl {
    requires myapp.api;
    provides com.example.myapp.api.MyService 
        with com.example.myapp.impl.MyServiceImpl;
}

module myapp.client {
    requires myapp.api;
    uses com.example.myapp.api.MyService;
}

Wpływ na frameworki i biblioteki

Modularność Java 9 wpłynie na cały ekosystem:

Spring Framework

Spring planuje stopniowe wprowadzenie wsparcia dla modułów. Obecnie Spring Boot 1.x będzie działał jako automatic module.

Hibernate i JPA

ORM libraries będą musiały dostosować się do ograniczeń reflection w modularnym środowisku.

Przydatne zasoby:

• Project Jigsaw – oficjalna dokumentacja
• jdeps tool reference
• jlink tool reference
• Java 9 Migration Guide

Jakie są twoje doświadczenia z modularyzacją projektów? Które biblioteki sprawiają najwięcej problemów podczas migracji?