Comment ajouter plusieurs fichiers jar dans classpath dans linux

D'accord, je suis très nouveau pour linux et la ligne de commande, et assez nouveau pour java. J'ai obtenu un stage de construction d'un programme java. J'ai finalement obtenu fait sur ma machine (windows), et maintenant, je dois migrer une machine linux pour tester et ensuite l'exécuter en tant qu'un fichier exécutable. J'ai fait beaucoup de lecture et de recherches sur linux et comprendre les chemins de classe, mais il est encore très difficile de comprendre pleinement. C'est juste en ne cliquant pas pour moi encore. Quelqu'un peut-il expliquer le but de classpath de manière simplifiée à l'aide d'exemples? L'un des plus déroutant aspects pour moi, c'est réellement définir le chemin d'accès physique à la jarre. Dois-je commencer, tout le chemin de l'usr ou dois-je seulement besoin pour commencer à partir de la jvm dossier? Si c'est important, mon programme java n'est pas situé dans la jvm dossier. Quelqu'un peut jeter un peu de lumière pour moi?

EDIT: merci beaucoup les gars pour votre aide, je ne peux pas dire que je suis entièrement en clair, mais ma compréhension de ma situation est beaucoup mieux.

source d'informationauteur exit_1

10

Vous utilisez le -classpath argument. Vous pouvez utiliser un chemin relatif ou absolu. Ce qui signifie que vous pouvez utiliser un chemin relatif au répertoire courant, OU vous pouvez utiliser un chemin absolu qui commence à la racine /.

Exemple:
```
bash$ java -classpath path/to/jar/file MyMainClass
```
Dans cet exemple, le main fonction se trouve dans MyMainClass et serait inclus dans le fichier jar.

Pour la compilation vous avez besoin d'utiliser javac

Exemple:
```
bash$ javac -classpath path/to/jar/file MyMainClass.java
```
Vous pouvez également spécifier le chemin de la classe via la variable d'environnement, suivez cet exemple:
```
bash$ export CLASSPATH="path/to/jar/file:path/tojar/file2"
bash$ javac MyMainClass.java
```
Pour tout normalement complexe projet java vous devriez regarder le script ant nommé build.xml
16

Dire que vous avez plusieurs fichiers jar a.jar,b.jar et c.jar. Pour les ajouter au classpath lors de la compilation vous avez besoin de faire
```
$javac -cp .:a.jar:b.jar:c.jar HelloWorld.java
```
À exécuter ne
```
$java -cp .:a.jar:b.jar:c.jar HelloWorld
```
5

Le chemin de la classe est l'endroit(s) où le compilateur java (commande: javac) et la JVM (commande:java) afin de trouver des classes de votre application de référence.
Que signifie, pour une application de référence à une autre classe ? En d'autres termes, signifie l'utilisation de cette classe, quelque part dans son code:

Exemple:
```
public class MyClass{
    private AnotherClass referenceToAnotherClass;
    .....
}
```
Lorsque vous essayez de compiler ce (javac) le compilateur aura besoin de la AnotherClass classe. De même lorsque vous essayez d'exécuter votre application: la machine aura besoin de la AnotherClass classe.
Afin de trouver cette classe, l'javac et la JVM regarder dans un (ensemble de) place(s). Ces endroits sont spécifiés par le classpath qui sur linux est un colon liste de répertoires séparés (répertoires où le javac/JVM devriez regarder pour localiser le AnotherClass quand ils en ont besoin).

Afin de compiler votre classe, puis de l'exécuter, vous devez vous assurer que le classpath contient le répertoire contenant le AnotherClass classe. Ensuite, vous l'appelez comme ceci:
```
javac -classpath "dir1;dir2;path/to/AnotherClass;...;dirN" MyClass.java //to compile it
java -classpath "dir1;dir2;path/to/AnotherClass;...;dirN" MyClass //to run it
```
Généralement les classes viennent sous la forme de "paquets" appelé les fichiers jar/bibliothèques. Dans ce cas, vous devez assurez-vous que le récipient contenant de l'AnotherClass classe est sur votre classpaht:
```
javac -classpath "dir1;dir2;path/to/jar/containing/AnotherClass;...;dirN" MyClass.java //to compile it
java -classpath ".;dir1;dir2;path/to/jar/containing/AnotherClass;...;dirN" MyClass //to run it
```
Dans les exemples ci-dessus, vous pouvez voir comment compiler une classe (MyClass.java) situé dans le répertoire de travail, puis exécutez la classe compilée (Notez le "." au début du chemin de classe qui représente répertoire courant). Ce répertoire doit être ajouté au classpath. Sinon, la JVM ne sera pas en mesure de le trouver.

Si vous avez votre classe dans un fichier jar, comme vous l'avez précisé dans la question, alors vous devez assurez-vous que le pot est dans le classpath trop , avec le reste de la nécessaire répertoires.

Exemple:
```
java -classpath ".;dir1;dir2;path/to/jar/containing/AnotherClass;path/to/MyClass/jar...;dirN" MyClass //to run it
```
ou plus générale (en supposant qu'une hiérarchie de paquet):
```
java -classpath ".;dir1;dir2;path/to/jar/containing/AnotherClass;path/to/MyClass/jar...;dirN" package.subpackage.MyClass //to run it
```
Afin d'éviter le chemin de la classe à chaque fois que vous voulez exécuter une application, vous pouvez définir une variable d'environnement appelée CLASSPATH.

Dans linux, dans l'invite de commande:
```
export CLASSPATH="dir1;dir2;path/to/jar/containing/AnotherClass;...;dirN" 
```
ou de modifier le ~/.bashrc et ajoutez cette ligne quelque part à la fin;

Cependant, le chemin de classe est soumis à de fréquents changements, donc, que vous aimeriez peut-être avoir le classpath définie sur un ensemble de base de dirs, dont vous avez besoin fréquemment, et s'étend ensuite le chemin de la classe à chaque fois que vous avez besoin pour cette session uniquement. Comme ceci:
```
export CLASSPATH=$CLASSPATH:"new directories according to your current needs" 
```
0

L'étape 1.
```
vi ~/.bashrc
```
L'étape 2. Ajouter cette ligne à la dernière:
```
export CLASSPATH=$CLASSPATH:/home/abc/lib/*;  (Assuming the jars are stored in /home/abc/lib) 
```
L'étape 3.
```
source ~/.bashrc
```
Après ces étapes direct compiler et exécuter vos programmes(par exemple: javac xyz.java)

Vous devez vous connecter pour publier un commentaire.