Compilando arquivos Java via código

Para compilar arquivos Java via código é extremamente fácil:

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
int result = compiler.run( System.in, System.out, System.err, "SeuArquivo.java" );
if ( 0 == result ) {
	System.out.println( "Compilado!" );
}

A saída do processo de compilação é realizada na System.out e na System.err. O retorno sendo zero, indica sucesso na compilação.

Dica: Para usar esta classe, certifique-se que você está usando o compilador da JDK e não da JRE. As classes estão no pacote /lib/tools.jar da JDK, que não exise na JRE. Caso você precise, pode usar a minha dica anterior, para carregar este arquivo Jar dinamicamente. Para não ter que montar o caminho de seu JAVA_HOME manualmente, pegue-o da propriedade java.home do objeto System:

String toolJarPath = "file:///"
	+ System.getProperty( "java.home" ).replaceAll( "\\\\", "/" )
	+ "/lib/tools.jar";

Carregando JARs dinamicamente

Para carregar arquivos .jar dinamicamente e depois acessar uma de suas classes, você pode usar a java.net.URLClassLoader, passando para ela um arquivo usando o protocolo jar e usando !/ ao fim da string. Por exemplo:

String jarPath = "file:///C:/dev/Java/jdk1.7.0_05/lib/tools.jar";
String className = "com.sun.tools.javac.api.JavacTool";
		
try {
	// Monta a URL com o protocolo JAR e !/ ao fim do caminho do seu arquivo.
	URL url = new URL( "jar", "", jarPath + "!/" );
	// Configura o loader para carregar o JAR
	URLClassLoader loader = new URLClassLoader( new URL[] { url } );
	// Carrega sua classe
	Class< ? > clazz = loader.loadClass( className );
	System.out.println( "Carregada: " + clazz.getName() );			
} catch ( MalformedURLException e ) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} catch ( ClassNotFoundException e ) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} 

Com isso, você pode, por exemplo, tentar carregar dinamicamente algum Jar usado para fazer uma conexão JDBC, sem precisar colocar todos os arquivos de vários bancos de dados em seu projeto. Fica a dica…

No meu GitHub

Há uns meses criei uma conta no github, onde havia postado algumas bibliotecas de código C++ e PHP. Aos poucos pretendo ir adicionando bibliotecas, projetos e exemplos de código, usando também outras linguagens, como Java e JavaScript.

Na minha última atualização na php-util, por exemplo, adicionei um arquivo invoker.php, que permite invocar métodos PHP parametrizados numa requisição HTTP. Por exemplo:

<script type="text/javascript" src="jquery.js" ></script>
<script type='text/javascript' >
var data = { _c : 'SomeClass', _m : 'someMethod' };
var showResponse = function( response ) {
		alert( 'Success: ' + response.success
			+ ' Message: ' + response.message
			+ ' Data: ' + ( response.data ? response.data : '' )
			);
	}
$.post( 'invoker.php', data, showResponse, 'json' );
</script>

Será enviado para o invoker.php os parâmetros _c e _m com, respectivamente, o nome da classe e do método desta classe a ser invocado. O arquivo que contém a classe será automaticamente incluído, uma instância da classe criada, seu método invocado e seu retorno obtido. Sendo a execução realizada com sucesso ou não, o resultado será serializado como JSON e enviado de volta para o cliente encapsulado em um objeto Response.

Continuando com o exemplo acima, será invocado o método someMethod de uma classe SomeClass. Se esta classe for simplesmente definida como a abaixo, a string "hello" será retornada para o cliente.

<?php
class SomeClass {
	function someMethod() {
		return "hello";
	}
}
?>

Então, será enviada uma resposta para o cliente (em JSON) como:

{ "success" : true, "message" : "", "data" : "hello" }

Isto permite automatizar coisas repetitivas, como criar um arquivo PHP simplesmente para invocar o método desejado e obter seu retorno como JSON. O encapsulamento da resposta ao cliente sempre realizada através de um objeto de Response permite padronizar a comunicação, tornando mais fácil extrair os resultados das requisições.

Por exemplo, pode-se invocar um método de uma classe controladora que irá obter os parâmetros enviados (via POST) de um formulário e salvá-los, e então saber seu retorno.

Ou, por exemplo, invocar um método que retorna uma lista de objetos para serem apresentados na tela. Esse objetos serão colocados no parâmetro data da resposta (JSON) e poderão ser obtidos e manipulados facilmente pelo JavaScript.

Baixe o código, dê uma lida, mande sugestões, correções, dúvidas. Sempre que possível, tentarei colocar coisas úteis lá.