Wie man die Java-Projektstruktur verwaltet

Einführung

Eine effektive Projektstruktur ist für erfolgreiche Java-Entwicklung von entscheidender Bedeutung. Dieser umfassende Leitfaden untersucht die grundlegenden Prinzipien der Organisation von Java-Projekten und gibt Entwicklern praktische Einblicke in die Erstellung skalierbarer, wartbarer und gut strukturierter Softwarelösungen.

Skills Graph

Erstellen einer einfachen Java-Projektstruktur

Java-Projekte folgen bestimmten Organisationskonventionen, die es Entwicklern ermöglichen, Code effektiv zu verwalten. In diesem Schritt erstellen Sie manuell eine einfache Java-Projektstruktur, um die grundlegenden Komponenten zu verstehen.

Grundlegendes zu Java-Projektkomponenten

Ein Java-Projekt enthält typischerweise:

• Quellcode-Dateien (.java)
• Kompilierte Bytecode-Dateien (.class)
• Ressourcen-Dateien (Konfiguration, Bilder usw.)
• Dokumentation

Erstellen einer einfachen Projektstruktur

Beginnen wir damit, eine einfache Projektstruktur in Ihrem Arbeitsbereich zu erstellen. Wir werden eine einfache "HelloWorld"-Anwendung erstellen, um die Konzepte zu veranschaulichen.

1. Öffnen Sie zunächst ein Terminal in Ihrer LabEx-Umgebung. Ihr Terminal sollte sich bereits im Verzeichnis /home/labex/project befinden.

2. Erstellen Sie ein Projektverzeichnis für unsere Java-Anwendung:

mkdir -p hello-java-app/src
cd hello-java-app

3. Erstellen Sie innerhalb des src-Verzeichnisses eine einfache Java-Klassen-Datei:

mkdir -p src/com/example/app

4. Jetzt erstellen wir unsere erste Java-Klasse. Öffnen Sie den Code-Editor und erstellen Sie eine neue Datei namens HelloWorld.java im Pfad hello-java-app/src/com/example/app/:

package com.example.app;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Java Project World!");
    }
}

5. Kompilieren wir diesen Java-Code. Navigieren Sie im Terminal zurück zum Projektstamm und führen Sie aus:

cd /home/labex/project/hello-java-app
mkdir -p bin
javac -d bin src/com/example/app/HelloWorld.java

Die Ausgabe sollte keine Fehler anzeigen, wenn die Kompilierung erfolgreich war.

6. Führen Sie jetzt die kompilierte Java-Anwendung aus:

java -cp bin com.example.app.HelloWorld

Sie sollten die folgende Ausgabe sehen:

Hello, Java Project World!

Grundlegendes zur Projektstruktur

Lassen Sie uns überprüfen, was wir erstellt haben:

hello-java-app/
├── bin/              ## Kompilierter Bytecode (.class-Dateien)
│   └── com/
│       └── example/
│           └── app/
│               └── HelloWorld.class
└── src/              ## Quellcode (.java-Dateien)
    └── com/
        └── example/
            └── app/
                └── HelloWorld.java

Diese Struktur folgt diesen Prinzipien:

• Trennung von Quellcode: Alle Java-Quellcode-Dateien befinden sich im src-Verzeichnis.
• Paketstruktur: Das Paket com.example.app entspricht den Verzeichnissen com/example/app/.
• Trennung von kompiliertem Code: Bytecode-Dateien befinden sich in einem separaten bin-Verzeichnis.

Wichtige Konzepte

• Pakete: Java verwendet Pakete, um Klassen zu organisieren und Namenskonflikte zu vermeiden.
• Verzeichnisstruktur: Paketnamen werden direkt auf Verzeichnisstrukturen abgebildet.
• Classpath: Die -cp-Option gibt Java an, wo es die kompilierten Klassen finden kann.

Sie haben nun manuell eine einfache Java-Projektstruktur erstellt. Diese Grundlage wird Ihnen helfen, komplexere Projektstrukturen zu verstehen, die in realen Anwendungen verwendet werden.

Organisieren von Java-Code mit Paketen

In diesem Schritt lernen Sie, wie Sie Ihren Java-Code mithilfe von Paketen organisieren und eine besser strukturierte Anwendung mit mehreren Klassen erstellen können. Eine ordnungsgemäße Paketorganisation ist für wartbare Java-Projekte unerlässlich.

Grundlegendes zu Paketkonventionen

Java-Pakete folgen einer hierarchischen Namenskonvention:

• Beginnt mit einem umgekehrten Domainnamen (z.B. com.example).
• Fügt den Projektnamen oder Organisationsnamen hinzu (z.B. com.example.project).
• Fügt funktionale Bereiche hinzu (z.B. com.example.project.model).

Lassen Sie uns diese Struktur in unserem Projekt implementieren.

Erstellen eines Projekts mit mehreren Paketen

Wir werden ein einfaches Bibliotheksverwaltungssystem mit verschiedenen Paketen für unterschiedliche Aspekte erstellen:

1. Navigieren Sie in Ihr Projektverzeichnis:

cd /home/labex/project
mkdir -p library-app/src
cd library-app

2. Erstellen Sie ein strukturiertes Paketlayout:

mkdir -p src/com/example/library/model
mkdir -p src/com/example/library/service
mkdir -p src/com/example/library/util

3. Erstellen Sie zunächst eine Modellklasse. Öffnen Sie den Code-Editor und erstellen Sie eine neue Datei namens Book.java im Pfad library-app/src/com/example/library/model/:

package com.example.library.model;

public class Book {
    private String title;
    private String author;
    private int year;

    public Book(String title, String author, int year) {
        this.title = title;
        this.author = author;
        this.year = year;
    }

    // Getters
    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    public int getYear() {
        return year;
    }

    @Override
    public String toString() {
        return "Book{title='" + title + "', author='" + author + "', year=" + year + "}";
    }
}

4. Erstellen Sie als Nächstes eine Serviceklasse in library-app/src/com/example/library/service/BookService.java:

package com.example.library.service;

import com.example.library.model.Book;
import java.util.ArrayList;
import java.util.List;

public class BookService {
    private List<Book> books = new ArrayList<>();

    public void addBook(Book book) {
        books.add(book);
    }

    public List<Book> getAllBooks() {
        return new ArrayList<>(books);
    }

    public Book findBookByTitle(String title) {
        for (Book book : books) {
            if (book.getTitle().equalsIgnoreCase(title)) {
                return book;
            }
        }
        return null;
    }
}

5. Erstellen Sie eine Hilfsklasse in library-app/src/com/example/library/util/BookFormatter.java:

package com.example.library.util;

import com.example.library.model.Book;

public class BookFormatter {
    public static String formatBookInfo(Book book) {
        return String.format("'%s' by %s (%d)",
            book.getTitle(), book.getAuthor(), book.getYear());
    }
}

6. Erstellen Sie schließlich die Hauptanwendungsklasse in library-app/src/com/example/library/LibraryApp.java:

package com.example.library;

import com.example.library.model.Book;
import com.example.library.service.BookService;
import com.example.library.util.BookFormatter;

public class LibraryApp {
    public static void main(String[] args) {
        // Create service
        BookService bookService = new BookService();

        // Add some books
        bookService.addBook(new Book("The Great Gatsby", "F. Scott Fitzgerald", 1925));
        bookService.addBook(new Book("To Kill a Mockingbird", "Harper Lee", 1960));
        bookService.addBook(new Book("1984", "George Orwell", 1949));

        // Display all books
        System.out.println("Library Catalog:");
        for (Book book : bookService.getAllBooks()) {
            System.out.println(BookFormatter.formatBookInfo(book));
        }

        // Find a specific book
        Book foundBook = bookService.findBookByTitle("1984");
        if (foundBook != null) {
            System.out.println("\nFound book: " + foundBook);
        }
    }
}

7. Kompilieren Sie alle Java-Dateien:

mkdir -p bin
javac -d bin src/com/example/library/model/Book.java src/com/example/library/service/BookService.java src/com/example/library/util/BookFormatter.java src/com/example/library/LibraryApp.java

8. Führen Sie die Anwendung aus:

java -cp bin com.example.library.LibraryApp

Sie sollten die folgende Ausgabe sehen:

Library Catalog:
'The Great Gatsby' by F. Scott Fitzgerald (1925)
'To Kill a Mockingbird' by Harper Lee (1960)
'1984' by George Orwell (1949)

Found book: Book{title='1984', author='George Orwell', year=1949}

Grundlegendes zur Paketstruktur

Lassen Sie uns die von uns erstellte Struktur untersuchen:

library-app/
├── bin/                              ## Kompilierter Bytecode
└── src/                              ## Quellcode
    └── com/
        └── example/
            └── library/
                ├── model/            ## Datenstrukturen
                │   └── Book.java
                ├── service/          ## Geschäftslogik
                │   └── BookService.java
                ├── util/             ## Hilfsfunktionen
                │   └── BookFormatter.java
                └── LibraryApp.java   ## Hauptanwendung

Prinzipien der Paketorganisation

Diese Struktur folgt wichtigen Entwurfsprinzipien:

1. Trennung von Belangen:

   • model-Paket: Enthält Datenstrukturen.
   • service-Paket: Enthält Geschäftslogik.
   • util-Paket: Enthält Hilfsfunktionen.

2. Logische Gruppierung: Verwandte Klassen werden in demselben Paket zusammengefasst.

3. Intuitive Navigation: Die Paketstruktur erleichtert die Suche nach bestimmten Funktionen.

4. Importverwaltung: Klassen verweisen aufeinander über Imports, wodurch die Abhängigkeiten klar werden.

Indem Sie den Code auf diese Weise organisieren, erstellen Sie wartbarere, skalierbare Anwendungen, die leichter zu verstehen und zu erweitern sind.

Verwenden von Maven für die Projektverwaltung

In diesem Schritt lernen Sie, wie Sie Apache Maven verwenden, um Ihr Java-Projekt zu verwalten. Maven ist ein leistungsstarkes Tool zur Build-Automatisierung und Abhängigkeitsverwaltung, das die Projektaufsetzung und -wartung vereinfacht.

Grundlegendes zu Maven

Maven bietet:

• Standardisierte Projektstruktur
• Abhängigkeitsverwaltung
• Build-Automatisierung
• Projektinformationsverwaltung
• Einheitlichen Build-Prozess über Projekte hinweg

Einrichten eines Maven-Projekts

Erstellen wir ein neues Projekt mit Maven:

1. Prüfen Sie zunächst, ob Maven installiert ist:

mvn --version

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Apache Maven 3.6.3
Maven home: /usr/share/maven
Java version: 11.0.18, vendor: Ubuntu, runtime: /usr/lib/jvm/java-11-openjdk-amd64
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "5.15.0-1036-azure", arch: "amd64", family: "unix"

2. Navigieren Sie in Ihr Projektverzeichnis:

cd /home/labex/project

3. Erstellen Sie ein neues Maven-Projekt mithilfe eines Archetyps (eines Projektvorlagens):

mvn archetype:generate \
  -DgroupId=com.example.calculator \
  -DartifactId=simple-calculator \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DarchetypeVersion=1.4 \
  -DinteractiveMode=false

Dieser Befehl erstellt ein neues Projekt mit einer standardisierten Verzeichnisstruktur.

4. Untersuchen Sie die Projektstruktur:

cd simple-calculator
ls -la

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

total 24
drwxr-xr-x 4 labex labex 4096 ... .
drwxr-xr-x 6 labex labex 4096 ... ..
-rw-r--r-- 1 labex labex  174 ... .gitignore
-rw-r--r-- 1 labex labex  720 ... pom.xml
drwxr-xr-x 4 labex labex 4096 ... src

Die wichtigste Datei hier ist pom.xml (Project Object Model), die die Projektkonfiguration definiert.

5. Untersuchen Sie das Maven-Standardverzeichnislayout:

find src -type d

Sie sollten Folgendes sehen:

src
src/main
src/main/java
src/main/java/com
src/main/java/com/example
src/main/java/com/example/calculator
src/test
src/test/java
src/test/java/com
src/test/java/com/example
src/test/java/com/example/calculator

Dies ist das Maven-Standardverzeichnislayout:

• src/main/java: Quellcode
• src/main/resources: Ressourcendateien
• src/test/java: Testcode
• src/test/resources: Testressourcen

6. Schauen wir uns die generierte App.java-Datei an:

cat src/main/java/com/example/calculator/App.java

Sie sollten eine einfache "Hello World"-Klasse sehen:

package com.example.calculator;

/**
 * Hello world!
 *
 */
public class App
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
    }
}

Verbessern des Maven-Projekts

Verbessern wir unser Taschenrechnerprojekt, indem wir weitere Klassen hinzufügen:

1. Erstellen Sie eine neue Datei namens Calculator.java in src/main/java/com/example/calculator/:

package com.example.calculator;

public class Calculator {

    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }

    public double divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        return (double) a / b;
    }
}

2. Modifizieren Sie nun die vorhandene App.java-Datei, um unsere Calculator-Klasse zu verwenden:

package com.example.calculator;

/**
 * Simple Calculator Application
 */
public class App
{
    public static void main( String[] args )
    {
        Calculator calculator = new Calculator();

        // Perform some calculations
        System.out.println("Addition: 5 + 3 = " + calculator.add(5, 3));
        System.out.println("Subtraction: 10 - 4 = " + calculator.subtract(10, 4));
        System.out.println("Multiplication: 6 * 7 = " + calculator.multiply(6, 7));
        System.out.println("Division: 20 / 4 = " + calculator.divide(20, 4));

        System.out.println("Calculator application completed successfully!");
    }
}

3. Bauen Sie das Projekt mit Maven:

mvn compile

Sie sollten eine Ausgabe sehen, die mit folgendem endet:

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

4. Packen Sie die Anwendung in eine JAR-Datei:

mvn package

Dieser Befehl kompiliert Ihren Code, führt Tests aus und packt die Anwendung.

5. Führen Sie die gepackte Anwendung aus:

java -cp target/simple-calculator-1.0-SNAPSHOT.jar com.example.calculator.App

Sie sollten die folgende Ausgabe sehen:

Addition: 5 + 3 = 8
Subtraction: 10 - 4 = 6
Multiplication: 6 * 7 = 42
Division: 20 / 4 = 5.0
Calculator application completed successfully!

Grundlegendes zur Maven-POM-Datei

Die Project Object Model (POM)-Datei enthält die Projektkonfiguration. Öffnen Sie die pom.xml-Datei im Editor und untersuchen Sie ihre Struktur:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.example.calculator</groupId>
  <artifactId>simple-calculator</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>simple-calculator</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <!-- Build configuration... -->
</project>

Wichtige Elemente in der POM-Datei:

• groupId: Organisations- oder Projektkennung
• artifactId: Projektname
• version: Projektversion
• dependencies: Externe Bibliotheken, die vom Projekt verwendet werden
• build: Konfiguration für das Bauen des Projekts

Wichtige Maven-Befehle

Hier sind einige essentielle Maven-Befehle:

• mvn compile: Kompiliert Quellcode
• mvn test: Führt Tests aus
• mvn package: Erstellt verteilbare Pakete (JAR, WAR)
• mvn install: Installiert das Paket im lokalen Repository
• mvn clean: Entfernt Build-Artefakte (Verzeichnis target)
• mvn clean install: Kombination aus clean und install

Maven hat die Java-Projektverwaltung erheblich vereinfacht, indem es Konventionen, Abhängigkeitsverwaltung und Build-Automatisierung bietet. Dieser standardisierte Ansatz hilft Entwicklern, sich auf das Schreiben von Code statt auf die Verwaltung der Projektstruktur zu konzentrieren.

Zusammenfassung

In diesem Lab haben Sie durch praktische Übungen wesentliche Strategien zur Verwaltung der Java-Projektstruktur gelernt:

1. Sie haben begonnen, indem Sie manuell eine grundlegende Java-Projektstruktur erstellt haben und die grundlegenden Komponenten von Quellverzeichnissen, Paketen und der Organisation von kompiliertem Code verstanden haben.

2. Anschließend haben Sie es zu einem komplexeren Projekt mit ordnungsgemäßer Paketorganisation geschafft und die Trennung von Belangen umgesetzt, indem Sie die Funktionalität in Model-, Service- und Utility-Pakete aufgeteilt haben.

3. Schließlich haben Sie gelernt, wie Sie Maven, ein leistungsstarkes Build-Automatisierungstool, verwenden können, um standardisierte Java-Projekte mit Abhängigkeitsverwaltung und automatisierten Build-Prozessen zu erstellen und zu verwalten.

Diese grundlegenden Fähigkeiten werden als solide Grundlage für Ihre zukünftige Java-Entwicklungsarbeit dienen und Ihnen ermöglichen, gut organisierte, wartbare und skalierbare Anwendungen zu erstellen. Indem Sie etablierte Konventionen und bewährte Verfahren für die Projektstruktur befolgen, können Sie effektiver mit anderen Entwicklern zusammenarbeiten und höherwertigen Code produzieren.