CodeGym /Kurse /JAVA 25 SELF /Kapselung durch Module: Export und Import

Kapselung durch Module: Export und Import

JAVA 25 SELF
Level 60, Lektion 2
Verfügbar

1. Export von Paketen: Wer sieht Ihren Code?

In der Welt vor Java 9 war alles einfach. Nur eben nicht besonders sicher. War eine Klasse public, konnte sie jeder sehen, der Zugriff auf das JAR oder den Classpath hatte. Das führte dazu, dass interne Klassen und sogar ganze Pakete versehentlich oder absichtlich außerhalb Ihres Projekts verwendet werden konnten. Ja, man konnte etwas mit private oder package-private verbergen, aber wenn eine Klasse public ist – ist sie für alle zugänglich.

Mit der Einführung von Modulen hat sich das geändert. Jetzt kann eine Klasse selbst dann nicht aus einem anderen Modul verwendet werden, wenn sie als public deklariert ist, sofern das Paket, in dem sie liegt, nicht ausdrücklich über module-info.java exportiert wird.

Wie sieht das in der Praxis aus

Angenommen, Sie haben folgende Projektstruktur:

my-app/
  src/
    core/
      com/example/core/
        CoreService.java
        InternalHelper.java
      module-info.java
    app/
      com/example/app/
        Main.java
      module-info.java

In der Datei core/module-info.java schreiben Sie:

module core {
    exports com.example.core;
}

Dann sind nur Klassen aus dem Paket com.example.core für andere Module sichtbar. Alles, was sich in anderen Paketen befindet (z. B. com.example.core.internal), bleibt unsichtbar – selbst wenn es dort public-Klassen gibt. Das ist die modulare Kapselung.

Mini-Demo: „sichtbar/unsichtbar“

Innerhalb von core:

// com/example/core/CoreService.java
package com.example.core;

public class CoreService {
    public void doWork() {
        System.out.println("Work done!");
    }
}

Innerhalb von app:

// com/example/app/Main.java
package com.example.app;

import com.example.core.CoreService;

public class Main {
    public static void main(String[] args) {
        CoreService service = new CoreService();
        service.doWork();
    }
}

Wenn Sie die Zeile exports com.example.core; aus core/module-info.java entfernen, erhalten Sie beim Kompilieren den Fehler:

error: package com.example.core is not visible

Sogar wenn CoreService public ist!

2. Import von Abhängigkeiten: requires und strikte Isolation

In JPMS kann man eine Klasse aus einem anderen Modul nicht einfach so verwenden. Man muss die Abhängigkeit ausdrücklich mit requires deklarieren.

Beispiel

In der Datei app/module-info.java:

module app {
    requires core;
}

Jetzt kann das Modul app alles verwenden, was das Modul core exportiert.

Wenn Sie requires core; vergessen, erhalten Sie einen Kompilierungsfehler:

error: package com.example.core is not visible

oder

error: cannot access CoreService

Wichtiger Punkt

  • requires wirkt auf Modulebene, nicht auf Paketebene.
  • Sie können nicht nur ein einziges Paket „importieren“ – nur das gesamte exportierte Modul.

3. Vergleich: Module vs. public/private

Module fügen eine neue Ebene der Kapselung hinzu, die oberhalb von Klassen und Paketen liegt.

Ebene Was regelt es? Wie funktioniert es?
private Zugriff innerhalb der Klasse Nur innerhalb einer Datei
package-private (standardmäßig) Zugriff innerhalb eines Pakets Alle Klassen in einem Paket
public Zugriff für alle Beliebiger Code überall
module Zugriff zwischen Modulen Nur exportierte Pakete

Kernidee:

  • Eine Klasse kann public sein, aber wenn ihr Paket nicht exportiert ist, ist sie nur innerhalb des Moduls zugänglich.
  • Das Exportieren eines Pakets über exports ist wie ein „Fenster“, durch das Ihr Code für andere Module sichtbar wird.

Beispiel: versteckte Implementierung

// com/example/core/internal/SecretSauce.java
package com.example.core.internal;

public class SecretSauce {
    public void addMagic() {}
}

Wenn Sie das Paket com.example.core.internal in module-info.java NICHT exportieren, kann kein externes Modul diese Klasse verwenden, selbst wenn sie public ist!

4. Beispiel: core und app – API und Implementierung

Betrachten wir ein typisches Szenario: Das Modul core stellt ein API bereit, das Modul app verwendet es.

Struktur:

core/
  com/example/core/
    CoreAPI.java
  com/example/core/impl/
    CoreImpl.java
  module-info.java

app/
  com/example/app/
    Main.java
  module-info.java

core/module-info.java:

module core {
    exports com.example.core; // Nur das API!
    // Wir exportieren com.example.core.impl nicht
}

app/module-info.java:

module app {
    requires core;
}

com/example/core/CoreAPI.java:

package com.example.core;

public interface CoreAPI {
    void doSomething();
}

com/example/core/impl/CoreImpl.java:

package com.example.core.impl;

import com.example.core.CoreAPI;

public class CoreImpl implements CoreAPI {
    @Override
    public void doSomething() {
        System.out.println("Doing something!");
    }
}

com/example/app/Main.java:

package com.example.app;

import com.example.core.CoreAPI;
// import com.example.core.impl.CoreImpl; // Das wird einen Kompilierungsfehler auslösen!

public class Main {
    public static void main(String[] args) {
        // CoreImpl impl = new CoreImpl(); // Fehler! Paket wird nicht exportiert.
        // Es darf nur das verwendet werden, was über das API sichtbar ist.
    }
}

Ergebnis:

  • Das Modul app sieht nur das, was core exportiert.
  • Die Implementierung (impl) ist verborgen, selbst wenn die Klassen dort public sind.

5. Praxis: mit exports und Sichtbarkeit experimentieren

Schritt 1: exports entfernen

Kommentieren Sie in core/module-info.java die Zeile aus:

// exports com.example.core;

Versuchen Sie nun, das Projekt zu kompilieren. Erwarten Sie einen Kompilierungsfehler im Modul app – es wird die Klassen aus com.example.core nicht sehen.

Schritt 2: nur das API exportieren

Stellen Sie die Zeile exports com.example.core; wieder her, exportieren Sie aber com.example.core.impl nicht. Versuchen Sie im Modul app, eine Klasse aus impl zu importieren. Sie bekommen erneut einen Kompilierungsfehler – alles korrekt!

Schritt 3: public-Klasse in einem nicht exportierten Paket

Erstellen Sie eine public-Klasse in einem nicht exportierten Paket. Versuchen Sie, sie aus einem anderen Modul zu verwenden – es wird nicht funktionieren. Das ist modulare Kapselung in Aktion.

6. Wie das in der IDE und „ganz anschaulich“ aussieht

  • Beim Versuch, eine Klasse aus einem nicht exportierten Paket zu importieren, hebt die IDE den Fehler hervor.
  • Der Hinweis erklärt, dass das Paket vom Modul nicht exportiert wird.
  • Fügen Sie für das benötigte Paket ein exports hinzu – der Fehler verschwindet.

Schema: Zugriffsebenen

+---------------------+
|      MODULE         |
|  (module-info.java) |
+---------------------+
       |
       v
+---------------------+
|     PAKETE          |
| (package, export)   |
+---------------------+
       |
       v
+---------------------+
|     KLASSE          |
| (public/private)    |
+---------------------+
       |
       v
+---------------------+
|    METHOD/FELD      |
| (public/private)    |
+---------------------+

7. Wichtige Details und Besonderheiten

Export „nur für Freunde“: exports ... to

Manchmal muss man ein Paket nur für bestimmte Module exportieren (z. B. für Tests oder spezielle Erweiterungen):

exports com.example.core.internal to my.special.module, my.test.module;

Nun sehen nur die angegebenen Module dieses Paket.

Kann man mehrere Pakete exportieren?

Ja! Fügen Sie einfach weitere exports-Zeilen hinzu:

exports com.example.core;
exports com.example.core.api;

Kann man „alles“ exportieren?

Nein. Im Modulsystem von Java geben Sie immer explizit an, was exportiert wird. Das ist seine Stärke.

8. Typische Fehler beim Arbeiten mit modularer Kapselung

Fehler Nr. 1: Die Erwartung, dass eine public-Klasse immer sichtbar ist.
Wenn ein Paket nicht über module-info.java exportiert wird, ist die Klasse für andere Module unsichtbar, selbst wenn sie public ist. Das ist die häufigste „Falle“ für Einsteiger.

Fehler Nr. 2: requires vergessen.
Wenn Ihr Modul Klassen aus einem anderen Modul verwendet, aber kein requires angibt, erhalten Sie einen Kompilierungsfehler. Beschreiben Sie Abhängigkeiten immer explizit.

Fehler Nr. 3: Versuch, dasselbe Paket aus zwei Modulen zu exportieren.
In JPMS darf jedes Paket nur von genau einem Modul exportiert werden. Wenn Sie diese Regel verletzen, stoppt der Compiler Sie.

Fehler Nr. 4: Falsche Struktur – module-info.java am falschen Ort.
Die Datei module-info.java muss im Quellwurzelverzeichnis des Moduls liegen, sonst wird das Modul nicht erkannt.

Fehler Nr. 5: Zyklische Abhängigkeiten zwischen Modulen.
Wenn Modul A B verlangt und B A verlangt, erhalten Sie einen Fehler. Vermeiden Sie Zyklen im Abhängigkeitsgraphen.

1
Aufgabe
JAVA 25 SELF, Level 60, Lektion 2
Gesperrt
Werkstatt digitaler Werkzeuge und Demonstration ihrer Kraft 🛠️
Werkstatt digitaler Werkzeuge und Demonstration ihrer Kraft 🛠️
1
Aufgabe
JAVA 25 SELF, Level 60, Lektion 2
Gesperrt
Der Hüter der Service-Geheimnisse 🤫
Der Hüter der Service-Geheimnisse 🤫
Kommentare
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION