Trabalhando com Arquivos (File) e Array de Bytes no Java

     As vezes precisamos transformar um arquivo em array de bytes e visse e versa seja para guardar o arquivo em banco ou tranferir na rede, e aqui seguem duas funções para fazer esse De-Para:

        public byte[] convertFileToByte(File file){
FileInputStream fileInputStream=null;
byte[] bFile = new byte[(int) file.length()];
try {
    //convert file into array of bytes
fileInputStream = new FileInputStream(file);
fileInputStream.read(bFile);
fileInputStream.close();
   
}catch(Exception e){
e.printStackTrace();
}
return bFile;
}

public File convertByteToFile(byte[] bYtes){
File file = new File("file");
BufferedOutputStream bos;
try {
bos = new BufferedOutputStream(new FileOutputStream(file));
bos.write(bYtes); 
bos.close(); 
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} 
return file;
}

Aplicando Máscara CNPJ em um campo no SQL Server

 

Muitas vezes os campos como CNPJ e CPF são guardados no banco de dados sem a formatação e pode acontecer de precisarmos pegar eles já formatados.

 

Bom, segue abaixo um exemplo de função que formata no padrão CNPJ, e que também serve de base para formatar um CPF.

 

DECLARE @cnpj CHAR(14) = '3477929600012'; -- Insira o CNPJ aqui

 

SELECT

STUFF(STUFF(STUFF(STUFF(

RIGHT('00000000000000' + @cnpj, 14), -- Completa com zeros à esquerda

3, 0, '.'), 7, 0, '.'), 11, 0, '/'), 16, 0, '-') AS CNPJformatado;

 

Primeiro são acrescentados 14 zeros a esquerda e então a função RIGHT é usada para pegar os últimos 14 dígitos do CNPJ, sendo assim, não importa quantos números faltem, eles serão preenchidos com zeros.

 

A função STUFF é aplicada em posições específicas para inserir os pontos, a barra e o traço usados na formatação do CNPJ.

 

Pra este artigo é só, espero que ajude.

Juntando Strings JSON

     Nesse artigo vou mostrar um método que junta até 3 JSONs em um só, sendo que qualquer um deles pode vir vazio ou nulo. Esse método foi usado para uma integração onde recebia até 3 respostas e precisava tratá-las como uma na aplicação. 

private String montaJson(String json, String json2, String json3) {

if(json != null && !json.isEmpty()){

    json = json.trim().substring(0, json.lastIndexOf("]"))+",";

    if(json2 != null && !json2.isEmpty()){

json += json2.trim().substring(1, json2.lastIndexOf("]"))+",";

if(json3 != null && !json3.isEmpty()){

json += json3.trim().substring(1);

} else {

    json = json.trim().substring(0, json.lastIndexOf(","))+"]";

}

    } else if(json3 != null && !json3.isEmpty()) {

json += json3.trim().substring(1, json3.lastIndexOf("]"));

    } else {

        json = json.trim().substring(0, json.lastIndexOf(","))+"]";

    }

} else {

if(json2 != null && !json2.isEmpty()){

    json = json2.trim().substring(0, json2.lastIndexOf("]"))+",";

    if(json3 != null && !json3.isEmpty()) {

        json += json3.trim().substring(1);

    } else {

              json = json.trim().substring(0, json.lastIndexOf(","))+"]";

    }

} else if(json3 != null && !json3.isEmpty()){

    json = json3.trim();

}

}

return json;

}

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ó. 

Uso de transações e variáveis em SQL Server, Oracle e PostgreSQL

Neste artigo vou mostrar o uso de transação e de declaração de variável nos Bancos de Dados mais utilizados: SQL Server, Oracle e PostgreSQL.

 

As vezes você pode por exemplo usar um SELECT pra retornar um ID e guardar ele em uma variável para depois fazer várias ações com ele, e essas ações precisam ser feitas por completo ou então você precisa desfazer o que foi executado parcialmente. Nos exemplos a seguir, o trecho que executa o DELETE serve como exemplo para aonde as ações seriam colocadas.

 

Segue o exemplo para SQL Server:

 

BEGIN TRANSACTION;

      DECLARE @nomeVariavel tipoVariavel; (alguns tipos como CHAR e VARCHAR precisam do tamanho entre parenteses junto ao tipo : varchar(30))

      SELECT @nomeVariavel = coluna

      FROM tabela WHERE condição;

      DELETE FROM tabela

      WHERE coluna = @nomeVariavel;

 

IF @@ERROR <> 0

      BEGIN

      ROLLBACK TRANSACTION;

      END

ELSE

      BEGIN

            COMMIT TRANSACTION;

      END

 

Segue o exemplo para Oracle:

 

DECLARE nome_da_variavel datatype;

BEGIN

nome_da_variavel := valor;

 

DELETE FROM tabela WHERE coluna = nome_da_variavel;

              

BEGIN

                

EXCEPTION WHEN others THEN

                 ROLLBACK;

                 RAISE;

              

END;

COMMIT;

END;

 

E por fim, segue o exemplo para PostgreSQL:

 

BEGIN;

DECLARE nome_da_variavel datatype;

nome_da_variavel := valor;

 

DELETE FROM tabela WHERE coluna = nome_da_variavel;

 

BEGIN

    EXCEPTION WHEN others THEN

        ROLLBACK;

        RAISE;

END;

COMMIT;

 

Pra esse artigo é isso, espero que ajude.

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\": \"John\", \"age\": 30}";

        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