Comment faire un plugin architecture praticable?

Nous avons un couple d'anciens projets Java, qui nous nous sommes convertis à des projets Maven / modules. Auparavant, tous les projets ont été NetBeans projets et n'avait pas de véritable gestion de la dépendance. Dépendances externes existait sur le réseau d'entreprises en voiture et ont été directement inclus comme Pots dans NetBeans projets de chaque module. Pour les dépendances internes, projet simple, les références ont été utilisées. C'était une douleur pour construire tout ce que parce que le programmeur avait de tout construire dans le bon ordre.

Maintenant, nous sommes dans la position que l'on peut ouvrir tous les modules Maven dans IntelliJ IDEA et NetBeans. Cependant, j'ai du mal à comprendre la meilleure façon de combiner les différents modules et dépendances externes de manière spécifique, ce qui est conforme à l'plugin forme de la structure. Surtout avec NetBeans (en développement avec à la fois des IDEs doit être possible).

Voici comment les dépôts git / structure de projet ressemble plus ou moins. La structure du dossier des modules est la valeur par défaut de Maven structure pour chaque module. La fonctionnalité de liste de ce site a été trop maladroit, je l'ai donc inclus en tant que capture d'écran...

Nous avons une repository maven pour les trucs et construire avec maven, etc. est de travail. Pour Intellij IDÉE que j'ai d'exécuter et de déboguer le produit final pour customer1 via un custom configuration d'exécution, qui copie les fichiers nécessaires dans la structure nécessaire:

Avec IntelliJ IDEA, je peux déboguer le logiciel, mais je pense que l'approche (personnalisé IntelliJ exécuter config que j'ai créé, en montrant tous besoin de Pots et des fichiers directement) est assez moche, et pour NetBeans je ne pouvais pas trouver un semblable "run configuration" mécanisme.

J'ai donc essayé de réaliser ce processus de construction par la création d'un nouveau "Customer1Runnable" projet Maven comme une sorte de description de compilation, qui pointe à tous les besoin de Maven modules. Sur cette base, j'ai cru que je pouvais atteindre et automatisme pour créer le logiciel structure. Ergo copie de tous les modules dans un dossier du plugin et de toutes les dépendances des modules dans un dossier lib à l'intérieur de la Customer1Runnable projet, en utilisant le maven-assembly-plugin.

Tout d'abord, est mon hypothèse correcte que c'est un possible cas d'utilisation pour le maven-assembly-plugin?

Le projet lui-même n'a pas de fichiers source, c'est seulement une pom.xml et la assembly-config.xml descripteur. J'ai attaché l'assembly-plugin pour le paquet de phase. Lors de l'exécution de la mvn package commande tous les modules sont construits, mais pour l'exécution de l'assemblée-plugin-je obtenir la sortie suivante:

Pour commencer, j'ai seulement essayé d'inclure un module dans l'assemblée descripteur. C'est le XML (opicom-assembly.xml) pour cela:

<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.1.0"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.1.0 http://maven.apache.org/xsd/assembly-2.1.0.xsd">
    <id>opicom-assembly</id>
    <formats>
        <format>dir</format>
    </formats>
    <includeBaseDirectory>false</includeBaseDirectory>
    <moduleSets>
        <moduleSet>
            <useAllReactorProjects>true</useAllReactorProjects>
                <includes>
                    <include>my.company.reporting:module1</include>
                </includes>
        </moduleSet>
    </moduleSets>
</assembly>

pom.xml de Customer1Runnable projet

 <?xml version="1.0" encoding="UTF-8"?>
<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>
    <version>1.6</version>
    <groupId>my.company.customer1</groupId>
    <artifactId>OpicomRunnable</artifactId>
    <packaging>pom</packaging>
    <name>OpicomRunnable</name>
    
    <repositories>
        <repository>
            <id>Company-Maven-Repo</id>
            <url>file:\\\\MyCompany\TFSDrop\MavenRepo</url>
        </repository>
    </repositories>
    
    <modules>
        <module>../my.company.customer1.module1</module>
        <module>../my.company.customer1.module2</module>
        .
        .
        .
        <module>../../MyCompany_Common/Report/my.company.reporting.module1</module>
    </modules>  
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.3.0</version>
                <inherited>true</inherited>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <descriptors>
                        <descriptor>opicom-assembly.xml</descriptor>
                    </descriptors>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Le pom du module ressemble à ceci:

<?xml version="1.0" encoding="UTF-8"?>
<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>

    <parent>
        <groupId>my.company</groupId>
        <artifactId>reporting</artifactId>
        <version>1.3</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <artifactId>module1</artifactId>
    <version>1.3</version>
    <packaging>jar</packaging>



    <dependencies>
        <!-- external dependencies -->
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.6</version>
        </dependency>
        <dependency>
            <groupId>com.oracle.database.jdbc</groupId>
            <artifactId>ojdbc8</artifactId>
            <version>21.1.0.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <finalName>my-company-${project.artifactId}</finalName>
                    <appendAssemblyId>false</appendAssemblyId>
                    <outputDirectory>../build</outputDirectory>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Merci pour toute entrée sur ce que je fais de mal ici / comment réaliser cela avec Maven.

EDIT: Comme demandé, voici un exemple de projet en tant que Fichier ZIP. https://drive.google.com/drive/folders/1ilJeTrOPgYgUTdOP0J4BQcBnPT5fls0k?usp=sharing Les répertoires parents ModuleGroupCustomer et ModuleGroupCommon ne représentent dépôts git dans le scénario réel. La relative chemin d'accès du module est causé, parce que le projet maven qui devrait être mon "run configuration" points à projets maven dans les deux référentiels.

Je suis peut-être un malentendu Maven en général? J'y ai pensé en termes de cas d'utilisation pour la gestion de la dépendance similaire .Net les packages nuget, mais aussi comme "configuration de projet" comme ordinaire NetBeans/Intellij projets.

Est-il préférable de simplement tenir à l'existant NetBeans projets au jour le jour le développement?