CodeGym /Kursy /JAVA 25 SELF /Podział projektu na moduły: najlepsze praktyki

Podział projektu na moduły: najlepsze praktyki

JAVA 25 SELF
Poziom 60, Lekcja 3
Dostępny

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”.

1
Zadanie
JAVA 25 SELF, poziom 60, lekcja 3
Niedostępne
Otwarcie kanału komunikacji dla dziennika zdarzeń 📢
Otwarcie kanału komunikacji dla dziennika zdarzeń 📢
1
Zadanie
JAVA 25 SELF, poziom 60, lekcja 3
Niedostępne
Architekt cyfrowej książki adresowej 🗺️
Architekt cyfrowej książki adresowej 🗺️
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION