1. Kiedy i po co dzielić projekt na moduły
Dlaczego nie warto robić wszystkiego w jednym module
Jeśli piszesz małe zadanie albo "Hello, World!", system modułów może wydawać się nadmiarowy. Jednak wraz ze wzrostem projektu — dziesiątki i setki klas, wiele pakietów, biblioteki zewnętrzne — chaos staje się nieunikniony. To jak biblioteka bez półek: dopóki książek jest mało — da się żyć, ale później coś znaleźć jest trudno. Moduły to twoje półki: pomagają zaprowadzić porządek i ukrywają „kuchnię” (implementację), pozostawiając na zewnątrz tylko „witrynę” (API).
Po co dzielić na moduły
- Rozdzielenie odpowiedzialności: każdy moduł odpowiada za swój obszar (np. baza danych, logika biznesowa, UI).
- Ponowne użycie kodu: moduł można włączyć do innego projektu.
- Lepsza testowalność: moduły testuje się niezależnie.
- Bezpieczeństwo i enkapsulacja: na zewnątrz widoczne jest tylko API, implementacja jest ukryta.
- Łatwiejsze utrzymanie: mniej „magicznych” powiązań, czytelna mapa zależności.
- Szybsza kompilacja i wdrożenie: przebudowywane są tylko zmienione moduły.
Kiedy dzielić na moduły
- Projekt staje się zbyt duży dla jednego developera (albo IDE zaczyna „zwalniać”).
- Wyodrębniają się wyraźne części: core, ui, utils, api, impl.
- Planujesz ponowne wykorzystanie kodu w innych projektach.
- Są zależności zewnętrzne potrzebne tylko części projektu.
- Trzeba ukryć szczegóły implementacji (algorytmy, klasy wewnętrzne).
2. Typowe schematy modułowości
Poniżej znajdują się popularne schematy podziału, odpowiednie dla projektów edukacyjnych i produkcyjnych.
Architektura „cebulowa” (Onion Architecture)
Warstwa zewnętrzna zależy od wewnętrznej, ale nie odwrotnie.
[ app (UI) ]
↓
[ core (logika) ]
↓
[ utils (narzędzia) ]
- app — moduł zewnętrzny: interfejs graficzny, aplikacja webowa, punkt wejścia (main).
- core — logika biznesowa, modele, serwisy.
- utils — klasy pomocnicze.
Zasada: warstwa wewnętrzna nie powinna zależeć od zewnętrznej. Dzięki temu core można ponownie wykorzystać w różnych interfejsach (konsola, web, desktop).
Moduły dla API i implementacji
W bibliotekach wygodnie jest rozdzielić interfejsy i ich implementację:
[ mylib.api ] ← eksportuje tylko interfejsy
[ mylib.impl ] ← zawiera implementacje, nie jest eksportowany
Moduły do testów
Testy często wydziela się do osobnego modułu, aby nie trafiały do artefaktu produkcyjnego.
[ app ]
[ core ]
[ core.tests ]
Schemat dla projektu edukacyjnego
myeditor/
├─ app/ ← punkt wejścia, uruchamianie aplikacji
├─ core/ ← logika biznesowa (praca z plikami, tekstem)
└─ utils/ ← narzędzia (logowanie, parsowanie)
3. Zależności między modułami
W modułach Java zależności podaje się jawnie w module-info.java za pomocą słowa kluczowego requires. To zwiększa czytelność i pozwala kompilatorowi/JVM kontrolować dostępność API poprzez exports.
Przykład zależności
core/module-info.java
module myeditor.core {
exports myeditor.core.api; // na zewnątrz widoczny jest tylko pakiet api
requires myeditor.utils; // używamy narzędzi
}
app/module-info.java
module myeditor.app {
requires myeditor.core; // używamy core
requires myeditor.utils; // możemy używać narzędzi bezpośrednio
}
Zasady i najlepsze praktyki
- Unikaj zależności cyklicznych. Jeśli A requires B i B requires A — to błąd projektowy. Zwykle rozwiązuje się to wydzieleniem wspólnego common/api.
- Minimalizuj zależności. Nie dołączaj modułu, jeśli naprawdę nie jest potrzebny.
- Eksportuj używane pakiety. Klasy muszą znajdować się w pakietach zadeklarowanych przez exports, w przeciwnym razie będzie błąd kompilacji.
- Narzędzia — maksymalnie niezależne. utils nie powinien zależeć od logiki biznesowej.
4. Praktyka: przykład podziału projektu edukacyjnego na 3 moduły
Struktura katalogów
myeditor/
├─ app/
│ ├─ src/
│ │ └─ myeditor/app/Main.java
│ └─ module-info.java
├─ core/
│ ├─ src/
│ │ ├─ myeditor/core/api/TextService.java
│ │ └─ myeditor/core/impl/TextServiceImpl.java
│ └─ module-info.java
└─ utils/
├─ src/
│ └─ myeditor/utils/Logger.java
└─ module-info.java
Przykłady module-info.java
core/module-info.java
module myeditor.core {
exports myeditor.core.api;
requires myeditor.utils;
}
app/module-info.java
module myeditor.app {
requires myeditor.core;
requires myeditor.utils;
}
utils/module-info.java
module myeditor.utils {
exports myeditor.utils;
}
Przykład kodu (TextService)
myeditor/core/api/TextService.java
package myeditor.core.api;
public interface TextService {
String toUpperCase(String text);
}
myeditor/core/impl/TextServiceImpl.java
package myeditor.core.impl;
import myeditor.core.api.TextService;
public class TextServiceImpl implements TextService {
@Override
public String toUpperCase(String text) {
return text.toUpperCase();
}
}
myeditor/app/Main.java
package myeditor.app;
import myeditor.core.api.TextService;
import myeditor.core.impl.TextServiceImpl;
public class Main {
public static void main(String[] args) {
TextService service = new TextServiceImpl();
System.out.println(service.toUpperCase("hello, modules!"));
}
}
Jak to wygląda w IntelliJ IDEA
- Każdy katalog to osobny Module w strukturze projektu.
- Każdy moduł ma własny module-info.java w katalogu głównym src.
- Przy uruchamianiu main z app IDE sama dobierze module-path.
- Próba użycia klasy z nieeksportowanego pakietu zakończy się błędem kompilacji.
5. Wpływ na proces budowania: Maven/Gradle i moduły
Maven
Projekt wielomodułowy to projekt „nadrzędny” (parent) i kilka „podrzędnych” modułów.
myeditor/
├─ pom.xml ← parent
├─ app/
│ └─ pom.xml
├─ core/
│ └─ pom.xml
└─ utils/
└─ pom.xml
Przykład parent pom.xml
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>myeditor</groupId>
<artifactId>myeditor-parent</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
<module>app</module>
<module>core</module>
<module>utils</module>
</modules>
</project>
Cechy:
- Maven uwzględnia module-info.java podczas kompilacji.
- Do uruchamiania używa się --module-path zamiast --classpath.
- Jeśli zapomnisz o exports lub requires — dostaniesz błąd kompilacji.
Gradle
Wielomodułowość konfiguruje się przez settings.gradle i osobne build.gradle dla modułów.
settings.gradle
rootProject.name = 'myeditor'
include 'app', 'core', 'utils'
build.gradle dla modułu
plugins {
id 'java'
}
java {
modularity.inferModulePath = true
}
IntelliJ IDEA
- IDEA potrafi tworzyć module-info.java przy tworzeniu modułu Java.
- Z Maven/Gradle struktura modułów jest wykrywana automatycznie.
- Przy uruchamianiu main z app IDE skonfiguruje module-path.
- Dialogi importu/eksportu podpowiadają widoczność pakietów i modułów.
Typowe błędy przy podziale na moduły
Błąd nr 1: Zależności cykliczne między modułami. Jeśli dwa moduły deklarują requires na siebie nawzajem, kompilator zgłosi błąd. Zwykle to oznaka „rozmytej” architektury. Rozwiązanie — wydzielić wspólny api-moduł lub przemyśleć granice.
Błąd nr 2: Używanie klas z nieeksportowanych pakietów. Klasa może być public, ale jeśli pakiet nie jest wskazany w exports w module-info.java, inny moduł jej nie zobaczy. Efekt — błąd kompilacji.
Błąd nr 3: Zapomniano dodać requires dla używanego modułu. Import z innego modułu bez odpowiedniego wpisu w module-info.java się nie skompiluje. Zawsze deklaruj zależności jawnie.
Błąd nr 4: Duplikowanie nazw modułów. Nazwy modułów muszą być unikalne w ramach budowania (zwłaszcza z Maven/Gradle). Duplikaty psują proces budowania.
Błąd nr 5: Nieprawidłowa struktura katalogów. Plik module-info.java musi leżeć w katalogu głównym src danego modułu. W przeciwnym razie kompilator nie znajdzie modułu.
Błąd nr 6: Nieprawidłowy module-path przy uruchamianiu. Przy uruchamianiu ręcznym podawaj --module-path zamiast --classpath, w przeciwnym razie otrzymasz „module not found”.
GO TO FULL VERSION