Compilando o Código Java

Os plug-ins do JDT incluem um compilador Java batch e incremental para construir arquivos Java .class a partir do código fonte. Não há uma API direta fornecida pelo compilador. Ela é instalada como um construtor em projetos Java. A compilação é disparada utilizando mecanismos de construção de plataforma padrão.

Há uma descrição detalhada do mecanismo de construção da plataforma em Construtores de projetos incrementais .

Código de Compilação

É possível de maneira programática, compilar os arquivos fonte Java em um projeto que utilize a API de construção.

   IProject myProject;
IProgressMonitor myProgressMonitor;myProject.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, myProgressMonitor);

Para um projeto Java, isso chamará o construtor de projeto incremental Java (juntamente com outros construtores de projeto incrementais que tenham sido incluídos na especificação de construção do projeto). Os arquivos .class gerados são gravados na pasta de saída designada. Os arquivos de recurso adicionais também são copiados para a pasta de saída.  

No caso de uma construção em batch completa, todos os arquivos .class na pasta de saída poderão ser 'apagados' para assegurar que nenhum arquivo stale seja encontrado. Isto é controlado através do uso de uma Opção do Construtor de Núcleo do JDT (CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER).  O padrão para esta opção é limpar pastas de saída.  A menos que esta opção seja redefinida, certifique-se de colocar todos os arquivos .class, para os quais você não tenha arquivos de origem correspondentes, em uma pasta de arquivos de classe separada no classpath em vez de na pasta de saída.

Os construtores incremental e em batch podem ser configurados com outras opções que controlam quais recursos são copiados para a pasta de saída.   A amostra a seguir mostra como configurar um filtro de recursos para que arquivos que terminam com '.ignore' e pastas chamadas 'META-INF', não sejam copiados para a pasta de saída:

      Opções da tabela de hashing = JavaCore.getOptions();
   options.put(JavaCore.CORE_JAVA_BUILD_RESOURCE_COPY_FILTER, "*.ignore,META-INF/");
   JavaCore.setOptions(options);

Os nomes de arquivos serão filtrados se corresponderem a um dos padrões fornecidos. Pastas inteiras serão filtradas se seus nomes corresponderem a um dos nomes de pasta fornecidos que terminarem em um separador de caminho.

Os construtores incremental e em lote também podem ser configurados para gerar apenas um único erro quando o arquivo .classpath tiver erros. Esta opção é definida por padrão e elimina muitos erros.  Consulte Opções do Construtor de Núcleo do JDT para obter uma lista completa das opções relacionadas ao construtor e seus padrões.

O compilador também pode ser configurado utilizando as opçõesJavaCore.   Você pode definir, por exemplo, a gravidade a ser utilizada para diferentes tipos de problemas encontrados durante a compilação.  ConsulteOpções do Compilador de Núcleo do JDT para obter uma lista de opções relacionadas ao compilador e seus padrões.

Ao configurar, através de programação, opções para o construtor ou compilador, é preciso determinar o escopo da opção.  Por exemplo, a configuração de um filtro de recursos pode se aplicar apenas a um projeto específico. O exemplo a seguir configura o mesmo filtro de recursos mostrado anteriormente, mas o define apenas para o projeto específico.

   
   Hashtable options = myProject.getOptions(false);  // obter somente as opções configuradas neste projeto
   options.put(JavaCore.CORE_JAVA_BUILD_RESOURCE_COPY_FILTER, "*.ignore,META-INF/");
   myProject.setOptions(options);

Utilizando o Adaptador Ant Javac

O compilador Eclipse pode ser utilizado dentro do script Ant utilizando o adaptador javac. Para utilizar o compilador Eclipse, será necessário apenas definir a propriedade build.compiler em seu script. A seguir, um pequeno exemplo.
<?xml version="1.0" encoding="UTF-8"?>
<project name="compile" default="main" basedir="../.">

	<property name="build.compiler" value="org.eclipse.jdt.core.JDTCompilerAdapter"/>

	<property name="root" value="${basedir}/src"/>

	<property name="destdir" value="d:/temp/bin" />

	<target name="main">
		<javac srcdir="${root}" destdir="${destdir}" debug="on" nowarn="on" extdirs="d:/extdirs" source="1.4">
		    <classpath>
		      <pathelement location="${basedir}/../org.eclipse.jdt.core/bin"/>
		    </classpath>
		</javac>		
	</target>
</project>
A sintaxe utilizada para a tarefa javac Ant pode ser encontrada na documentação da tarefa Ant javac . O adaptador atual suporta a tarefa Javac Ant 1.4.1. Uma versão 1.5 estará disponível quando Ant 1.5 for liberado.

Determinação de Problemas

O Núcleo do JDT define um marcador especializado (tipo de marcador "org.eclipse.jdt.core.problem ") para indicar problemas de compilação. Para descobrir os problemas detectados pelo compilador de maneira programática, deve-se utilizar o protocolo de marcador de plataforma padrão. Consulte Marcadores de Recursos para obter uma visão geral da utilização de marcadores.

O seguinte trecho procura todos os marcadores de problemas Java em uma unidade de compilação.

   public IMarker[] findJavaProblemMarkers(ICompilationUnit cu)          throws CoreException {
IResource javaSourceFile = cu.getUnderlyingResource();IMarker[] markers = javaSourceFile.findMarkers(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER,true, IResource.DEPTH_INFINITE);   }

Os marcadores de problemas Java são mantidos pelo construtor de projeto Java e são removidos automaticamente à medida que os problemas são resolvidos e a origem Java é recompilada.

O valor do id do problema é definido por uma das constantes em IProblem . O id do problema é confiável, mas a mensagem é localizada e, portanto, pode ser alterada de acordo com o locale padrão. As constantes definidas em IProblem são autodescritivas.

Uma implementação de IProblemRequestor deve ser definida para coletar os problemas descobertos durante uma operação Java. As cópias de trabalho poderão ser reconciliadas com a detecção de problemas se um IProblemRequestor tiver sido fornecido para a criação da cópia de trabalho. Para conseguir isso, você pode utilizar o método reconcile. Por exemplo:

  ICompilationUnit unit = ..; // obter alguma unidade de compilação
			
  // criar solicitante para acumular problemas descobertos
  IProblemRequestor problemRequestor = new IProblemRequestor() {
    public void acceptProblem(IProblem problem) {
      System.out.println(problem.getID() + ": " + problem.getMessage());
    }
    public void beginReporting() {}
    public void endReporting() {}
    public boolean isActive() {	return true; } // detectará problemas se ativo
  };
    
  // utilizar cópia de trabalho para reter origem com erro
  IWorkingCopy workingCopy = (IWorkingCopy)unit.getWorkingCopy(null, null, problemRequestor);
  ((IOpenable)workingCopy).getBuffer().setContents("public class X extends Zork {}");

  // reconciliação do disparo
  workingCopy.reconcile(true, null);
Você pode incluir uma ação sobre os problemas relatados no método acceptProblem(IProblem). Neste exemplo, o problema relatado será que Zork não pode ser resolvido ou não é uma superclasse válida e seu id é IProblem.SuperclassNotFound .

Copyright IBM Corporation e outros 2000, 2003. Todos os Direitos Reservados.