Se você já mexeu com java imaginou esse código aqui certo?
public class Main {
public static void main (String[] args) {
System.out.println("Hello world!");
}
}
E se eu te disser que esse segundo código faz a mesma coisa:
void main() {
System.out.println("Hello world!");
}
Sim, essa estrutura é do recurso unnamed classes, inserido como preview no java 21, mas acredito que para próxima release LTS isso já pode estar habilitado!🤞🏻
Mas ai você pode argumentar que para executar esse arquivo você precisaria da JRE, configurar o java nas variáveis de ambiente e toda a parafernalha necessária para rodar um bytecode java em cada máquina onde for executar esse algoritmo.
Não é bem assim, a algum tempo foi criada a GraalVM, que trás o conceito de compilar o seu arquivo java para um binário nativo da máquina em que foi criado, ou seja, a partir deste momento você tem um binário executável na arquitetura + SO em que foi compilado.
O ponto negativo é claro, fica com relação a instalar os SDKs de cada SO para compilar nativo, em Linux Ubuntu é só um "sudo apt-get install build-essential libz-dev zlib1g-dev
" enquanto no Windows tem que instalar o Visual Studio com o pacote de Desktop development with C++ e marcar a opção de Windows SDK relativo a sua versão (11, 10, …), reserve por volta de 20GB no Windows 🥲.
A vantagem é que uma vez compilado você pode passar para qualquer outro computador com o mesmo SO e arquitetura que vai funcionar! Muito massa! Já pode compartilhar com seus colegas seu hello world executável em java!
Mão na massa!
Os passos são bem simples, basta compilar o seu .java com o javac como sempre foi, com o seguinte comando:
javac --enable-preview -source 21 Main.java
obs.: - enabled-preview -source 21 somente é necessário se for usar o recurso unnamed classes.
Em seguida usar o novo comando native- image para compilar:
native-image --enable-preview Main
se tudo ocorrer com sucesso, será criado um novo binário executável main.exe ou main se estiver no linux.
Para executar basta digitar o seguinte comando no terminal:
./main.exe
E pronto! Já é possível ver o seu "Hello World!" Aparecendo no terminal.
Este é o uso mais simples de compilação nativa do java usando como base um .class, mas também existe a compilação para um .jar, neste caso o comando é:
native-image -jar Main.jar myExecutableName
Se tudo ocorrer com sucesso será criado um executável com o nome myExecutableName.exe ou myExecutableName em linux.
Conclusão
Entre os principais ganhos em compilar nativo está a diminuição no tempo de inicialização e um menor consumo de recursos para executar seu algoritmo, em contraparte perdemos as otimizações que a JVM faz ao longo do cíclo de vida de uma aplicação, temos um garbage collector mais enxuto, ocorre um aumento no tempo de compilação e se torna necessário compilar para cada arquitetura onde o algoritmo será executado.
Por hoje é só pessoal! Se chegou até aqui muito obrigado!
Fontes:
https://openjdk.org/jeps/445
https://www.graalvm.org/latest/reference-manual/native-image/
https://www.graalvm.org/latest/docs/getting-started/
Top comments (1)
Eu amo essa feature, pois acredito que ajudará a diminuir o "medo" dos iniciantes, tornando a linguagem mais amigável. E, de quebra, ainda facilita quando a gente estiver testando ou prototipando ideias.
Infelizmente não. O apanhado features do JDK 22 já está fechado.
Ele virá com o segundo preview dessa feature que, inclusive, mudou de nome.
De Unnamed Classes passou a se chamar Implicitly Declared Classes segundo a JEP 463.
Não vejo a hora de chegar na versão final.