In deze sectie wordt beschreven hoe u het Java-buildpad moet instellen. Het buildpad is het klassenpad dat wordt gebruikt voor het bouwen van een Java-project (IJavaProject).
Een klassenpad is gewoon een array van klassenpadgegevens (IClassPathEntry) waarmee de typen worden beschreven die beschikbaar zijn. De typen kunnen voorkomen in een bronvorm of binaire vorm en met de volgorde van de gegevens in het pad wordt de zoekvolgorde gedefinieerd voor het omzetten van typen tijdens een build.
Het Java-buildpad wordt weergegeven in de structuur van een Java-projectelement. U kunt in een project de pakketfragmentenhoofdmappen opvragen (IPackageFragmentRoot). Elk klassenpadgegeven is toegewezen aan een of meer pakketfragmentenhoofdmappen, die elk weer een set pakketfragmenten bevatten.
In deze bespreking van het buildpad wordt geen aandacht besteed aan het Java-runtimepad, dat onafhankelijk van het buildpad kan worden gedefinieerd. (Zie Java-code uitvoeren voor een bespreking van het runtime-klassenpad.)
U kunt het buildpad van een project programmatisch wijzigen met behulp van
setRawClasspath in het bijbehorende Java-element van het project. Met de volgende code wordt het klassenpad voor een projectresource ingesteld:
IProject project = ... // een projectresource ophalen
IJavaProject javaProject = JavaCore.create(project);
IClasspathEntry[] newClasspath = ...;
javaProject.setRawClasspath(newClasspath, someProgressMonitor);
(Opmerking: het gebruik van de term "raw" klassenpad wordt gebruikt om het feit te benadrukken dat eventuele variabelen die zijn gebruikt om vermeldingslocaties te beschrijven niet zijn omgezet.)
Het Java-buildpad wordt bevroren in een bestand met de naam '.classpath' in de bestandsstructuur van het project. Het doel van dit bestand is dat de instellingen van het Java-buildpad gemeenschappelijk door anderen kunnen worden gebruikt via een bepaalde broncoderepository. Dit bestand moet vooral niet handmatig worden bewerkt, omdat het beschadigd kan raken.
Klassenpadgegevens kunnen worden gedefinieerd met behulp van factorymethoden die zijn gedefinieerd inJavaCore. Klassenpadgegevens kunnen naar het volgende verwijzen:
Het volgende is een voorbeeld van een klassenpadgegeven waarmee de bronmap 'src' van project
'MyProject' wordt aangegeven:
IClassPathEntry srcEntry = JavaCore.newSourceEntry(new Path("/MyProject/src"));
Het volgende is een voorbeeld van een klassenpadgegeven waarmee de klassenbestandmap 'lib' van 'MyProject' wordt aangegeven:
IClassPathEntry libEntry = JavaCore.newLibraryEntry(
new Path("/MyProject/lib"),
null, //no source
null, //no source
false); //not exported
Het volgende klassenpadgegeven heeft een bronbijlage:
IClassPathEntry libEntry = JavaCore.newLibraryEntry(
new Path("d:/lib/foo.jar"), // library location
new Path("d:/lib/foo_src.zip"), //source archive location
new Path("src"), //source archive root path
true); //exported
In het bronarchiefhoofdmappad wordt de locatie van de hoofdmap beschreven in het bronarchief. Als het wordt ingesteld op null, wordt de hoofdmap van het archief dynamisch afgeleid.
Het volgende klassenpadgegeven geeft een vereist project 'MyFramework' aan.
IClassPathEntry prjEntry = JavaCore.newProjectEntry(new Path("/MyFramework"), true); //exported
U kunt een automatische klassenpadvariabele-initiatorvariabele initiator registreren die wordt aangeroepen via het extensiepunt org.eclipse.jdt.core.classpathVariableInitializer als het werkgebied wordt gestart
Het volgende klassenpadgegeven geeft een bibliotheek aan waarvan de locatie wordt bewaard in de variabele 'HOME'. De bronbijlage wordt gedefinieerd met behulp van de variabelen 'SRC_HOME' en 'SRC_ROOT':
IClassPathEntry varEntry = JavaCore.newVariableEntry(
new Path("HOME/foo.jar"), // bibliotheeklocatie
new Path("SRC_HOME/foo_src.zip"), // bronarchieflocatie
new Path("SRC_ROOT"), // bronarchiefhoofdmappad
true); // geëxporteerd
JavaCore.setClasspathVariable("HOME", new Path("d:/mijnInstallatie"), null); // geen voortgangsbewaking
U kunt een automatische klassenpadcontainer-initiator registreren die latent wordt aangeroepen via het extensiepuntorg.eclipse.jdt.core.classpathContainerInitializer als de container moet worden verbonden.
Het volgende klassenpadgegeven geeft een systeemklassebibliotheekcontainer aan:
IClassPathEntry varEntry = JavaCore.newContainerEntry(
new Path("JDKLIB/default"), // container 'JDKLIB' + hint 'default'
false); // niet geëxporteerd
JavaCore.setClasspathContainer(
new Path("JDKLIB/default"),
new IJavaProject[]{ myProject }, // waarde voor 'myProject'
new IClasspathContainer[] {
new IClasspathContainer() {
public IClasspathEntry[] getClasspathEntries() {
return new IClasspathEntry[]{
JavaCore.newLibraryEntry(new Path("d:/rt.jar"), null, null, false);
};
}
public String getDescription() { return "Eenvoudige JDK-bibliotheekcontainer"; }
public int getKind() { return IClasspathContainer.K_SYSTEM; }
public IPath getPath() { return new Path("JDKLIB/basic"); }
}
},
null);
Aan een klassenpadbrongegeven kan een uitsluitingspatroon worden toegewezen, waarmee wordt voorkomen dat bepaalde resources in een bronmap zichtbaar zijn in het klassenpad. Als u een patroon gebruikt, kunnen opgegeven gedeelten van de resourcestructuur worden uitgefilterd. Elk uitsluitingspatroon is relatief aan het klassepadgegeven en maakt gebruik aan een patroonmechanisme dat lijkt op Ant. Uitsluitingspatronen kunnen worden gebruikt om geneste bronmappen op te geven zolang het buitenste patroon het binnenste patroon uitsluit.
Zie getExclusionPatterns voor meer informatie over uitsluitingspatronen.
Met de Java-project-API isOnClasspath worden zowel de opname- als uitsluitingspatronen gecontroleerd, voordat vastgesteld of een bepaalde resource zich in het klassenpad bevindt.
Opmerking:
IPath sourceFolder = new Path("/MyProject/src"); IPath outputLocation = sourceFolder.append("bin"); IClassPathEntry srcEntry = JavaCore.newSourceEntry( sourceFolder, // bronmaplocatie new Path[] { outputLocation }, // uitgesloten geneste map outputLocation); // uitvoerlocatie
Aan een klassepadbrongegeven kan ook een opnamepatroon worden toegewezen, waarin expliciet wordt gedefinieerd dat resources zichtbaar moeten zijn op het klassenpad. Als er geen opnamepatronen zijn opgegeven, bevat het brongegeven alle relevante bestanden in de resourcestructuur in het pad van dit brongegeven. Als er een om meer uitsluitingspatronen worden opgegeven, betekent dit dat alleen de opgegeven gedeelten van de resourcestructuur moeten worden opgenomen. Elk opgegeven pad moet een relatief pad zijn en wordt relatief aan het pad van dit brongegeven geïnterpreteerd. Bestandspatronen zijn hoofdlettergevoelig. Een bestand dat overeenkomt met een of meer van deze patronen is opgenomen in de pakketfragmenthoofdmap tenzij deze wordt uitgesloten door een of meer van de uitsluitingspatronen van dit gegeven.
Zie getExclusionPatterns
voor een bespreking van de syntaxis en de semantiek van padpatronen. De afwezigheid van uitsluitingspatronen is semantisch equivalent aan het expliciete opnamepatroon. **
.
Met de Java-project-API isOnClasspath worden zowel de opname- als uitsluitingspatronen gecontroleerd, voordat vastgesteld of een bepaalde resource zich op het klassenpad bevindt.
Voorbeelden:
src/**
worden alle bestanden opgenomen onder een hoofdmap met de naam src
.
src/**
en tests/**
bevatten alle bestanden onder de hoofdmappen met de naamsrc
en tests
.
src/**
samen met het uitsluitingspatroon src/**/Foo.java
bevatten alle bestanden onder een hoofdmap met de naam src
behalve de bestanden met de naam Foo.java
.