terça-feira, 23 de maio de 2023

Fazendo requisições com HTTP Client do Java 11

     O Java 11 introduziu uma API nativa para fazer chamadas HTTP, substituindo o pacote java.net.HttpURLConnection. Isso facilitou o desenvolvimento de aplicativos que consomem serviços da web. Essa nova API traz:

 

1. Simplicidade de Uso: A nova API apresenta uma interface de programação mais simples e intuitiva em comparação com o HttpURLConnection. Ela utiliza uma abordagem baseada em métodos fluentes(Fluent Interface), que permitem o encadeamento das chamadas, facilitando a construção de solicitações e o processamento de respostas.

2.  Suporte Nativo a Requisições Assíncronas: A API oferece suporte nativo a chamadas assíncronas, permitindo que você faça solicitações HTTP de forma não bloqueante e aproveite os benefícios do processamento paralelo.

3. Manipulação de Cookies: facilita a manipulação de cookies em solicitações e respostas HTTP. Você pode facilmente adicionar, remover ou ler cookies com métodos simples e diretos.

4. Tratamento de Redirecionamentos Automáticos: lida automaticamente com redirecionamentos HTTP, seguindo as respostas de redirecionamento e fornecendo a resposta final após a conclusão do redirecionamento.

5.  Suporte a Protocolos Modernos: oferece suporte nativo a protocolos modernos como HTTP/2 e WebSocket, permitindo uma comunicação mais eficiente e otimizada com servidores.

6.  Extensibilidade: é projetada para ser extensível, permitindo que você adicione ou modifique facilmente recursos e comportamentos.

 

Segue um exemplo de uso do acesso ao endereço desse blog:

 

   private static void lendoURLcomJava11() {

           try {

                HttpRequest request = HttpRequest.newBuilder()

                     .GET()

                     .uri(URI.create("http://olamundo-java.blogspot.com"))

                     .build();

          

                HttpClient httpClient = HttpClient.newHttpClient();

               

                HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());

               

                System.out.println(response.statusCode());

                System.out.println(response.body());

               

           }catch (Exception e) {

                e.printStackTrace();

           }

  }


Caso queira por exemplo fazer um POST em uma API REST poderia fazer da seguinte maneira:

 

   private static void fazendoPostParaRestApi() {    

        HttpClient httpClient = HttpClient.newBuilder()

                .build();

 

        // Construindo a URI da API REST

        String apiUrl = "https://api.example.com/data";

        URI uri = URI.create(apiUrl);

 

        // Criando o corpo da solicitação POST

        String requestBody = "{\"name\": \"Daniel\", \"Idade\": 34}";

        HttpRequest httpRequest = HttpRequest.newBuilder()

                .uri(uri)

                .header("Content-Type", "application/json")

                .POST(BodyPublishers.ofString(requestBody))

                .build();

 

        try {

            // Enviando a solicitação

            HttpResponse<String> response = httpClient.send(httpRequest, HttpResponse.BodyHandlers.ofString());

 

            // Obtendo a resposta

            int statusCode = response.statusCode();

            String responseBody = response.body();

 

            // Exibindo a resposta

            System.out.println("Status Code: " + statusCode);

            System.out.println("Response Body: " + responseBody);

        } catch (Exception e) {

            e.printStackTrace();

        }

  }


Gerando Webservice SOAP a partir de um WSDL com Apache CXF

    Nesse artigo vou mostrar como gerar um Webservice SOAP a partir de um arquivo WSDL com a biblioteca Apache CXF.


    O CXF tem várias ferramentas, e uma delas é o WDLS to Java (wsdl2java). Com esse carinha podemos executar um comando e ler um WSDL gerando todas as classes Java necessárias.


  O download pode ser feito em https://cxf.apache.org/download.html. Baixe o zip e descompacte-o no C:

 

    Agora no Path nas variáveis de ambiente do Windows adicione o caminho para a pasta bin da versão do CXF que baixou. Nesse caso, como usei a 3.1.4 ficaria:

 

C:\apache-cxf-3.1.4\bin

 

    Isso permite usar a ferramenta em qualquer lugar pela linha de comando.

 

   O WSDL tem várias partes e pode ser usado tanto para gerar o servidor quanto o cliente. São elas:


1. Definições (Definitions): Essa sessão é a raiz do documento WSDL e contém todas as definições relacionadas ao serviço da Web. Ela define os namespaces utilizados, bem como os tipos de dados e as mensagens que serão utilizadas.

2. Tipos (Types): Nesta sessão, são definidos os tipos de dados utilizados pelos serviços da Web. Geralmente, esses tipos são definidos usando XML Schema Definition, que especifica a estrutura e as restrições dos dados ficando em um arquivo separado (XSD). Nesse caso é importante ter acesso aos 2 arquivos. Quando isso ocorre, na sessão Types vai ter o endereço (schemaLocation) do XSD e pode ser necessário que você altere para o local onde colocou os arquivos.

3. Mensagens (Messages): Aqui são definidas as mensagens utilizadas pelos serviços da Web. Uma mensagem é uma unidade lógica de dados que é trocada entre o cliente e o serviço. Cada mensagem é composta por partes, onde cada parte tem um nome e um tipo associado.

4. Porta (Port): Esta sessão define os pontos de extremidade (endpoints) disponíveis para acessar os serviços da Web. Um ponto de extremidade é uma combinação de um endereço de rede e um contrato, que define a interface para acessar o serviço.

5. Vinculação (Binding): Aqui são especificados os detalhes de vinculação para cada ponto de extremidade definido. A vinculação define como as mensagens serão transmitidas entre o cliente e o serviço, incluindo o protocolo de transporte utilizado (por exemplo, SOAP sobre HTTP) e os formatos de codificação de dados.

6.  Serviço (Service): Nesta sessão, são definidos os serviços específicos oferecidos pelos pontos de extremidade. Ela especifica os detalhes do serviço, como o nome, a localização e as operações suportadas.

 

    Uma vez com o CXF configurado e o arquivo WSDL em mãos (e o XSD se for o caso), utilize o seguinte comando para gerar as classes Java:

 

> wsdl2java -d <diretório_destino> -p <pacote_base> <caminho_para_arquivo_wsdl>

    

    Substitua <diretório_destino> pelo diretório onde deseja que as classes Java sejam geradas, <pacote_base> pelo pacote base que você deseja para as classes geradas (tipo: com.examplo.webservice) e <caminho_para_arquivo_wsdl> pelo caminho completo do arquivo WSDL que você deseja usar.


   As opções -server, -client e -impl são usadas para gerar classes específicas relacionadas a diferentes aspectos de um Webservice. Aqui está uma explicação de cada uma dessas opções:


1.   -server: Essa opção é usada para gerar as classes do lado do servidor, ou seja, as classes que implementam o serviço Web. Ao usar a opção -server, o wsdl2java gerará classes que podem ser usadas para implementar as operações do serviço definidas no WSDL. Essas classes geralmente contêm a lógica de negócios e a implementação real dos métodos do serviço Web.

2.   -client: Essa opção é usada para gerar as classes do lado do cliente, ou seja, as classes que são usadas para acessar e interagir com o serviço Web. Ao usar a opção -client, o wsdl2java gerará classes que permitem ao cliente chamar os métodos do serviço de forma conveniente. Essas classes geralmente lidam com a comunicação de rede, envio e recebimento de mensagens SOAP, bem como a tradução entre os objetos Java e o formato XML usado nas mensagens SOAP.

3.  -impl: Essa opção é usada para gerar as classes de implementação do serviço. Ela é útil quando se deseja gerar somente as classes de implementação do serviço Web, sem as classes do lado do cliente ou do lado do servidor. Essas classes de implementação contêm a lógica de negócios e são responsáveis por processar as solicitações recebidas do lado do cliente e retornar as respostas correspondentes.


    Pronto, com isso as classe podem ser geradas da forma que atendam sua necessidade.

 

 

Fonte: 

https://cxf.apache.org/

https://cxf.apache.org/docs/wsdl-to-java.html

quarta-feira, 26 de abril de 2023

Usar número da linha como ID em um SELECT no SQL Server

         Nesse artigo vou mostrar 2 maneiras de como usar o número da linha como ID trazendo ele na consulta. Isso é util quando queremos por exemplo usar um DTO (ou VO) em uma consulta com JPA mas na consulta não tem campos que são sempre únicos para servir de ID para o DTO e o JPA precisa de um ID único.

   A primeira usamos o ROW_NUMBER e a segunda criamos uma SEQUENCE. Em "MEU_SELECT_COM_JOINS" você substitui por toda sua consulta que carrega os dados que você precisa para o DTO e pronto.


--------------------------------------------------
-- row_number(): SQL2005+
--------------------------------------------------
select
    row_number() over (order by (select null)) id,
    tabela_.*

from (MEU_SELECT_COM_JOINS) as tabela_
 
 
--------------------------------------------------
-- Sequence: SQL2012+
--------------------------------------------------
-- Criando sequencia
if object_id('sLinhas') is not null drop sequence sLinhas
create sequence sLinhas as int start with 1
 
select
    next value for sLinhas as id,
    tabela_.*

from (MEU_SELECT_COM_JOINS) as tabela_


terça-feira, 14 de março de 2023

Alterando encoding de arquivos no Linux

 As vezes precisamos mudar o Encoding de um arquivo para corrigir os caracteres estranhos.


Para descobrir a codificação de origem pode-se usar a ferramenta file, exemplo:


$ file [nome_arquivo]


Exemplo de conversão de ISO-8859-1 para UTF-8:


$ iconv -f iso-8859-1 -t utf-8 arquivo.txt > arquivo_novo.txt


Uma dica importante é criar um novo arquivo pra saída, pois assim você não perde seus dados... (ele apaga mesmo!) Crie um novo arquivo, verifique se está tudo certo e somente depois sobrescreva o arquivo original.

segunda-feira, 13 de março de 2023

Alternando entre versões do Java no Linux

        Nesse artigo vou mostrar como mudar da versão do Java em um servidor Linux. Essa mudança altera a versão padrão em uso pelo servidor, embora aplicações possam apontar diretamente para uma versão ao invés de usar a versão padrão definida para o servidor.


$ sudo update-alternatives --config java


       Irá aparecer a lista de versões disponíveis e você pode digitar o número correspondente a versão desejada e depois confirmar com Enter.




       Este comando também é útil para ver onde as versões foram instaladas no servidor, porque ele mostra o caminho completo. Importante lembrar que algumas versões que possam ter sido baixadas e descompactadas não irão aparecer.




segunda-feira, 6 de março de 2023

Particionando, Formatando e Montando discos no Linux

 

Nesse artigo vamos mostrar como montar um disco no Linux. Ao adicionar um novo disco, físico ou lógico dependendo do ambiente, é necessário adicioná-lo ao sistema. Esse processo é chamado de montagem.

 

Para vermos os discos disponíveis podemos usar o comando lsblk:

 

$ sudo lsblk

 

Antes de montar é necessário particionar e formatar o disco. Os discos seguem uma ordem alfabética: sda (principal), sdb (segundo), sdc (terceiro)... e assim por diante. Vamos seguir como se fosse o segundo disco. Primeiro vamos particionar:

 

$ fdisk /dev/sdb

 

Então o fdisk vai pedir algumas opções para poder particionar o disco e oferecer a opção “m” para ajuda. Para particionar como uma única partição primária de dados você pode fornecer a opção “n” e depois escolher “p” para a primária. Depois siga o prompt confirmando o número de partições (que é 1) e o início e fim dela. Após receber a mensagem que a partição foi criada, digite “w” para confirmar as alterações no disco.

 

Para formatar digite:

 

$ mkfs.ext4 /dev/sdb

 

Caso queira uma partição onde o Windows possa enxergar também use NTFS.

 

Agora vamos à montagem do disco para uso. As montagens podem ser feitas em qualquer pasta do sistema, porém existe um diretório padrão para isso que o /mnt.

 

Vamos imaginar que vamos montá-lo na pasta chamada “arquivos”. Primeiro criamos a pasta:

 

$ mkdir /mnt/arquivos

  

Agora fazemos a montagem apontando o disco para a pasta:

 

$ mount /dev/sdb /mnt/arquivos

 

Dessa maneira o disco está montado e disponível, a menos que o sistema seja reiniciado. Para manter o disco montado sempre que o sistema ligar ainda é necessário automatizar essa montagem. Abra o arquivo fstab que fica no etc e acrescente a seguinte linha informando o disco, pra onde vai e o sistema de arquivos, além do padrão “defaults 0 0”:

 

$ /dev/sdb /mnt/arquivos ext4 defaults 0 0

 

Agora é só salvar o arquivo e ele sempre será montado ao iniciar o sistema.