Esta seção descreve como definir o caminho de construção Java. O caminho de construção é o classpath utilizado para construção de um produto Java(IJavaProject).
Um classpath é simplesmente uma matriz de entradas de classpath (IClassPathEntry) que descreve os tipos disponíveis. Os tipos podem aparecer no formato de origem ou binário e a seqüência das entradas no caminho define a ordem de consulta para resolução de tipos durante uma construção.
O caminho de construção Java é refletido na estrutura de um elemento de projeto Java. Você pode consultar um projeto para obter suas raízes de fragmentos do pacote(IPackageFragmentRoot). Cada entrada do classpath faz o mapeamento até uma ou mais raízes de fragmentos do pacote e cada uma delas contém, além disso, um conjunto de fragmentos do pacote.
Esta discussão sobre o caminho de construção não envolve o caminho de tempo de execução Java, o qual pode ser definido separadamente do caminho de construção. (Consulte Executando código Java para obter uma discussão sobre o classpath de tempo de execução.
É possível alterar, através de programação, o caminho de construção de um projeto
setRawClasspath no elemento Java do projeto correspondente. O código a
seguir define o classpath para um recurso do projeto:
IProject project = ... // obter algum recurso de projeto
IJavaProject javaProject = JavaCore.create(project);
IClasspathEntry[] newClasspath = ...;
javaProject.setRawClasspath(newClasspath, someProgressMonitor);
(Nota: O termo "raw" classpath é utilizado para enfatizar que variáveis utilizadas para descrever localizações de entrada não foram resolvidas.)
O caminho de construção Java permanece em um arquivo chamado '.classpath' na estrutura de arquivos do projeto. A finalidade deste arquivo é fornecer uma maneira para compartilhar as definições do caminho de construção Java com outros através de algum repositório de código fonte. Especificamente, esse arquivo não deve ser editado manualmente, pois poderá ser danificado.
As entradas de classpath podem ser definidas com os métodos de fábrica definidos em JavaCore. As entradas de classpath podem fazer referência a qualquer um dos seguintes:
Segue
abaixo um exemplo de entrada de classpath que indica a pasta de origem 'src' do projeto 'MyProject':
IClassPathEntry srcEntry = JavaCore.newSourceEntry(new Path("/MyProject/src");
Segue um exemplo da entrada de classpath que indica a pasta do arquivo de classe 'lib' do 'MyProject':
IClassPathEntry libEntry = JavaCore.newLibraryEntry(
new Path("/MyProject/lib"),
null, //sem origem
null, //sem origem
false); //não exportado
A entrada de classpath a seguir possui uma conexão de origem:
IClassPathEntry libEntry = JavaCore.newLibraryEntry(
new Path("d:/lib/foo.jar"), // localização da biblioteca
new Path("d:/lib/foo_src.zip"), //localização do archive de origem
new Path("src"), //caminho raiz do archive de origem
true); //exportado
O caminho raiz do archive de origem descreve a localização da raiz no archive de origem. Se definido como nulo, a raiz do archive será inferida dinamicamente.
A entrada de classpath a seguir indica um projeto pré-requisito 'MyFramework'.
IClassPathEntry prjEntry = JavaCore.newProjectEntry(new Path("/MyFramework"), true); //exportado
É possível registrar um inicializador de variável de classpath automático que é chamado através do ponto de extensão org.eclipse.jdt.core.classpathVariableInitializer quando o espaço de trabalho é iniciado.
A entrada de classpath a seguir indica uma biblioteca cuja localização é mantida na
variável 'HOME'. A conexão de origem é definido utilizando as
variáveis 'SRC_HOME' e 'SRC_ROOT' :
IClassPathEntry varEntry = JavaCore.newVariableEntry(
new Path("HOME/foo.jar"), // localização da biblioteca
new Path("SRC_HOME/foo_src.zip"), //localização do archive de origem
new Path("SRC_ROOT"), //caminho raiz do archive de origem
true); //exportado
JavaCore.setClasspathVariable("HOME", new Path("d:/myInstall"), null); // sem progresso
É possível registrar um inicializador de contêiner de classpath automático que é chamado lentamente através do ponto de extensão org.eclipse.jdt.core.classpathContainerInitializer quando o contêiner precisa ser ligado.
A entrada de classpath a seguir indica um contêiner de biblioteca de classe do sistema:
IClassPathEntry varEntry = JavaCore.newContainerEntry(
new Path("JDKLIB/default"), // contêiner 'JDKLIB' + dica 'default'
false); //não exportado
JavaCore.setClasspathContainer(
new Path("JDKLIB/default"),
new IJavaProject[]{ myProject }, // valor para '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 "Basic JDK library container"; }
public int getKind() { return IClasspathContainer.K_SYSTEM; }
public IPath getPath() { return new Path("JDKLIB/basic"); }
}
},
null);
Um padrão de exclusão pode ser atribuído a uma entrada de origem do classpath, o que impede que determinados recursos em uma pasta de origem fiquem visíveis no classpath. O uso de um padrão permite que partes especificadas da árvore de recursos sejam removidas. Cada caminho de padrão exclusivo é correspondente à entrada do classpath e utiliza um mecanismo de padrão semelhante ao Ant. Os padrões de exclusão pode ser utilizados para especificar pastas de origem aninhadas contanto que o padrão externo exclua o padrão interno.
ConsultegetExclusionPatterns() para obter detalhes adicionais sobre padrões de exclusão.
A API do projeto Java,isOnClasspath, verifica os padrões de exclusão antes de determinar se um determinado recurso está no classpath.