Java on Gilberto | GibaTech

Spring Data: Como realizar integrações de maneira facilitada

Tue, 22 Mar 2022 00:00:00 -0300

O Spring Data é uma abstração criada pelo Spring para interagirmos com dados, sejam de fontes relacionais ou não relacionais. Além de fornecer as operações mais comuns como listar ou salvar prontas, também provê formas práticas de personalizar consultas.

1. Recursos

Suporte a bancos relacionais (JPA) e não relacionais (MongoDB, Redis, Cassandra)
Interfaces prontas como CrudRepository, JpaRepository e PagingAndSortingRepository
Query methods derivados do nome do método
Anotações para personalização com @Query

2. Exemplo com JPA

Adicione a dependência no build.gradle:

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'com.h2database:h2'
}

Crie a entidade e o repositório:

@Entity
public class Cliente {
    @Id @GeneratedValue
    private Long id;
    private String nome;
    private String email;
    // getters e setters omitidos (use Lombok!)
}

public interface ClienteRepository extends JpaRepository<Cliente, Long> {
    List<Cliente> findByNomeContainingIgnoreCase(String nome);
    Optional<Cliente> findByEmail(String email);
}

O Spring Data implementa automaticamente os métodos da interface. O método findByNomeContainingIgnoreCase gera a query SELECT * FROM cliente WHERE nome LIKE %:nome% sem escrever uma linha de SQL.

3. Exemplo com MongoDB

1
2
3

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
}

@Document
public class Produto {
    @Id
    private String id;
    private String nome;
    private BigDecimal preco;
}

public interface ProdutoRepository extends MongoRepository<Produto, String> {
    List<Produto> findByPrecoBetween(BigDecimal min, BigDecimal max);
}

Mais informações:

Spring Boot | Profiles: Como trocar configurações de acordo com o ambiente

Sun, 20 Mar 2022 00:00:00 -0300

Os Profiles ou perfis de execução de uma aplicação nos permitem diferentes configurações de acordo com o ambiente ou objetivo da execução. Por exemplo, precisamos de um banco de dados H2 localmente, com certo usuário e senha, mas em produção usamos um Postgres com outro usuário e senha. Ainda, podemos ter algum teste que usa uma terceira configuração, por exemplo, com um banco desconfigurado para simular um erro de execução.

Para estas variações de execução temos os Profiles. Esta é uma funcionalidade central do Spring e está presente tanto no SpringBoot quanto diretamente na raiz do Spring. Com ela podemos criar diferentes arquivos de configuração para nossa aplicação, e quando “executamos” podemos informar qual “profile” queremos utilizar.

Dada a explicação inicial, vamos ver como “criar” profiles e como utilizá-los:

1.Criando profiles

Cabe dizer que o nome dos profiles não são predefinidos e você pode ser criativo, mas usualmente eles são simples e alfanuméricos. Exemplos de bons nomes de profiles: “local”, “testes”, “testes-kafka”, “producao” ou mesmo “cliente345”. Dito isso, há basicamente duas formas de “definir” esses nomes de profiles:

1.1.Limitando uso de SpringBeans com Profiles

Por exemplo, supondo que temos um SpringBean (classe Java com algum stereotype) de configuração de banco Postgresql, que só queremos que seja executado em Produção. Podemos utilizar nesta classe a anotação @Profile indicando que queremos que funcione somente no profile “prod”:

@Component
@Profile("prod")
public class ConfigurePostgresConfig {
    //Método de configuração omitido...
}

Neste caso esse “SpringBean” será carregado para o contexto do Spring somente se o profile for especificamente “prod”. Ainda é possível colocar uma lista de profiles nesta anotação ou fazer lógica como “OU”, “E” ou “NEGAÇÃO” mas não abordaremos esses exemplos aqui. Olhe a documentação adicional para esses casos.

1.2.Diferenciando configurações com Profiles

No caso de configurações podemos criar arquivos para cada cenário, e eles podem ser no formato “properties” ou “yaml”. Porém, não basta criarmos o arquivo, ele deve seguir um padrão:

application-{nomeprofile}.{properties ou yml}

Exemplos de nomes válidos: application-prod.yaml, application-local.properties, application-teste-integrado.yaml. Nestes casos os profiles são “prod”, “local” e “teste-integrado” respectivamente.

OBS:

Ainda há o arquivo “application.yaml” ou “application.properties” considerado o profile padrão (default).
A extensão “yaml” também pode ser escrita apenas “yml”.
Com algumas configurações no projeto o prefixo “application” pode ser substituído por “bootstrap”. Neste caso, por exemplo podemos ter um arquivo “bootstrap-local.yml” também válido.

2.Utilizando profiles

Para fazermos nossa aplicação ler e utilizar um destes arquivos de configuração, ou mesmo considerar o profile para descartar um “SpringBean” da configuração temos de indicar qual (ou quais) profiles queremos utilizar na inicialização da aplicação. Podemos fazer isso de algumas formas:

2.1.Através do application.yml/application.properties

Esses arquivos, por serem o “profile padrão” SEMPRE são lidos, então dentro deles podemos declarar uma propriedade “spring.profiles.active” indicando qual profile também deve ser considerado. Exemplo:

arquivo application.properties (profile padrão):

`1`	`spring.profiles.active=local`

arquivo application-local.properties (profile local):

`1`	`logging.level.root=debug`

2.2.Através de variável de ambiente

Podemos definir uma variável tanto na nossa IDE quanto no próprio sistema operacional denominada “SPRING_PROFILES_ACTIVE”. Por exemplo, no linux, ao configurarmos através de export SPRING_PROFILES_ACTIVE=dev estamos exportando no bash uma variável ativando o profile “dev”.

2.3.Através de parâmetros de execução

Podemos ainda definir um parâmetro “spring.profiles.active”. Os parâmetros de JVM normalmente são passados utilizando “-D”, então no caso ficaria: -Dspring.profiles.active=dev para ativar o profile “dev”.

Ainda é possível fixar essa variável “spring.profiles.active” programaticamente no Java, como propriedade de projetos Maven ou Gradle. Em todos os casos irá funcionar, resta escolher a melhor forma de configurar essa propriedade.

Materiais em vídeo:

Fizemos uma seleção dentre os vídeos para ajudá-lo a entender mais sobre o assunto:

Mais informações:

Seguem materiais adicionais, lembrando que sempre a documentação oficial é a melhor fonte, seguido de outros sites e fóruns:

Lombok: menos código repetitivo e mais foco nas regras de negócio

Mon, 03 Jan 2022 12:00:00 -0300

O que é? Qual o uso?

A ideia deste projeto é reduzir a quantidade de código repetitivo que escrevemos no Java. Métodos de leitura e escrita de campos (getters/setters), construtores com ou sem argumentos, tudo se resume a anotações com o Lombok! Poderia ficar melhor? Sim, ele consegue criar até classes de Builders com a mesma facilidade.

Exemplos de uso

Adicione a dependência no build.gradle:

dependencies {
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
}

@Data — gera getters, setters, toString, equals e hashCode

import lombok.Data;

@Data
public class Usuario {
    private Long id;
    private String nome;
    private String email;
}

O código acima equivale a aproximadamente 50 linhas de getters, setters, toString, equals e hashCode.

@AllArgsConstructor e @NoArgsConstructor

import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Produto {
    private Long id;
    private String nome;
    private BigDecimal preco;
}

@Builder — padrão Builder automaticamente

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class Pedido {
    private Long id;
    private String cliente;
    private List<Item> itens;
}

// Uso:
Pedido pedido = Pedido.builder()
    .cliente("João")
    .itens(List.of(item1, item2))
    .build();

Dá uma olhada nesse vídeo pra conferir:

Vídeos

O Felipe Públio tem um material interessante sobre o tema:

Mais informações:

https://projectlombok.org/

AssertJ: Asserções de testes de forma fluída

Wed, 25 Aug 2021 12:00:00 -0300

Asserções de forma fluída para o Java.

Para que serve

AssertJ é uma biblioteca Java que fornece um conjunto rico de asserções e mensagens de erro verdadeiramente úteis, melhora a legibilidade do código de teste e é projetada para ser fácil de usar em seu IDE favorito.

Funcionalidades

Asserções com recursos do Java 8
Mensagens de erro descritivas
Conjuntos de asserções (SoftAssertions)

Iniciando uma asserção

1
2

.assertThat(resultado)              // Tudo inicia a partir do assertThat()
    .isEqualTo(esperado)            // seguido dos método que olharemos

Asserções para itens individuais

1
2
3

.assertThat(resultado)
    .as("Nome: %s", nome)   // Mensagem descritiva em caso de falha.
    .isEqualTo(algo)        // Equals clássico

Asserções para coleções ou arrays

.assertThat(colecao)
    .filteredOn(predicate, lambda ou field)   // Filtra os itens
    .containsOnly(item...)                    // Exatamente os itens existentes
    .contains(item...)                        // Um ou mais itens que devem existir
    .doesNotContain(item...)                  // Um ou mais itens que não devem existir
    .extracting(lambda ou field)              // Extrai campo(s) dos itens do array
    .flatExtracting(lambda ou field)          // Extrai campo(s) do tipo lista de cada item do array

Testando uma exceção

.assertThatThrownBy(() -> acao())           // Ação que dispara uma exceção
    .isInstanceOf(Exception.class)          // Valida o tipo da exceção
    .hasMessageContaining("Erro X")         // Valida a mensagem
    
//ou
assertThatExceptionOfType(Exception.class)  // Valida o tipo da exceção
    .isThrownBy()                           // Ação que dispara uma exceção
    .withMessage("%s!", "Erro X")           // Valida a mensagem
    .withMessageContaining("Erro X")        // Ou parte da mensagem

Notas curiosas

Além do Core, o AssertJ possui módulos extras para Guava, Joda, Neo4J, Databases e Swing.
Você pode encadear um conjunto de assertions com o SoftAssertions coletando todos os erros ao mesmo tempo em vez de parar em cada Asserção individual.
Você pode fazer asserção com o conteúdo de um arquivo utilizando assertThat(contentOf(arquivo)).

Mais informações:

https://assertj.github.io/doc/

Spring Boot: O que é este Framework para Desenvolvimento Java

Wed, 25 Aug 2021 12:00:00 -0300

O Spring Boot é um dos frameworks Java mais estabelecidos, criado para simplificar a configuração e o desenvolvimento de aplicações Spring. Ele oferece dependências pré-configuradas (starters), servidor web embutido (Tomcat, Jetty) e reduz significativamente a configuração de infraestrutura.

Exemplo mínimo

Uma aplicação REST funcional com Spring Boot requer apenas uma classe:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class MinhaAplicacao {
    public static void main(String[] args) {
        SpringApplication.run(MinhaAplicacao.class, args);
    }

    @GetMapping("/")
    public String ola() {
        return "Olá, mundo!";
    }
}

Basta adicionar a dependência spring-boot-starter-web no build.gradle:

1
2
3

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

E a aplicação já sobe com servidor Tomcat embutido na porta 8080.

Recursos:

Vídeo:

Para conhecer melhor suas funcionalidades, esse vídeo da Alga Works explica bem para os fundamentos:

Conclusão

O Spring Boot é atualmente a forma mais produtiva de desenvolver aplicações Java para a web, eliminando grande parte da configuração manual e permitindo foco nas regras de negócio. Se você está começando com Java, comece pelo Spring Boot.

Mais informações:

Java: Ambiente de desenvolvimento

Fri, 10 Apr 2020 00:00:00 +0000

As ferramentas descritas aqui são base para o desenvolvimento Java e podem ser obtidas gratuitamente (legalmente) através dos links disponibilizados

Intellij

Link: https://www.jetbrains.com/idea/download/

Acesse a URL e faça download da versão Community para seu sistema operacional. Ele funciona da mesma forma no Linux, Mac ou Windows.

Java

Link: https://www.java.com/pt_BR/download/

Acesse a URL e faça download para seu sistema.

Há uma alternativa que pode ser utilizada sem problemas não vinculada à Oracle: O OpenJDK.

Link: https://adoptopenjdk.net/

Cliente Rest

Esta ferramenta é util caso você esteja construindo API’s Rest. Há alternativas como extensões para Chrome e Firefox mas o Postman possui mais recursos, sendo muito utilizado em ambientes corporativos.

Link: https://www.postman.com/downloads/

Outras ferramentas

Ainda, com relação ao Java, se você gosta de experimentar diferentes versões, uma alternativa para gerenciar elas facilmente é o SDKMAN. Mais detalhes neste outro artigo: Dev Tools Java

Ferramentas de Desenvolvimento

Tue, 25 Dec 2018 15:24:38 -0200

SDKMAN — Gerenciador de versões para ferramentas Java

Site oficial: sdkman.io

O SDKMAN permite instalar e alternar facilmente entre diferentes versões de várias ferramentas. Entre elas: Gradle, Grails, Groovy, Java, Kotlin, Maven, Scala, Spring Boot.

Instalação

1
2

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

Uso básico

# Listar versões disponíveis do Java
sdk list java

# Instalar uma versão específica
sdk install java 21.0.2-tem

# Alternar entre versões
sdk use java 17.0.9-tem

# Definir versão padrão
sdk default java 21.0.2-tem

Ele baixa os pacotes e configura as variáveis de ambiente automaticamente, deixando os binários no PATH para execução direta, como se fosse uma instalação no sistema principal.

Outras ferramentas úteis

Ferramenta	Uso
Gradle	Automação de build e gerenciamento de dependências
Maven	Automação de build e gerenciamento de dependências
Docker	Contêineres para ambientes isolados (banco, filas, etc.)
HTTPie	Cliente HTTP via terminal para testar APIs REST
jq	Processamento de JSON no terminal