comment utiliser le fichier de classe d'une autre guerre

Nous avons deux différentes applications web et nous voulons prolonger de quelques contrôleurs de la guerre dans une autre guerre.

Nous sommes à l'aide de maven pour construire le projet.

de la guerre nous ont donné sa dépendance

<dependency>
            <groupId>com.abc.exchange</groupId>
            <artifactId>employer</artifactId>
            <version>2.3.M2-SNAPSHOT</version>
            <type>war</type>
            <scope>compile</scope>
        </dependency>

Il est incapable de construire donnant classe ne trouve pas exception.

Tout organisme peut m'aider comment faire?

J'obtiens l'erreur maven build failed :

[INFO] ------------------------------------------------------------------------
[ERROR] Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:2.3.2:compile (default-compile) on project agent-war: Compilation failure: Compilation failure:
[ERROR] \projects\trunk_new\agent\src\main\java\com\platform\agent\web\AgentEmployeeController.java:[22,41] cannot find symbol
[ERROR] symbol  : class EmployeeController
[ERROR] location: package com..platform.employer.web

source d'informationauteur Zuned Ahmed

17

Vous pouvez définir la guerre plugin pour produire un distinct fichier jar qui est disponible par l'intermédiaire d'un classificateur basé sur la configuration:
```
<configuration>
  ..
  <attachClasses>true</attachClasses>
  <archiveClasses>true</archiveClasses>
</configuration>
```
Après que vous pouvez l'utiliser comme une dépendance distincte dans d'autres projets. Mais le mieux pour faire un autre pot module.
7

Ce que vous faites est à l'aide d'un La GUERRE de fichier de superposition. Maven prend en charge cette. Cependant...

La GUERRE plugin s'exécute dans le package phase. N'importe quel plugin, tels que le compilateur Java (qui s'exécute dans la phase de compilation), qui s'exécute avant cette phase ne verrez pas les fichiers de la GUERRE plugin a extrait. (ici est la liste de référence de toutes les phases Maven si ça peut aider)

Si vous avez la possibilité de restructurer le projet de la structure, la meilleure façon est de créer un traditionnel POT de projet avec vos contrôleurs et les deux Guerres tirer de ce BOCAL en tant que dépendance.

Si il ya une raison pourquoi vous ne pouvez pas faire cela, vous aurez besoin de faire quelque chose comme:
1. Configurer la GUERRE plugin pour exécuter dans une phase antérieure à compilecomme generate-resources et permet de s'assurer de l'extraction de la superposition des fichiers de classe à ${project.build.outputDirectory}.
2. Vous pouvez également utiliser la Dépendance Maven Plugin décompresser but d'extraire des classes à partir de la dépendance de la GUERRE de ${project.build.outputDirectory}.
Mais je ne le recommande si possible de revoir vos contrôleurs dans un POT, il est beaucoup plus facile et plus maintenable.
4

mettre les contrôleurs dans un nouveau pot de projet et dépendances de votre webprojects à ce contrôleur.

Ajouter les plugins suivants de votre part maven guerre module (pour la création de la guerre et un pot de l'artefact en même temps):

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.4</version>
            <executions>
                <execution>
                    <id>make-a-jar</id>
                    <phase>compile</phase>
                    <goals>
                        <goal>jar</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>       
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-install-plugin</artifactId>
            <version>2.4</version>
            <executions>
                <execution>
                    <phase>install</phase>
                    <goals>
                        <goal>install-file</goal>
                    </goals>
                    <configuration>
                        <packaging>jar</packaging>
                        <artifactId>${project.artifactId}</artifactId>
                        <groupId>${project.groupId}</groupId>
                        <version>${project.version}</version>
                        <file>
                            ${project.build.directory}/${project.artifactId}-${project.version}.jar
                        </file>
                    </configuration>
                </execution>
            </executions>
        </plugin>

puis ajouter la dépendance à votre charge maven guerre module.

1

Java EE visibilité des normes de l'état que les classes d'une guerre ne devraient pas être disponibles pour les classes dans une autre guerre, lorsqu'ils sont emballés que d'une OREILLE. La plupart des conteneurs de faire respecter cette stricte.

Vous devez mettre le code que vous souhaitez partager dans un BOCAL et de l'inclure comme une dépendance dans la guerre que vous voulez utiliser.

Dans la guerre de projet pom.xml inclure

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
        <version>2.1.1</version>
        <configuration>
            <attachClasses>true</attachClasses>
        </configuration>
</plugin>

Cela va créer your-project-0.0.1-SNAPSHOT-clases.jar dans le dossier cible avec la guerre.

Dans le projet dépendant pom.xml inclure

 <dependency>
        <groupId>com.yourproject</groupId>
        <artifactId>you-project</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <classifier>classes</classifier>
  </dependency>

Cela a fonctionné pour moi. Espérons que cela aide.

Edit: Si nous voulons seulement certains fichiers de classe dans le bocal puis l'ajouter à pom.xml

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
            <version>2.4</version>
                <executions>
                    <execution>
                        <id>make-a-jar</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                            <configuration>
                                <classifier>classifier_name</classifier>
                                <includes>
                                    <include>com/../..</include>
                                </includes>
                            </configuration>
                    </execution>
                </executions>
     </plugin>

Dans le projet dépendant pom.xml inclure

 <dependency>
        <groupId>com.yourproject</groupId>
        <artifactId>you-project</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <classifier>classifier_name</classifier>
  </dependency>

remarque: le nom de classificateur doit être la même dans les deux pom.xml fichiers

Vous devez vous connecter pour publier un commentaire.