LabEx
EntrerRejoindre

Comment gérer la structure d'un projet Java

JavaBeginner
Pratiquer maintenant

Introduction

Une structure de projet efficace est essentielle pour un développement Java réussi. Ce guide complet explore les principes fondamentaux de l'organisation des projets Java, offrant aux développeurs des informations pratiques pour créer des solutions logiciels évolutives, maintenables et bien structurées.

Création d'une structure de projet Java de base

Les projets Java suivent certaines conventions d'organisation qui aident les développeurs à gérer efficacement le code. Dans cette étape, vous allez créer manuellement une structure de projet Java simple pour comprendre les composants fondamentaux.

Compréhension des composants d'un projet Java

Un projet Java contient généralement :

  • Des fichiers de code source (.java)
  • Des fichiers de bytecode compilé (.class)
  • Des fichiers de ressources (configuration, images, etc.)
  • Des documents

Création d'une structure de projet simple

Commençons par créer une structure de projet de base dans votre espace de travail. Nous allons construire une simple application "HelloWorld" pour illustrer les concepts.

  1. Tout d'abord, ouvrez un terminal dans votre environnement LabEx. Votre terminal devrait déjà être dans le répertoire /home/labex/project.

  2. Créez un répertoire de projet pour notre application Java :

mkdir -p hello-java-app/src
cd hello-java-app
  1. À l'intérieur du répertoire src, créez un simple fichier de classe Java :
mkdir -p src/com/example/app
  1. Maintenant, créons notre première classe Java. Ouvrez l'éditeur de code et créez un nouveau fichier appelé HelloWorld.java dans le chemin 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!");
    }
}
  1. Compilons ce code Java. Dans le terminal, revenez à la racine du projet et exécutez :
cd /home/labex/project/hello-java-app
mkdir -p bin
javac -d bin src/com/example/app/HelloWorld.java

La sortie ne devrait afficher aucune erreur si la compilation a réussi.

  1. Maintenant, exécutez l'application Java compilée :
java -cp bin com.example.app.HelloWorld

Vous devriez voir la sortie suivante :

Hello, Java Project World!

Compréhension de la structure du projet

Revoyons ce que nous avons créé :

hello-java-app/
├── bin/              ## Bytecode compilé (.class files)
│   └── com/
│       └── example/
│           └── app/
│               └── HelloWorld.class
└── src/              ## Code source (.java files)
    └── com/
        └── example/
            └── app/
                └── HelloWorld.java

Cette structure suit les principes suivants :

  • Séparation du code source : Tous les fichiers de code source Java se trouvent dans le répertoire src
  • Structure des packages : Le package com.example.app correspond aux répertoires com/example/app/
  • Séparation du code compilé : Les fichiers de bytecode se trouvent dans un répertoire bin séparé

Concepts clés

  • Packages : Java utilise les packages pour organiser les classes et éviter les conflits de noms
  • Structure des répertoires : Les noms de packages correspondent directement aux structures de répertoires
  • Classpath : Le flag -cp indique à Java où trouver les classes compilées

Vous avez maintenant créé manuellement une structure de projet Java de base. Cette base vous aidera à comprendre les structures de projet plus complexes utilisées dans les applications du monde réel.

Organisation du code Java avec des packages

Dans cette étape, vous allez apprendre à organiser votre code Java en utilisant des packages et à créer une application plus structurée avec plusieurs classes. Une bonne organisation des packages est essentielle pour les projets Java maintenables.

Compréhension des conventions de nommage des packages

Les packages Java suivent une convention de nommage hiérarchique :

  • Commencez par un nom de domaine inversé (par exemple, com.example)
  • Ajoutez le nom du projet ou de l'organisation (par exemple, com.example.project)
  • Ajoutez les domaines fonctionnels (par exemple, com.example.project.model)

Implémentons cette structure dans notre projet.

Création d'un projet multi - packages

Nous allons construire un simple système de gestion de bibliothèque avec des packages distincts pour différentes préoccupations :

  1. Accédez à votre répertoire de projet :
cd /home/labex/project
mkdir -p library-app/src
cd library-app
  1. Créez une disposition structurée de packages :
mkdir -p src/com/example/library/model
mkdir -p src/com/example/library/service
mkdir -p src/com/example/library/util
  1. Tout d'abord, créez une classe modèle. Ouvrez l'éditeur de code et créez un nouveau fichier appelé Book.java dans le chemin 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 + "}";
    }
}
  1. Ensuite, créez une classe de service dans 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;
    }
}
  1. Créez une classe utilitaire dans 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());
    }
}
  1. Enfin, créez la classe principale de l'application dans 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);
        }
    }
}
  1. Compilez tous les fichiers Java :
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
  1. Exécutez l'application :
java -cp bin com.example.library.LibraryApp

Vous devriez voir la sortie suivante :

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}

Compréhension de la structure des packages

Examinons la structure que nous avons créée :

library-app/
├── bin/                              ## Bytecode compilé
└── src/                              ## Code source
    └── com/
        └── example/
            └── library/
                ├── model/            ## Structures de données
                │   └── Book.java
                ├── service/          ## Logique métier
                │   └── BookService.java
                ├── util/             ## Fonctions utilitaires
                │   └── BookFormatter.java
                └── LibraryApp.java   ## Application principale

Principes d'organisation des packages

Cette structure suit des principes de conception importants :

  1. Séparation des préoccupations :

    • Package model : Contient les structures de données
    • Package service : Contient la logique métier
    • Package util : Contient les fonctions utilitaires

  2. Groupement logique : Les classes liées sont regroupées dans le même package

  3. Navigation intuitive : La structure des packages facilite la localisation d'une fonctionnalité spécifique

  4. Gestion des imports : Les classes se référencent les unes aux autres via des imports, rendant les dépendances claires

En organisant le code de cette manière, vous créez des applications plus maintenables, évolutives, faciles à comprendre et à étendre.

Utilisation de Maven pour la gestion de projet

Dans cette étape, vous allez apprendre à utiliser Apache Maven pour gérer votre projet Java. Maven est un outil puissant d'automatisation de build et de gestion des dépendances qui simplifie la configuration et la maintenance des projets.

Comprendre Maven

Maven offre :

  • Une structure de projet standard
  • Une gestion des dépendances
  • Une automatisation du build
  • Une gestion des informations sur le projet
  • Un processus de build cohérent entre les projets

Configuration d'un projet Maven

Créons un nouveau projet en utilisant Maven :

  1. Tout d'abord, vérifiez si Maven est installé :
mvn --version

Vous devriez voir une sortie similaire à celle-ci :

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"
  1. Accédez à votre répertoire de projet :
cd /home/labex/project
  1. Créez un nouveau projet Maven en utilisant un archetype (un modèle de projet) :
mvn archetype:generate \
  -DgroupId=com.example.calculator \
  -DartifactId=simple-calculator \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DarchetypeVersion=1.4 \
  -DinteractiveMode=false

Cette commande créera un nouveau projet avec une structure de répertoire standard.

  1. Examinez la structure du projet :
cd simple-calculator
ls -la

Vous devriez voir une sortie similaire à :

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

Le fichier clé ici est pom.xml (Project Object Model), qui définit la configuration du projet.

  1. Examinez la disposition standard des répertoires Maven :
find src -type d

Vous devriez voir :

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

Voici la disposition standard des répertoires Maven :

  • src/main/java : Code source
  • src/main/resources : Fichiers de ressources
  • src/test/java : Code de test
  • src/test/resources : Ressources de test
  1. Examinons le fichier App.java généré :
cat src/main/java/com/example/calculator/App.java

Vous devriez voir une simple classe "Hello World" :

package com.example.calculator;

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

Amélioration du projet Maven

Améliorons notre projet de calculatrice en ajoutant plus de classes :

  1. Créez un nouveau fichier appelé Calculator.java dans 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;
    }
}
  1. Maintenant, modifiez le fichier App.java existant pour utiliser notre classe Calculator :
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!");
    }
}
  1. Compilez le projet en utilisant Maven :
mvn compile

Vous devriez voir une sortie se terminant par :

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
  1. Emballer l'application dans un fichier JAR :
mvn package

Cette commande compile votre code, exécute les tests et empaquette l'application.

  1. Exécutez l'application empaquetée :
java -cp target/simple-calculator-1.0-SNAPSHOT.jar com.example.calculator.App

Vous devriez voir la sortie suivante :

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

Comprendre le fichier POM Maven

Le fichier Project Object Model (POM) contient la configuration du projet. Ouvrez le fichier pom.xml dans l'éditeur et examinez sa structure :

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

Éléments clés du fichier POM :

  • groupId : Identifiant de l'organisation ou du projet
  • artifactId : Nom du projet
  • version : Version du projet
  • dependencies : Bibliothèques externes utilisées par le projet
  • build : Configuration pour la compilation du projet

Commandes clés de Maven

Voici quelques commandes essentielles de Maven :

  • mvn compile : Compile le code source
  • mvn test : Exécute les tests
  • mvn package : Crée un paquet distribuable (JAR, WAR)
  • mvn install : Installe le paquet dans le référentiel local
  • mvn clean : Supprime les artefacts de build (répertoire target)
  • mvn clean install : Combinaison de clean et install

Maven a considérablement simplifié la gestion des projets Java en fournissant des conventions, une gestion des dépendances et une automatisation du build. Cette approche standardisée aide les développeurs à se concentrer sur l'écriture de code plutôt que sur la gestion de la structure du projet.

Résumé

Dans ce laboratoire, vous avez appris des stratégies essentielles pour gérer la structure des projets Java grâce à des exercices pratiques :

  1. Vous avez commencé par créer manuellement une structure de projet Java de base, en comprenant les composants fondamentaux des répertoires de code source, des packages et de l'organisation du code compilé.

  2. Vous avez ensuite passé à la création d'un projet plus complexe avec une bonne organisation des packages, en mettant en œuvre la séparation des préoccupations en divisant la fonctionnalité en packages de modèle, de service et d'utilitaires.

  3. Enfin, vous avez appris à utiliser Maven, un puissant outil d'automatisation de build, pour créer et gérer des projets Java standardisés avec une gestion des dépendances et des processus de build automatisés.

Ces compétences de base constitueront une solide base pour vos futurs travaux de développement Java, vous permettant de créer des applications bien organisées, maintenables et évolutives. En suivant les conventions établies et les meilleures pratiques en matière de structure de projet, vous collaborerez plus efficacement avec d'autres développeurs et produirez un code de meilleure qualité.

Connexe Java Cours
Java pour débutants

Java pour débutants

java
Exercices de programmation Java

Exercices de programmation Java

java
Insertion en bloc de données dans un emploi du temps de cours

Insertion en bloc de données dans un emploi du temps de cours

java