Como Realizar uma Transação Pix Usando a Inter SDK em Java com Spring Boot

O Banco Inter oferece uma SDK Java que facilita a integração de serviços como pagamentos Pix em suas aplicações. Neste artigo, vamos configurar o Inter SDK e implementar um serviço para realizar uma transação Pix usando Spring Boot.

Estrutura do Projeto

O projeto terá a seguinte estrutura de classes e arquivos de configuração:

/src/main/java
├── br/com/escconsulting/config/InterConfig.java
├── br/com/escconsulting/controller/InterPIXController.java
├── br/com/escconsulting/dto/InterIncluirPIXDTO.java
├── br/com/escconsulting/service/InterPIXService.java
├── br/com/escconsulting/service/InterPIXServiceImpl.java
└── resources/application.yml

1. Configuração do Ambiente

Antes de começarmos, configure o application.yml com as variáveis de ambiente para armazenar informações sensíveis, como credenciais de cliente e certificado.

Arquivo application.yml

# Configurações para integração com o Banco Inter
inter:
  client:
    id: ${INTER_CLIENT_ID}             # ID do cliente do Inter
    secret: ${INTER_CLIENT_SECRET}     # Segredo do cliente do Inter
  cert:
    path: ${INTER_CERT_PATH}           # Caminho para o certificado PFX
    password: ${INTER_CERT_PASSWORD}   # Senha do certificado PFX
  ambiente: ${INTER_AMBIENTE:sandbox}  # Define o ambiente (sandbox para testes)
  debug: ${INTER_DEBUG:false}          # Habilita ou desabilita o modo debug
  conta-corrente: ${INTER_CONTA_CORRENTE}  # Número da conta corrente

Defina as Variáveis de Ambiente

Defina essas variáveis de ambiente em seu sistema operacional, substituindo os valores conforme necessário:

• INTER_CLIENT_ID: ID do cliente fornecido pelo Banco Inter.
• INTER_CLIENT_SECRET: Segredo do cliente para autenticação.
• INTER_CERT_PATH: Caminho do certificado PFX.
• INTER_CERT_PASSWORD: Senha do certificado PFX.
• INTER_AMBIENTE: Ambiente de execução (sandbox ou producao).
• INTER_DEBUG: true para modo debug.
• INTER_CONTA_CORRENTE: Número da conta corrente.

2. Configuração da Inter SDK

Com o arquivo application.yml configurado, vamos criar a classe InterConfig para inicializar o SDK usando essas configurações.

Classe InterConfig

package br.com.escconsulting.config;

import inter.InterSdk;
import inter.exceptions.SdkException;
import lombok.Getter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@Getter
public class InterConfig {

    @Value("${inter.client.id}")
    private String clientId;

    @Value("${inter.client.secret}")
    private String clientSecret;

    @Value("${inter.cert.path}")
    private String certPath;

    @Value("${inter.cert.password}")
    private String certPassword;

    @Value("${inter.ambiente}")
    private String ambiente;

    @Value("${inter.debug}")
    private boolean debug;

    @Value("${inter.conta-corrente}")
    private String contaCorrente;

    @Bean
    public InterSdk interSdk() throws SdkException {
        InterSdk interSdk = new InterSdk(clientId, clientSecret, certPath, certPassword);
        interSdk.setAmbiente(ambiente);
        interSdk.setDebug(debug);
        interSdk.setContaCorrente(contaCorrente);
        return interSdk;
    }
}

3. Criando o DTO para a Requisição Pix

O DTO (Data Transfer Object) InterIncluirPIXDTO representará os dados necessários para a transação Pix, incluindo o ID da solicitação, a chave Pix do destinatário e o valor da transação.

Classe InterIncluirPIXDTO

package br.com.escconsulting.dto;

import lombok.Getter;
import java.math.BigDecimal;
import java.util.UUID;

@Getter
public class InterIncluirPIXDTO {
    private UUID customerVehicleWithdrawalRequestId;  // ID da solicitação de retirada
    private String chave;  // Chave Pix do destinatário
    private BigDecimal valor;  // Valor da transação Pix
}

4. Controlador REST para o Endpoint Pix

Vamos criar o controlador REST InterPIXController para expor um endpoint que recebe as requisições Pix.

Classe InterPIXController

package br.com.escconsulting.controller;

import br.com.escconsulting.dto.InterIncluirPIXDTO;
import br.com.escconsulting.service.InterPIXService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/inter/pix")
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class InterPIXController {

    private final InterPIXService interPIXService;

    @PostMapping
    public ResponseEntity<?> incluirPix(@RequestBody InterIncluirPIXDTO interIncluirPIXDTO) {
        return interPIXService.incluirPix(interIncluirPIXDTO)
                .map(savedBank -> ResponseEntity.status(HttpStatus.CREATED).body(savedBank))
                .orElseThrow(() -> new IllegalStateException("Falha ao realizar a transação Pix."));
    }
}

5. Serviço para Realizar a Transação Pix

O serviço InterPIXServiceImpl contém a lógica para criar e enviar a transação Pix.

Interface InterPIXService

package br.com.escconsulting.service;

import br.com.escconsulting.dto.InterIncluirPIXDTO;
import inter.banking.model.RespostaIncluirPix;
import java.util.Optional;

public interface InterPIXService {
    Optional<RespostaIncluirPix> incluirPix(InterIncluirPIXDTO interIncluirPIXDTO);
}

Implementação InterPIXServiceImpl

package br.com.escconsulting.service;

import br.com.escconsulting.dto.InterIncluirPIXDTO;
import inter.InterSdk;
import inter.banking.model.Destinatario;
import inter.banking.model.Pix;
import inter.banking.model.RespostaIncluirPix;
import inter.exceptions.SdkException;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.util.Optional;

@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class InterPIXServiceImpl implements InterPIXService {

    private final InterSdk interSdk;

    @Transactional
    @Override
    public Optional<RespostaIncluirPix> incluirPix(InterIncluirPIXDTO interIncluirPIXDTO) {
        try {
            // Configuração do destinatário e valor do Pix
            Destinatario destinatario = Destinatario.builder()
                    .chave(interIncluirPIXDTO.getChave())
                    .build();

            Pix pix = Pix.builder()
                    .valor(interIncluirPIXDTO.getValor())
                    .destinatario(destinatario)
                    .build();

            // Envia o Pix e obtém a resposta
            RespostaIncluirPix resposta = interSdk.banking().incluirPix(pix);

            System.out.println("Pix enviado com sucesso. e2eId=" + resposta.getEndToEndId());
            return Optional.of(resposta);

        } catch (SdkException e) {
            e.printStackTrace();
            return Optional.empty();
        }
    }
}

Explicação do Código

1. Configuração do Destinatário e Valor: O destinatário é configurado com a chave Pix fornecida no DTO, e o valor da transação é especificado.
2. Envio da Transação: O método incluirPix da InterSdk é chamado para realizar a transação.
3. Resposta: A resposta da transação é retornada, contendo detalhes como o ID e2eId.

Testando o Endpoint Pix

Para testar a integração:

1. Inicie a Aplicação: Execute o projeto Spring Boot.
2. Envie uma Requisição: Faça uma requisição POST para o endpoint /inter/pix com um corpo JSON, por exemplo: { "customerVehicleWithdrawalRequestId": "123e4567-e89b-12d3-a456-426614174000", "chave": "chave-do-destinatario", "valor": 150.00 }
3. Verifique a Resposta: Se tudo estiver correto, a transação Pix será realizada e uma resposta contendo detalhes do Pix será retornada.

Conclusão

Neste guia, configuramos o Inter SDK em uma aplicação Spring Boot para realizar transações Pix. Implementamos a configuração da SDK, o controlador REST e o serviço que envia a transação Pix. Essa solução proporciona uma integração direta e segura com o Banco Inter para pagamentos Pix em Java.

Como Personalizar a Mensagem de Inicialização no Spring Boot

Personalizar a mensagem de inicialização do Spring Boot é uma maneira eficaz de incluir detalhes sobre a aplicação, como seu nome e versão, além de tornar a inicialização mais agradável visualmente. Neste tutorial, vamos configurar o banner.txt para exibir uma arte ASCII e informações personalizadas.

1. Criando o Arquivo banner.txt

O Spring Boot permite que você adicione um banner ASCII na inicialização usando um arquivo chamado banner.txt. Esse arquivo deve ser colocado na pasta src/main/resources do seu projeto.

1. Crie o Arquivo: No diretório src/main/resources, crie o arquivo banner.txt.
2. Arte ASCII: Insira a arte ASCII de sua preferência. Você pode utilizar sites como https://patorjk.com/software/taag/ para gerar textos ASCII personalizados.

Exemplo de conteúdo do banner.txt:

 .----------------. .----------------. .----------------. .----------------.   .----------------.   .----------------. .----------------. .----------------.
| .--------------. | .--------------. | .--------------. | .--------------. | | .--------------. | | .--------------. | .--------------. | .--------------. |
| |  ____  ____  | | | _____  _____ | | |  _______     | | |  _______     | | | |              | | | |      __      | | |   ______     | | |     _____    | |
| | |_   ||   _| | | ||_   _||_   _|| | | |_   __ \    | | | |_   __ \    | | | |              | | | |     /  \     | | |  |_   __ \   | | |    |_   _|   | |
| |   | |__| |   | | |  | |    | |  | | |   | |__) |   | | |   | |__) |   | | | |    ______    | | | |    / /\ \    | | |    | |__) |  | | |      | |     | |
| |   |  __  |   | | |  | '    ' |  | | |   |  __ /    | | |   |  __ /    | | | |   |______|   | | | |   / ____ \   | | |    |  ___/   | | |      | |     | |
| |  _| |  | |_  | | |   \ `--' /   | | |  _| |  \ \_  | | |  _| |  \ \_  | | | |              | | | | _/ /    \ \_ | | |   _| |_      | | |     _| |_    | |
| | |____||____| | | |    `.__.'    | | | |____| |___| | | | |____| |___| | | | |              | | | ||____|  |____|| | |  |_____|     | | |    |_____|   | |
| |              | | |              | | |              | | |              | | | |              | | | |              | | |              | | |              | |
| '--------------' | '--------------' | '--------------' | '--------------' | | '--------------' | | '--------------' | '--------------' | '--------------' |
 '----------------' '----------------' '----------------' '----------------'   '----------------'   '----------------' '----------------' '----------------'
${application.title} - Versão: ${application.version}
Powered by Spring Boot ${spring-boot.version}

Neste exemplo, usamos variáveis como ${application.title}, ${application.version}, e ${spring-boot.version}, que o Spring Boot preencherá automaticamente.

2. Configurando Variáveis Dinâmicas

As variáveis dinâmicas no banner.txt são preenchidas pelo Spring Boot com informações obtidas do arquivo application.properties ou application.yml. Para configurar o título e a versão da aplicação:

1. Abra o application.properties ou application.yml.
2. Defina as Propriedades para o título e versão da aplicação: application.title=Minha Aplicação application.version=1.0.0 Em application.yml: application: title: Minha Aplicação version: 1.0.0

Essas propriedades serão usadas para preencher ${application.title} e ${application.version} no banner.txt.

3. Personalizando Outras Configurações de Inicialização (Opcional)

Além do banner, o Spring Boot permite personalizar várias outras configurações de inicialização:

• Banner em Arquivos Externos: Você também pode colocar o banner.txt fora do projeto e especificar seu caminho em application.properties: spring.banner.location=/caminho/para/banner.txt
• Desativando o Banner: Se você quiser desativar o banner ASCII, basta definir: spring.main.banner-mode=off

4. Exibindo Informações Dinâmicas Adicionais

Você pode adicionar outras informações dinâmicas no banner.txt, como a versão do Java ou dados do sistema, que o Spring Boot preenche automaticamente:

• ${java.version}: Exibe a versão do Java em execução.
• ${os.name}: Exibe o sistema operacional.

5. Testando o Banner Personalizado

Para verificar se a personalização do banner está funcionando corretamente:

1. Compile e Execute a Aplicação com o comando Maven ou Gradle usual, por exemplo:mvn spring-boot:run
2. Verifique a saída do console, onde deverá aparecer o banner personalizado com as variáveis preenchidas conforme configurado.

Exemplo Completo de application.properties

Aqui está um exemplo completo de application.properties com as propriedades necessárias para exibir um banner personalizado e algumas configurações adicionais:

application.title=Minha Aplicação
application.version=1.0.0
spring.main.banner-mode=console

Conclusão

Personalizar o banner de inicialização do Spring Boot é uma ótima maneira de dar um toque especial à sua aplicação e adicionar informações importantes no console ao iniciar o sistema. Ao combinar uma arte ASCII com variáveis dinâmicas, você torna a inicialização mais informativa e atraente.

Como Colocar um Projeto Java em um Contêiner Docker com Docker Compose

Este guia mostra como configurar um projeto Java com banco de dados PostgreSQL em contêineres Docker. Vamos usar o Dockerfile para definir a imagem do contêiner do aplicativo Java e o docker-compose.yml para orquestrar o aplicativo e o banco de dados.

Estrutura do Projeto

Aqui está a estrutura de diretórios esperada para o projeto:

/seu-projeto
├── Dockerfile
├── docker-compose.yml
├── target/
│   └── hurr-0.0.1-SNAPSHOT.jar
├── sql/
│   └── seus-scripts.sql

1. Dockerfile para Configurar o Contêiner Java

Primeiro, vamos analisar o Dockerfile para o contêiner Java, que será responsável por executar o aplicativo:

# Usando uma imagem do JDK 21 da Amazon Corretto como base
FROM amazoncorretto:21

# Definindo o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copiando o JAR da aplicação para o contêiner
COPY target/hurr-0.0.1-SNAPSHOT.jar /app/app.jar

# Copiando todos os scripts SQL para o diretório /app/sql no contêiner
COPY sql/ /app/sql/

# Variável de ambiente para o tempo de execução Java
ENV JAVA_OPTS=""

# Expondo a porta que a aplicação usa
EXPOSE 8080

# Comando para rodar a aplicação
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar /app/app.jar"]

Explicação do Dockerfile

• Imagem Base: amazoncorretto:21 é usada como a base da imagem, fornecendo o JDK 21 necessário para rodar o aplicativo.
• Diretório de Trabalho: WORKDIR /app define /app como o diretório de trabalho dentro do contêiner.
• Cópia do JAR da Aplicação: COPY target/hurr-0.0.1-SNAPSHOT.jar /app/app.jar copia o arquivo JAR compilado para o contêiner.
• Cópia de Scripts SQL: COPY sql/ /app/sql/ copia todos os scripts SQL para o diretório /app/sql no contêiner, caso sejam necessários para inicializar o banco de dados.
• Variável de Ambiente: ENV JAVA_OPTS="" permite definir variáveis de execução Java para ajustes de memória e outros parâmetros de execução.
• Exposição de Porta: EXPOSE 8080 indica a porta que o aplicativo usará para se comunicar com o exterior.
• Comando de Inicialização: ENTRYPOINT inicia a aplicação usando o comando java -jar /app/app.jar, aplicando as variáveis de ambiente JAVA_OPTS.

2. Arquivo docker-compose.yml para Orquestração

O arquivo docker-compose.yml define como os serviços do aplicativo Java e do banco de dados PostgreSQL interagem.

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      - JAVA_OPTS=-Dspring.datasource.url=jdbc:postgresql://db:5432/hurr?currentSchema=hurr
      - SPRING_DATASOURCE_USERNAME=postgres
      - SPRING_DATASOURCE_PASSWORD=postgres
    ports:
      - "8080:8080"
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      POSTGRES_DB: hurr
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5432:5432"
    volumes:
      - postgres-data:/var/lib/postgresql/data

volumes:
  postgres-data:

Explicação do docker-compose.yml

1. Serviço app:
   • Build: build define que a imagem do serviço será construída a partir do Dockerfile na raiz do projeto.
   • Variáveis de Ambiente:
     • JAVA_OPTS: Configura o endereço do banco de dados db, o nome do banco (hurr), e o schema (hurr), além das credenciais de usuário e senha.
     • SPRING_DATASOURCE_USERNAME e SPRING_DATASOURCE_PASSWORD: Definem o usuário e a senha do banco de dados.
   • Portas: ports mapeia a porta 8080 do contêiner para 8080 na máquina host.
   • Depends_on: depends_on define que o serviço app só iniciará após o serviço db estar em execução.
2. Serviço db:
   • Imagem do PostgreSQL: postgres:15 usa uma imagem oficial do PostgreSQL na versão 15.
   • Variáveis de Ambiente: Configuram o nome do banco (POSTGRES_DB), o usuário (POSTGRES_USER) e a senha (POSTGRES_PASSWORD) para o banco de dados.
   • Portas: ports mapeia a porta 5432 do contêiner para 5432 no host, permitindo que o banco seja acessado localmente.
   • Volume: volumes cria um volume persistente (postgres-data) para armazenar dados do banco.
3. Volume postgres-data:
   • Esse volume garante que os dados do banco de dados persistam, mesmo se o contêiner for reiniciado.

3. Iniciando a Aplicação com Docker Compose

Para iniciar os contêineres do aplicativo Java e do banco de dados PostgreSQL, execute o seguinte comando:

docker-compose up --build

Esse comando cria e inicia os contêineres, exibindo os logs diretamente no terminal. A aplicação estará disponível em http://localhost:8080 e o banco de dados PostgreSQL estará disponível na porta 5432.

4. Verificando a Configuração

• Acessando a Aplicação: Acesse http://localhost:8080 para verificar se o aplicativo está rodando corretamente.
• Acessando o Banco de Dados: Você pode conectar-se ao banco PostgreSQL usando um cliente SQL e os seguintes parâmetros:
  • Host: localhost
  • Porta: 5432
  • Banco de Dados: hurr
  • Usuário: postgres
  • Senha: postgres

Conclusão

Com essa configuração, você tem um ambiente Docker completo para rodar um projeto Java com PostgreSQL. Esse setup facilita o desenvolvimento e a replicação do ambiente em outras máquinas. Além disso, o uso de variáveis de ambiente torna a configuração flexível e adaptável a diferentes ambientes, como desenvolvimento, testes e produção.