Java 9 – Tudo o que você precisa saber sobre os recursos do novo Java

Java, a linguagem de programação altamente acessível tem sido um acéfalo para desenvolvedores em todo o mundo. Desde a sua criação em 1995, a linguagem tem sido amplamente utilizada em vários setores.

Hoje, você encontrará Java em seus telefones. Alimentando o sistema operacional Android e a infinidade de aplicativos que o Android oferece. É usado para desenvolver jogos como o Minecraft, que possui uma enorme base de jogadores. Ele também é usado em aplicativos de negócios, como ler informações de cartão de crédito em caixas e alimentar as informações entre os sistemas e os bancos.

Após um intervalo de 3 anos, o Java lançou sua nova edição – Java SE 9. Com várias mudanças arquitetônicas importantes e recursos complementares, o Java SE 9 oferece uma solução poderosa pela qual os desenvolvedores ansiavam.

O Java 7 adicionou try-with-resource em 2011, oferecendo melhor funcionalidade de gerenciamento de recursos.
O Java 8 adicionou expressões lambda, uma boa jogada, mas um pouco falha no paradigma OOP.

Agora as Soluções Java permitem que os programadores tenham métodos privados. Métodos estáticos privados! Sim, você leu certo!

O Java SE 8 ofereceu muitas mudanças estruturais que foram recebidas com emoções mistas pelos desenvolvedores. Principalmente, estas são as deficiências do Java SE 8 que o Java SE 9 tentou superar:

1. O JDK não era navegável para o pequeno dispositivo de computação
2. Não houve melhoria geral no desempenho do aplicativo
3. Não havia segurança e manutenção geral do JDK
4. Os desenvolvedores Java enfrentaram dificuldades para construir e manter as bibliotecas de código e aplicativos maiores

Então, vamos ver as principais mudanças e aprimoramentos que o Java 9 oferece em relação aos seus predecessores

Atualizações de API de processo no Java 9

Tradicionalmente, a API do Java tem sido de natureza primitiva. Esse suporte para iniciar novos processos, redirecionar fluxos de saída e erros. No Java 9, as novas atualizações da API do processo permitem:

1. Obtendo o PID do processo JVM atual e de qualquer outro
2. Gerenciando subprocessos
3. Gerenciando subprocessos
4. Obtenha informações como PID, nome e uso de recursos dos processos em execução no sistema.

Este é um código de exemplo, que imprime o PID atual, bem como as informações do processo atual:

public class NewFeatures
{
public static void main(String [] args)
{
ProcessHandle currentProcess = ProcessHandle.current();
System.out.println("PID:"+ currentProcess.getPid());
ProcessHandle.Info currentProcessInfo = currentProcess.info();
System.out.println("Info:" + currentProcessInfo);
}
}


Cliente HTTP/2 em Java 9

Espera-se que esse recurso seja reformado nas versões subsequentes ou pode até ser removido completamente.
Anteriormente, os desenvolvedores dependiam das bibliotecas de terceiros, por exemplo, Apache HTTP, Jersey e muitos outros. A API HTTP do Java é anterior à especificação HTTP/1.1 e é síncrona e difícil de manter. Essas limitações exigiram a necessidade de adicionar uma nova API. A nova API do cliente HTTP fornece o seguinte:

1. Uma API simples e concisa para lidar com a maioria das solicitações HTTP
2. Suporte para especificação HTTP/2
3. Melhor performance
4. Melhor segurança
5. Mais algumas melhorias

Aqui está um trecho de código para fazer uma solicitação HTTP GET usando as novas APIs. Este é o módulo conforme definido no arquivo module-info.java:

module newfeatures{
requires jdk.incubator.httpclient;
}

O código a seguir usa a API de cliente HTTP. Esta é uma parte do módulo jdk.incubator.httpclient :

import jdk.incubator.http.*;
import java.net.URI;
public class Http2Feature{
public static void main(String[] args) throws Exception{
HttpClient client = HttpClient.newBuilder().build();
HttpRequest request = HttpRequest
.newBuilder(new URI(http://httpbin.org/get;))
.GET()
.version(HttpClient.Version.HTTP_1_1)
.build();
HttpResponse.String response = client.send(request,
HttpResponse.BodyHandler.asString());
System.out.println("Status code:" + response.statusCode());
System.out.println("Response Body:" + response.body());
}
}
}

Mais recursos de atualizações de simultaneidade no Java 9

Com o Java 9, uma nova classe chamada – java.util.concurrent.Flow foi introduzida, que suporta a implementação de uma estrutura de publicação-assinatura. Essa estrutura permite que os desenvolvedores criem componentes. Esses componentes podem consumir de forma assíncrona uma transmissão ao vivo de dados configurando editores que produzem os dados e assinantes que consomem os dados. Estas são as novas interfaces:

• java.util.concurrent.Flow.Publisher
• java.util.concurrent.Flow.Subscriber
• java.util.concurrent.Flow.Subscription
• java.util.concurrent.Flow.Processor (que atua como Publicador e Assinante).

Java Shell Scripting (Read-Eval-Print-Loop) em Java 9

O objetivo do Projeto Kulla era investigar a adição da ferramenta REPL (Read-Eval-Print-Loop) para Java 9. Esta versão do Java apresenta uma ferramenta de linha de comando especial chamada JShell. O objetivo aqui é popularizar e maximizar o uso do REPL. Então, o que isso significa? Agora, você não precisa agrupar algumas linhas de código em um método separado para executá-las. Eficiente? Eu digo sim.
Por exemplo, em Scala, um programa simples Hello World é escrito como scala>println(“Hello World”);
Vamos executar o comando JShell, conforme mostrado na imagem a seguir:

Projeto Jigsaw em Java 9

O trunfo dos novos recursos do Java 9 é o sistema all-newmodule. A criação de sistemas complexos geralmente envolve códigos complexos de alto nível que resultam em ambiguidade. Com a complexidade do código, dois problemas fundamentais são enfrentados: O encapsulamento do código é difícil e não há noção de dependências explícitas entre os diferentes arquivos JAR de um sistema. Cada classe pública pode ser acessada por qualquer outra classe pública no caminho de classe. Isso leva ao uso desnecessário de classes que não deveriam ser API pública. Além disso, o próprio caminho de classe é problemático: como você sabe se todos os JARs necessários estão lá e as entradas duplicadas? O sistema de módulos resolve ambos os problemas.
É aqui que a natureza robusta do Java 9 é vista. Os arquivos JAR modulares contêm um descritor de módulo adicional. Neste descritor de módulo, instruções `requires` são usadas para expressar dependências em outros módulos. Além disso, as instruções `exports` controlam quais pacotes são acessíveis a diferentes módulos. Por padrão, todos os pacotes não exportados são encapsulados no módulo.

Existem vários PEC, que fazem parte deste projeto, como segue:

JEP 200 – JDK modular: Aplica o sistema de módulos da plataforma Java para modularizar o JDK que pode ser combinado em tempo de compilação, tempo de construção ou tempo de execução.
JEP 201 – código fonte modular: usado para criar módulos e permite construir ferramentas para compilar os módulos criados
JEP 220 – imagens de tempo de execução modulares: este JEP melhora o desempenho, a segurança e a capacidade de manutenção reestruturando as imagens de tempo de execução JDK e JRE para acomodar módulos
JEP 282 – O jlink, conhecido como Java linker: usos como módulos de empacotamento e suas dependências em menos tempo de execução.

Arquivos JAR de várias versões

Para aproveitar os novos recursos da plataforma Java em versões mais recentes, os desenvolvedores da biblioteca devem lançar uma versão mais recente de sua biblioteca. Em breve, haverá várias versões da biblioteca sendo mantidas pelos desenvolvedores, o que pode ser catastrófico. Para superar essa limitação, o Java 9 apresenta vários lançamentos de arquivos JAR, permitindo que os desenvolvedores criem arquivos JAR com diferentes versões de arquivos de classe para diferentes versões do Java. Dê uma olhada neste exemplo.

Uma ilustração dos arquivos JAR atuais da seguinte forma:

raiz de jarro
- Uma aula
– Classe B
– Classe C

Veja como são os arquivos JAR de várias versões:

raiz de jarro

- Uma aula
– Classe B
– Classe C
– META-INF
– versões
– – 9
- - - - Uma aula
– – 10
– – – – Classe B

Na ilustração anterior, os arquivos JAR suportavam arquivos de classe para duas versões Java 9 e 10. Assim, quando o JAR é executado na versão 9 do Java, as pastas A.class nas versões – 9 são selecionadas para execução.

Nas versões anteriores do Java que não oferecem suporte a arquivos JAR de várias versões, as classes no diretório de versões nunca são usadas. Portanto, se você executar o arquivo JAR de várias versões no Java 8, é tão bom quanto executar um arquivo JAR simples.

Na minha opinião, as coisas estão começando a mudar com Java. E esta é uma tendência crescente. Isso significa que a popularidade do Java e seu uso serão afetados? De jeito nenhum. Java foi e ainda é uma linguagem de programação incrivelmente poderosa e robusta na indústria de tecnologia hoje. Comece a aprender Java e veja isso fazer a diferença em sua carreira. Boa sorte!

Nota do autor:
Esse artigo técnico é uma contribuição de Sumit, que trabalha em tecnologias de tendências, como DevOps, Big Data e Python. E na equipe de Marketing Digital da Edureka.