Como criar uma requisição POST com Java

     Neste artigo vou mostrar como fazer um POST usando Java. Este código é valido para qualquer versão, mas no Java 11 introduziram uma nova forma de fazer que você pode estar vendo nesse link: Fazendo requisições com HTTP Client do Java 11

 

     Segue aqui o código: 

 

import java.io.BufferedReader; import java.io.DataOutputStream; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URL; public class Java8Post { public static void main(String[] args) throws Exception { String url = "https://exemplo.com/requisicao"; URL obj = new URL(url); HttpURLConnection connection = (HttpURLConnection) obj.openConnection(); // Configurar a requisição como POST connection.setRequestMethod("POST"); // Adicionar cabeçalhos necessários connection.setRequestProperty("Content-Type", "application/json"); // Habilitar o envio de dados na requisição connection.setDoOutput(true); String requestBody = "{\"chave\": \"valor\"}"; // Enviar o corpo da requisição DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream()); outputStream.writeBytes(requestBody); outputStream.flush(); outputStream.close(); // Obter a resposta da requisição int responseCode = connection.getResponseCode(); System.out.println("Código de resposta: " + responseCode); BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream())); String inputLine; StringBuffer response = new StringBuffer(); while ((inputLine = reader.readLine()) != null) { response.append(inputLine); } reader.close(); System.out.println("Resposta: " + response.toString()); } }

 

     Pra esse artigo é só. 

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

Consumindo API Rest com Spring Boot usando a classe WebClient

           Nesse artigo vou mostrar como fazer um cliente para uma API Rest com Spring 5 usando a classe WebClient que é parte do novo WebFlux Framework. Esse cliente vai consumir uma API de Livros. Aproveitando o post, já vou criar esse cliente em uma classe de teste usando JUnit para mostrar o teste de APIs com ele. Mas a forma de uso aqui não se limita a testes.

         

Como o foco é a construção de um cliente para consumir uma API, vou omitir o código da API, trazendo só a construção do cliente. Então vamos ao código:

 

import java.util.List;

import org.junit.jupiter.api.Assertions

import org.junit.jupiter.api.BeforeAll;

import org.junit.jupiter.api.Test;

import org.springframework.core.ParameterizedTypeReference;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpMethod;

import org.springframework.http.MediaType;

import org.springframework.web.reactive.function.client.WebClient;

import org.springframework.web.reactive.function.client.WebClient.Builder;

import org.springframework.web.reactive.function.client.WebClient.ResponseSpec;

 

import br.com.socialbooks.model.Livro;

import reactor.core.publisher.Mono;

 

class LivroControllerTest {

 

       @BeforeAll

       static void inserirLivro() {

             // configura uma requisição

             Builder builder = WebClient.builder();

             builder.baseUrl("http://localhost:8080");

 

             Livro livro = new Livro("Aprendendo Spring boot");

 

             // prepara o cliente

             WebClient client = builder.build();

             ResponseSpec response = client.method(HttpMethod.POST).uri("/livros").bodyValue(livro).retrieve();

 

             // recebendo o recurso salvo

             Mono<Livro> monoLivro = response.bodyToMono(Livro.class);

             livro = monoLivro.block();

       }

 

       @Test

       void testGetListaLivros() {

             // configura uma requisição

             Builder builder = WebClient.builder();

             builder.baseUrl("http://localhost:8080");

             builder.defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);

 

             // prepara o client

             WebClient client = builder.build();

             ResponseSpec response = client.method(HttpMethod.GET).uri("/livros").retrieve();

 

             /*

              * recebe o Mono que executa de forma assíncrona. OBS: Para carregar uma lista

              * de objetos, é preciso usar o ParameterizedTypeReference.

              */

             Mono<List<Livro>> monoLivro = response.bodyToMono(new                  ParameterizedTypeReference<List<Livro>>() {

             });

 

             // como funciona de forma assincrona, usamos o block para forçar ele esperar a resposta.

             List<Livro> livros = monoLivro.block();

 

              Assert.assertTrue(livros.get(0).getTituloLivro().equals("Aprendendo Spring boot"));

 

       }

 

       @Test

       void testGetLivro() {

             // configura uma requisição

             Builder builder = WebClient.builder();

             builder.baseUrl("http://localhost:8080");

             builder.defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);

 

             // prepara o client

             WebClient client = builder.build();

             ResponseSpec response =             client.method(HttpMethod.GET).uri("/livros/1").retrieve();

             // recebe o Mono que executa de forma assíncrona

             Mono<Livro> monoLivro = response.bodyToMono(Livro.class);

 

             // como funciona de forma assincrona, usamos o block para forçar ele esperar 

             // a resposta.

             Livro livro = monoLivro.block();

             Assert.assertTrue(livro.getTituloLivro().equals("Aprendendo Spring boot"));

       }

}

 

Pra esse artigo é só.

Esse artigo foi baseado estudos feitos em:

https://www.baeldung.com/spring-webclient-json-list

https://www.youtube.com/watch?v=Q1BjCuAQRrQ&list=LL&index=4

Usando JUnit para testar acesso a webservice

 Essa postagem traz um código simples de testes para um acesso a webservice:

import javax.ws.rs.client.Client;

import javax.ws.rs.client.ClientBuilder;

import javax.ws.rs.client.WebTarget;

import org.junit.Assert;

import org.junit.Test;

public class teste {

    @Test

    public void testaQueAConexaoComOServidorFunciona() {

        Client client = ClientBuilder.newClient();

        WebTarget target = client.target( "http://www.mocky.io" );

        String conteudo = target.path( "/v2/52aaf5deee7ba8c70329fb7d" ).request().get( String.class );

        System.out.println( conteudo );

        Assert.assertTrue( conteudo.contains( "Rua Vergueiro 3185" ) );

    }

}

Lendo conteúdo de uma URL no Java

       Nesse artigo vou mostrar como ler um conteúdo de uma URL via Java. Isso é útil para ler um XML ou JSON disponibilizado por um site um sistema externo por exemplo.

public void lerConteudoURL() {
       
        String noticia;
        try {
            URL url = new URL("endereço_web");

            HttpURLConnection.setFollowRedirects(true);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setConnectTimeout(3000);
            connection.setRequestProperty("Accept-Charset", "text/xml; charset=UTF-8");
            int codeMessage = connection.getResponseCode();

            if(HttpURLConnection.HTTP_OK == codeMessage) {
                InputStream buffer = new BufferedInputStream(connection.getInputStream());
                BufferedReader reader = new BufferedReader(new InputStreamReader(buffer, "UTF-8"));
                String line = reader.readLine();
               
                while (line !=null) {
                   
                    //conteúdo da linha
                    System.out.println(line);
                   
                    //pega a próxima linha
                    line = reader.readLine();
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        }

}