DEV Community: Rinaldo

JAVA 8: Utilize métodos STATIC em INTERFACES e simplifique seu código!

Rinaldo — Fri, 10 May 2019 14:20:28 +0000

Métodos static em Interfaces do Java 8 simplificam e reduzem seu código, além de poderem aumentar sua produtividade. Aprenda agora e aumente a qualidade do seu código!

Métodos `static` em classes utilitárias

É comum a necessidade de criar métodos static para que possam ser chamados sem a necessidade de criar um novo objeto. A própria JDK possui várias classes que contém somente métodos static, por exemplo: java.lang.Math, java.util.Collections, java.util.Arrays, java.util.stream.Streams.

E a JDK deixa claro que não quer que você crie instâncias dessas classes. Veja os construtores retirados diretamente do código fonte da JDK:

 // Suppresses default constructor, ensuring non-instantiability.
 private Collections() {
 }

 // Suppresses default constructor, ensuring non-instantiability.
 private Arrays() {}

/**
 * Don't let anyone instantiate this class.
 */
private Math() {}

private Streams() {
    throw new Error("no instances");
}

Além disso, inúmeras bibliotecas disponibilizam classes utilitárias que também contém apenas métodos static, como aquelas dos projetos _ Apache Commons _.

O problema com classes utilitárias

Esse tipo de classe normalmente é chamada de utilitária, por isso a terminação *Util em muitas delas, principalmente nas da Apache. Essas classes basicamente não seguem o padrão de Orientação à Objetos (OO), pois contém apenas código estruturado.

Aliás, se fosse possível no Java, esses métodos nem estariam dentro de uma classe.

Quando utilizar classes utilitárias?

O fato de não seguir os conceitos da OO não é necessariamente algo ruim. Porém, imagine a seguinte situação: você possui uma classe Pessoae quer fazer um método utilitário static. O que você acha que faz mais sentido : criar uma classe PessoaUtil com esse método, ou criá-lo na própria classe Pessoa? Eu advogo pela segunda opção. Ou seja, só vejo sentido em criar uma classe utilitária quando:

Você não é o dono da classe original , ou não consegue modificá-la ; ou
Você possui uma estrutura de interfaces e esse método utilitário serve para todas elas. Este é o caso da classe java.util.Collections.

Quer dizer, eu defendia isso até o Java 8. Agora, no segundo caso, a própria interface pode ter métodos static.

Métodos `static` em Interfaces do Java 8

A partir do Java 8, é possível criar métodos static na própria interface :

  interface Corredor {
    static double calculeVelocidade(double tempo, double distancia) {
      return distancia/tempo;
    }
  }

Ou seja, nesse caso, é possível chamar o método da Interface sem instanciar um novo objeto:

    double velocidade = Corredor.calculeVelocidade(5.0, 10.0);
    System.out.println(velocidade);

Sendo assim, mesmo que você tenha uma estrutura de interfaces, você poderia criar seus métodos static dentro da interface apropriada.

Claro, existem exceções à regra, e talvez ainda há casos parecidos em que faça sentido criar uma classe utilitária. A questão é que agora você tem uma nova opção a considerar.

Métodos `static` em Interfaces NÃO fazem parte da API

É muito importante lembrar que os métodos criados como static não fazem parte da API da Interface. Ou seja, eles realmente são elementos da Interface. Assim como métodos static de uma classe são elementos da classe.

Por isso, o código abaixo não compila , por conta das linhas 3 e 7.

  public static void main(String[] args) {
    // NÃO COMPILA - a classe Pessoa não possui o método calculeVelocidade
    double velocidade = Pessoa.calculeVelocidade(5.0, 10.0);
    System.out.println(velocidade);

    // NÃO COMPILA - o objeto instância de Pessoa não possui o método calculeVelocidade
    double velocidade2 = new Pessoa().calculeVelocidade(5.0, 10.0);
    System.out.println(velocidade2);
  }

  interface Corredor {
    static double calculeVelocidade(double tempo, double distancia) {
      return distancia/tempo;
    }
  }

  class Pessoa implements Corredor {}

Ou seja, não é possível chamar o método static da interface diretamente em classes que implementam aquela interface.

Métodos `static` em Interfaces são `public` e NÃO são `abstract`

Por definição, até o Java 8, todos os métodos de uma interface eram public e abstract, mesmo que você não declarasse-os assim. Veja no exemplo abaixo:

  interface Corredor {
    public abstract void correr();
    void correrRapido(); // também é public e abstract
  }

Os métodos static continuam sendo obrigatoriamente public, porém não são abstract. E faz todo sentido, afinal eles contém uma implementação.

Parabéns! Agora você conhece melhor as interfaces do Java 8! Você pode utilizar esse conhecimento para entregar no prazo soluções de alta qualidade.

E você? Já utiliza métodos static em Interfaces? Já teve que dar manutenção em algum código assim? Lembra de situações em que você poderia ter se beneficiado dessa nova opção? Deixe um comentário!

Veja também o vídeo no YouTube!

https://www.youtube.com/watch?v=8W_Xp2BnSVgM

O post JAVA 8: Utilize métodos STATIC em INTERFACES e simplifique seu código! apareceu primeiro em rinaldo.dev.

Java 8 Streams: Pare de usar ‘for’ e simplifique seu código!

Rinaldo — Sat, 30 Mar 2019 22:04:01 +0000

Streams do Java 8 deixam seu código mais legível e conciso, além de poderem aumentar sua produtividade ao lidar com listas e coleções. Aprenda agora e aumente a qualidade do seu código!

Loops tradicionais

Iterar sobre uma Collection antes do Java 5 era um código feio e complexo, o que sempre aumenta a chance de criar um bug inesperado. Lembremos:

List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 6, 3, 2, 1, 8, 5, 7, 4);
for (Iterator<Integer> numero = lista.iterator(); numero.hasNext();) {
    Integer integer = numero.next();
    System.out.print(integer);
}

Felizmente, a partir do Java 5 foi criada a nova sintaxe For-Each, que diminuiu muito a complexidade de iterar sobre coleções:

List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 6, 3, 2, 1, 8, 5, 7, 4);
for (Integer numero : lista) {
    System.out.print(numero);
}

Apesar da nova sintaxe ter facilitado muito a vida de desenvolvedores java, ela ainda não tirou proveito da programação funcional e é fortemente imperativa. No Java 8 isso mudou completamente.

Streams do Java 8

O Java 8 trouxe a criação de funções lambda. Se você ainda não está familiarizado com elas, pode conhecer mais clicando aqui. Com isso, foi possível criar uma nova forma de iterar sobre coleções, que é mais simples, concisa e ainda mais legível. Veja um exemplo simples, que faz o mesmo que os dois exemplos anteriores:

List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 6, 3, 2, 1, 8, 5, 7, 4);
lista.stream().forEach(System.out::print);

Essa sintaxe cria um stream de dados. Neste caso, os dados são os números. Para cada um deles é chamada a função System.out.print(...) passando o número como parâmetro. Aqui também estamos utilizando a sintaxe de method reference, que é essa forma de referenciar o método: System.out::print.

Operações intermediárias em Streams do Java 8

O método forEach que utilizamos acima é uma operação final, ou terminal, pois depois dela nada mais pode ser feito. Mas você pode fazer muito mais com Streams do Java 8. Vamos ver agora exemplos com operações intermediárias.

Os métodos `skip`, `limit` e `distinct`

Vejamos o exemplo abaixo que filtra alguns resultados antes de apresentá-los.

List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 2, 3, 2, 1, 8, 5, 7, 4);
lista.stream()
    .skip(2) // ignora os dois primeiros números
    .limit(9) // limita a 9 números
    .distinct() // ignora números iguais
    .forEach(System.out::print);

A execução desse código produz a seguinte saída no console:

Nesse exemplo são feitas várias operações antes de executar o forEach:

O skip serve para ignorar os primeiros X itens. Aqui ignoramos o 1 e o 5.
O limit informa quantos objetos você quer tratar, a partir disso os próximos são ignorados. Aqui pegamos do 8 ao 5.
O distinct é igual ao DISTINCT do SQL: ele mantém apenas os resultados que são diferentes entre si. Para isso, ele utiliza o método equals dos objetos da lista. Aqui ignoramos a repetição dos números 2 e 8.

O método `filter`

As 3 funções que mostramos acima “filtram” o nosso stream, ou seja, ignoram alguns elementos. Mas e se for necessário um filtro mais personalizado? Para isso utiliza-se o método filter:

List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 2, 3, 2, 1, 8, 5, 7, 4);
lista.stream()
    .filter(e -> e % 2 == 0) // mantém apenas números pares
    .forEach(System.out::print); // imprime todos no console

O trecho de código acima produz a seguinte saída no console:

Perceba que o método filter, nesse caso, está filtrando nosso stream para manter apenas números pares. Se você ainda não está familiarizado com as funções lambdas, a estrutura é a seguinte:

Estrutura da função lambda passada para o método filter

O método `map`

Caso seja necessário fazer uma transformação no dado antes de passá-lo para o próximo método do stream, utiliza-se o método map. Apesar do nome, ele não tem relação com a interface Map. Veja abaixo.

List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 2, 3, 2, 1, 8, 5, 7, 4);
lista.stream()
    .map(e -> e * 2) // multiplica cada item por 2
    .forEach(e -> System.out.print(e + " ")); // imprime todos no console

A saída no console é a seguinte:

2 10 16 14 8 4 6 4 2 16 10 14 8

Perceba que todos os números foram multiplicados por 2 antes de serem apresentados no console. Porém, é importante notar que os números da lista original não foram alterados. Ou seja, as transformações do método map afetam apenas os valores que serão passados para frente naquele stream. Isso é excelente, pois sempre que possível o ideal é trabalharmos com valores e instâncias imutáveis.

Operações finais em Streams do Java 8

Em todos os exemplos apresentados até agora o stream finaliza com um forEach. Essa é uma das operações finais disponíveis na API de Streams do Java 8. Ou seja, é um método que fecha o stream e coleta o resultado de tudo que foi feito. Veremos agora outras operações finais que geralmente são mais úteis do que o forEach. Afinal, você provavelmente irá querer armazenar o resultado das operações do stream, e utilizar esse resultado para alguma coisa. Vejamos algumas possibilidades.

Os métodos `max`, `min`, `count`

Se deseja pegar o maior ou o menor valor depois das operações realizadas no seu stream, os métodos max e min fazem exatamente isso. Vejamos o max:

List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 2, 3, 2, 1, 8, 5, 7, 4);
Optional<Integer> maiorNumero = lista.stream()
        .map(e -> e * 2) // multiplica cada item por 2
        .max(Comparator.naturalOrder()); // pega o maior item pela ordem natural
System.out.println(maiorNumero.get());

Ao utilizar o método max é necessário informar como o stream irá comparar seus objetos. Nesse caso, como Integer já implementa a interface Comparable e o método compareTo, ele já possui uma ordem natural que podemos utilizar, por isso usamos Comparator.naturalOrder(). Nesse exemplo o número 16 é impresso no console, pois é o maior número no stream depois de termos multiplicado todos por 2. Veja que, por ser uma operação final, é necessário armazenar o resultado em uma variável para utilizá-lo. O mesmo ocorre com o método min:

List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 2, 3, 2, 1, 8, 5, 7, 4);
Optional<Integer> menorNumero = lista.stream()
        .map(e -> e * 2) // multiplica cada item por 2
        .min(Comparator.naturalOrder()); // pega o menor item pela ordem natural
System.out.println(menorNumero.get());

Seguindo a mesma ideia do método max, esse exemplo produz a saída 2 no console.

Por fim, o método count retorna quantos elementos restam no stream:

List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 2, 3, 2, 1, 8, 5, 7, 4);
Long quantidade = lista.stream()
        .filter(e -> e % 2 == 0) // mantém apenas números pares
        .count(); // pega quantos itens restam no stream
System.out.println(quantidade);

Nesse exemplo a saída no console será 6, que é a quantidade de números pares no stream.

O método `collect`

E finalizando os exemplos das operações básicas, temos o método collect. Ele é a forma mais personalizável de coletar o resultado das operações do Stream. Por ter inúmeras formas de ser utilizado, falarei mais sobre ele em um artigo específico. Para saber assim que eu compartilhar, é só me seguir, os links estão no final deste artigo. Por enquanto vejamos alguns exemplos básicos com collect.

Se você quiser apenas coletar o resultado em uma nova lista, utilize um collector pré-implementado em Collectors.toList():

List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 2, 3, 2, 1, 8, 5, 7, 4);
List<Integer> novaLista = lista.stream()
        .filter(e -> e % 2 == 0) // mantém apenas números pares
        .map(e -> e * 2) // multiplica cada item por 2
        .collect(Collectors.toList()); // coleta todos os itens em uma nova lista
System.out.println(novaLista);

Nesse exemplo filtramos apenas os números pares, multiplicamos todos por 2 e coletamos o resultado em uma nova lista. A saída no console é:

[16, 8, 4, 4, 16, 8]

Caso queira agrupar os itens da lista em um mapa, utilize o collector Collectors.groupingBy(...):

List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 2, 3, 2, 1, 8, 5, 7, 4);
Map<Boolean, List<Integer>> mapa = lista.stream()
        .map(e -> e * 2) // multiplica cada item por 2
        .collect(Collectors.groupingBy(e -> e > 8)); // agrupa itens baseado no resultado da comparação
System.out.println(mapa);

Neste exemplo estamos multiplicando todos os itens do stream por 2, e depois agrupamos em números maiores que 8 e menores ou igual a 8. Veja como fica o mapa ao ser impresso no console:

{false=[2, 8, 4, 6, 4, 2, 8], true=[10, 16, 14, 16, 10, 14]}

E caso queira gerar uma única string a partir do stream, pode utilizar o collector Collectors.joining(...), que une várias strings em uma só:

List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 2, 3, 2, 1, 8, 5, 7, 4);
String stringUnica = lista.stream()
        .map(String::valueOf) // transforma cada item em String
        .collect(Collectors.joining(";")); // junta todas as Strings em uma única separada por ';'
System.out.println(stringUnica);

Aqui transformamos cada número em uma string utilizando String.valueOf(…). Depois agrupamos todos em uma única string separando os elementos por ponto e vírgula. A saída no console é a seguinte string:

1;5;8;7;4;2;3;2;1;8;5;7;4

Parando de usar ‘for’ e ‘while’

Utilizando Streams do Java 8, raramente será necessário que você faça um loop explícito novamente, como for, while ou do...while. A API de streams utiliza loops implícitos, tira proveito da programação funcional, e deixa seu código muito mais legível e conciso. Além disso, em um próximo artigo mostrarei como você pode paralelizar a execução de um stream de forma muito simples!

Apesar de termos apresentado streams apenas a partir de listas, é possível criá-los de várias outras formas! Veja:

De um array utilizando Arrays.stream(Object[]);
De métodos estáticos em classes de stream, como Stream.of(Object[]), IntStream.range(int, int);
As linhas de um arquivo podem ser obtidas com BufferedReader.lines();
Streams de arquivos podem ser obtidos através de métodos na classe Files;
Streams de números aleatórios podem ser obtidos em Random.ints().

Parabéns! Agora você conhece melhor a API de Streams do Java 8! Você pode utilizar esse conhecimento para entregar no prazo soluções de alta qualidade.

Quer entender um pouco mais sobre funções lambda e sua estrutura? Veja esse artigo para entender facilmente a estrutura de funções lambda.

Quer receber minhas melhores dicas para escrever código de alta qualidade e entregar projetos no prazo? Então acesse aqui.

Quer aprender a melhorar seu código diariamente? Então me segue no twitter : https://twitter.com/rinaldodev

E você? Já teve que dar manutenção em algum código com streams? Lembra de situações em que você poderia ter utilizado streams? Deixe um comentário!

Gostou do que aprendeu? Compartilhe com outros desenvolvedores no WhatsApp e nas suas redes sociais!

O post Java 8 Streams: Pare de usar ‘for’ e simplifique seu código! apareceu primeiro em rinaldo.dev.

Java 8: Entenda facilmente funções lambda, a principal novidade!

Rinaldo — Sat, 23 Mar 2019 22:29:44 +0000

A criação de Funções Lambda foi a principal novidade do Java 8, lançado em 2014! Hoje é praticamente obrigatório conhecer como elas funcionam e saber utilizá-las no seu código.

Prefere esse conteúdo em vídeo? Assista aqui!

Java 8 e programação funcional

Há algum tempo o JavaScript veio se estabelecendo como a linguagem padrão de desenvolvimento front-end. Ao mesmo tempo ocorre também o aparecimento e a popularização de linguagens como Scala, Kotlin e Python. Junto desses movimentos, a programação funcional começou a se tornar cada vez mais popular.

Com a intenção de trazer essa possibilidade também para o Java, foi criada a nova sintaxe de funções lambda. Se você nunca viu uma, aqui está:

() -> System.out.println("Hello World")

Se você nunca viu um código assim, não se assuste, você vai entender facilmente o que significa.

Java sem funções lambda

Se você programa Java há algum tempo, provavelmente já teve que escrever algum código parecido com esse:

public static void main(String[] args) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("Hello World");
        }
    }).run();
}

Apesar de esse código funcionar perfeitamente, ele tem um grande problema: é gigante. Pense bem, foram necessárias 6 linhas de código para criar uma Thread e imprimir “Hello World”, algo que deveria ser completamente trivial. Agora, veja esse mesmo código utilizando uma função lambda:

public static void main(String[] args) {
    new Thread(() -> System.out.println("Hello World")).run();
}

O código acima é interpretado pelo compilador exatamente igual ao anterior, tendo uma única linha de código e sendo muito mais conciso. E o mais interessante aqui é que ainda estamos utilizando o mesmo construtor para criar uma Thread. A própria IDE confirma isso:

Construtor recebendo uma instância de Runnable

O compilador sabe que essa função lambda é uma instância de Runnable, mesmo que nós não deixemos isso explícito. Ok, mas como ele sabe disso?

Java 8 e o conceito SAM

Esse comportamento do compilador fica simples quando entendemos o conceito de Single Abstract Method, ou SAM. Basicamente, qualquer interface que tenha um único método está seguindo esse conceito. Logo, o compilador entende que sua função lambda é, na verdade, a implementação desse único método. Vamos ver de perto.

A interface Runnable, por exemplo, possui apenas o método run. Aqui está ela, copiada direto da JDK:

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Sendo assim, ao utilizar uma função lambda como fizemos acima, o compilador entende que ela só pode ser a implementação do método run.

Quanto à anotação @FunctionalInterface presente nessa classe, ela é apenas informativa. Ela instrui ao compilador que gere um erro caso essa classe não preencha todos os requisitos para ser uma interface funcional, ou seja, uma que pode ser criada a partir de uma função lambda. Por exemplo, se essa interface tivesse dois métodos, ocorreria um erro de compilação. Apesar disso, essa anotação não é obrigatória. Você pode utilizar funções lambda com qualquer interface que atenda os pré-requisitos para ser considerada funcional.

Ok, então funções lambda servem apenas para eu diminuir a quantidade de linhas de código em casos como esse? Não. A verdade é que as funções lambda são muito mais úteis do que parecem. Os exemplos que dei acima são apenas para entender seu funcionamento, mas o que elas permitem fazer em Java é muito mais interessante.

Programação funcional

Com funções lambda é possível utilizar métodos muito conhecidos para quem utiliza JavaScript, como filter, map e forEach.

Imagine, por exemplo, que você tem uma lista de números. Você deseja imprimir o valor dos 7 primeiros, multiplicado por 2, mas apenas se o número for par. Vejamos uma implementação possível com Java tradicional:

public static void main(String[] args) {
    List<Integer> lista = Arrays.asList(1,5,8,7,4,6,3,2,1,8,5,7,4);
    for (int i = 0; i < 7; i++) {
        Integer numero = lista.get(i);
        if (numero % 2 == 0) {
            System.out.println(numero * 2);
        }
    }
}

Essa é uma implementação comum, funciona perfeitamente e, se você programa em Java há algum tempo, provavelmente está acostumado a vê-la. Porém, vamos ver como seria a mesma implementação com o uso de Streams do Java 8:

public static void main(String[] args) {
    List<Integer> lista = Arrays.asList(1,5,8,7,4,6,3,2,1,8,5,7,4);
    lista.stream()
        .limit(7)
        .filter(e -> e % 2 == 0)
        .map(e -> e * 2)
        .forEach(System.out::println);
}

Para quem não está acostumado, essa implementação pode parecer estranha a primeira vez. Porém, ela é muito mais concisa e delimitada. É possível saber exatamente todas as operações que estão sendo feitas nessa lista. Claramente existe um limite (limit), um filtro (filter), uma transformação (map) e uma ação para cada item (forEach).

Essa é estrutura da função lambda passada para o método filter:

Estrutura da função lambda passada no método filter", depois do corpo da função."/>

A partir do momento que você aprende funções lambda e a nova API de Streams, você escreve um código muito mais fácil de entender, logo, mais fácil de dar manutenção. Além disso, muito menos propício a bugs.

A real vantagem do Java 8

De fato, a principal vantagem das funções lambdas no Java 8 foi permitir o uso de Streams. Sem elas seria praticamente impossível utilizar Streams com facilidade. O código seria tão grande e complicado, que simplesmente não seria útil. Se você está curioso para saber como ficaria a implementação acima sem o uso de funções lambda, aqui está. Por favor, nunca faça isso.

public static void main(String[] args) {
    List<Integer> lista = Arrays.asList(1, 5, 8, 7, 4, 6, 3, 2, 1, 8, 5, 7, 4);
    Stream<Integer> limit = lista.stream().limit(7);
    // nunca escreva um código assim!
    Stream<Integer> filter = limit.filter(new Predicate<Integer>() {
        @Override
        public boolean test(Integer e) {
            return e % 2 == 0;
        }
    });
    Stream<Integer> map = filter.map(new Function<Integer, Integer>() {
        @Override
        public Integer apply(Integer e) {
            return e * 2;
        }
    });
    map.forEach(new Consumer<Integer>() {
        @Override
        public void accept(Integer t) {
            System.out.println(t);
        }
    });
}

Um caminho para o futuro do Java

Apesar de funções lambda terem sido extremamente úteis para o lançamento da API de Streams, isso foi apenas o começo. Várias APIs estão se tornando possíveis com o uso de funções lambda. O Java 9, por exemplo, trouxe Reactive Streams, o padrão implementado pela famosa biblioteca RxJava.

Em breve provavelmente estaremos implementando muitas coisas com programação funcional e funções lambdas no Java, como requisições HTTP, operações com arquivos e comunicação com banco de dados.

Quer saber um pouco mais da utilidade de funções lambda? Veja esse outro artigo sobre Streams e como utilizar funções lambda com coleções.

Parabéns! Agora você conhece expressões lambda do Java 8, e pode utilizar esse conhecimento para entregar seu projeto mais rápido e crescer na sua carreira.

Quer acessar esse conteúdo em vídeo também? Assista aqui!

Quer receber minhas melhores dicas para escrever código de alta qualidade e entregar projetos no prazo? Então acesse aqui.

Quer aprender a melhorar seu código diariamente? Então me segue no twitter: https://twitter.com/rinaldodev

Você já viu algum código com funções lambda recentemente? Ou conhece outras situações em que poderíamos utilizar? Deixe um comentário! Compartilhe também!

Gostou do que aprendeu? Compartilhe com outros Devs!

O post Java 8: Entenda facilmente funções lambda, a principal novidade! apareceu primeiro em rinaldo.dev.

@Transient com JPA: 3 coisas que você não deve fazer!

Rinaldo — Sun, 10 Mar 2019 01:55:26 +0000

Usar @Transient com JPA pode parecer fácil, mas existem 3 coisas que se você fizer, podem deixar seu código confuso. Aprenda agora como utilizar da melhor forma, escrever um código de alta qualidade e entregar seu projeto no prazo!

Por que JPA?

Como tudo que vamos utilizar na programação, temos que entender o conceito, para não termos dor de cabeça mais tarde. Utilizamos JPA basicamente para fazer mapeamento objeto-relacional. Em geral, queremos estabelecer uma relação entre nossos objetos e uma base de dados relacional. O que fazemos é basicamente isso:

@Transient com JPA

A partir do momento que você anota sua classe com @Entity, o JPA espera que todos os atributos dela estejam relacionados a uma coluna do banco. Os atributos anotados com @Transient são uma exceção a essa regra. De certa forma, essa anotação funciona como uma ferramenta para burlar o conceito básico do JPA. A grande questão é que cada pequena diferença que você cria entre sua tabela e sua classe traz mais complexidade para seu mapeamento.

Por isso, usar @Transient com JPA pode ser um sinal de que tem algo cheirando mal no seu código e você não está percebendo. Ao mesmo tempo, nem sempre utilizar é necessariamente errado. Vamos ver alguns cenários e suas alternativas.

1. Usar @Transient com JPA para definir um tipo de operação

Um cenário comum. Você está na classe onde executa suas regras de negócio e recebe um objeto de Usuario. Você precisa saber se é para criar um novo usuário, ou atualizar um existente, e pra isso cria um atributo transient.

Se você escreveu um código assim, é uma boa hora para refatorar. O atributo atualizar não tem absolutamente nada a ver com a classe Usuario. Então a coerência do seu código foi para o espaço. Você criou um forte acoplamento entre o comportamento do método salvarUsuario e uma flag que está dentro de uma entidade. Além disso, essa entidade só deveria ter atributos relacionados a ela.

Nesse caso, provavelmente seu fluxo de negócio para um novo cadastro e para uma atualização são diferentes. Até mesmo na camada de apresentação, raramente a página em que um usuário se cadastra é a mesma onde ele atualiza seus dados. Então não faz sentido vincular isso no seu negócio. Seria muito melhor ter dois métodos separados para cada operação e uma classe Usuario limpa.

Além disso, se você está recebendo a entidade de uma chamada externa ou da sua camada de apresentação, considere utilizar o padrão DTO.

2. Usar @Transient com JPA para passar um dado para validação

Outro cenário em que você pode considerar usar @Transient com JPA é quando percebe que precisa passar um dado apenas para validação, mas não para persistência. Vejamos.

Nesse caso temos dois exemplos. O atributos acima foram criados apenas para que sua camada de negócio faça alguma validação. Provavelmente seria algo mais ou menos assim:

Esse código tem alguns problemas:

Primeiro, esses dois atributos não tem de fato a ver com a entidade que está sendo persistida.
Depois, essas validações não precisam estar tão a fundo no backend. A confirmação do email serve para impedir um possível erro de digitação, algo que está muito mais próximo da camada de apresentação. A aceitação de termos de uso serve apenas para garantir que o usuário acessou os termos e/ou clicou em um checkbox, algo que não muda o comportamento dessa parte da aplicação.
E por último, quem quer que esteja chamando esse método pode burlar as validações. A camada de apresentação poderia simplesmente copiar o conteúdo de email para confirmacaoEmail, e marcar um true em aceitouTermosDeUso. Depois disso, faria a chamada. Sua validação só serviria para dar uma falsa sensação de segurança.

Qual seria então a alternativa? Depende muito do seu cenário:

Se você usa serviços rest, deixe que apresentação faça esse trabalho. Se quiser muito manter os atributos para lembrar ao usuário do seu serviço de fazer essas validações, considere receber uma DTO ao invés da sua entidade.
Se você usa algum framework como JSF, simplesmente faça essa validação no seu controller, sem criar atributos na classe.
No pior dos casos, se você ainda acredita ter alguma razão para fazer isso, utilize parâmetros separados, deixando sua entidade fora disso:

3. Usar @Transient com JPA para armazenar outras entidades temporariamente

Outro caso em que usar @Transient com JPA costuma ser utilizado, é para armazenar uma lista de outras entidades. Por exemplo:

Por vários motivos que não são o foco deste artigo, muitas vezes mapeamentos bidirecionais não são recomendados. Isso faz com que alguns programadores criem esse atributo transient para preencher quando necessário. Eu considero esse caso um problema “menor”, pois conceitualmente o usuário realmente tem uma lista de endereços.

O grande problema aqui é quando essa lista é preenchida. Ao fazer isso, geralmente você está criando um acoplamento entre o código que preencheu a lista, e o código que utilizou. Minhas sugestões:

Se o consumidor da entidade Usuario for uma fronteira externa ao sistema, ou uma camada de apresentação, você pode utilizar uma DTO.
Se o consumidor for outra parte interna do sistema que tem acesso ao banco de dados, deixe que ela mesma recupere essa informação.
Considere utilizar um mapeamento bidirecional com FetchType.LAZY, e avalie quais seriam os impactos no seu código:

Raramente não será possível utilizar uma das alternativas citadas acima. Caso você ainda acredite que não tem outra solução, preencha essa lista apenas em métodos que explicitamente fazem isso, e documente bem na classe Usuario:

Uso de DTO

Algumas vezes nesse artigo citei o uso do padrão DTO. Ele foi criado especificamente para isso: transferir informações entre subsistemas, ou fronteiras claras da aplicação. A única razão válida que vejo para não utilizá-lo é o aumento na quantidade de código. O chamado boilerplate code. Porém, ao utilizá-lo, você evita usar @Transient com JPA.

Além disso, você não precisa escrever todo o código para converter uma entidade para DTO. Existem muitas ferramentas para ajudar nesse mapeamento, que facilitam esse trabalho e suavizam o impacto no tamanho do código. Você pode encontrar uma lista dessas ferramentas aqui, e muitas outras na internet.

Quando usar @Transient com JPA

Bom, então não tem nenhum caso bom para se utilizar @Transient? Na verdade, tem. Um cenário onde essa anotação é muito útil, é para fazer cache de atributos derivados de outros atributos. Utilizando a mesma classe Usuario, é possível fazer algo do tipo:

É claro que esse cenário é extremamente simples, e talvez o aumento de complexidade não compense. Afinal, lembre-se que nesse caso você teria que atribuir null ao atributo nomeCompleto se sua classe for mutável e alguém alterar o primeiroNome ou sobrenome. Mas, em um cenário onde o ganho de performance pode ser considerável, é uma opção válida.

Parabéns! Agora você sabe usar @Transient com JPA, pode entregar seu projeto mais rápido e crescer na sua carreira.

Quer receber minhas melhores dicas para escrever código de alta qualidade e entregar projetos no prazo? Então acesse aqui.

Quer aprender a melhorar seu código diariamente? Então me segue no twitter : https://twitter.com/rinaldodev

E você? Conhece outras situações em que devemos ter cuidado com @Transient com JPA? Tem dicas de onde podemos usar sem problemas? Compartilhe também! Deixe um comentário!

Gostou do que aprendeu? Compartilhe com outros Devs!

DEV Community: Rinaldo

JAVA 8: Utilize métodos STATIC em INTERFACES e simplifique seu código!

Métodos static em classes utilitárias

O problema com classes utilitárias

Quando utilizar classes utilitárias?

Métodos static em Interfaces do Java 8

Métodos static em Interfaces NÃO fazem parte da API

Métodos static em Interfaces são public e NÃO são abstract

Veja também o vídeo no YouTube!

Java 8 Streams: Pare de usar ‘for’ e simplifique seu código!

Loops tradicionais

Streams do Java 8

Operações intermediárias em Streams do Java 8

Os métodos skip, limit e distinct

O método filter

O método map

Operações finais em Streams do Java 8

Os métodos max, min, count

O método collect

Parando de usar ‘for’ e ‘while’

Java 8: Entenda facilmente funções lambda, a principal novidade!

Java 8 e programação funcional

Java sem funções lambda

Java 8 e o conceito SAM

Programação funcional

A real vantagem do Java 8

Um caminho para o futuro do Java

@Transient com JPA: 3 coisas que você não deve fazer!

Por que JPA?

@Transient com JPA

1. Usar @Transient com JPA para definir um tipo de operação

2. Usar @Transient com JPA para passar um dado para validação

3. Usar @Transient com JPA para armazenar outras entidades temporariamente

Uso de DTO

Quando usar @Transient com JPA

Métodos `static` em classes utilitárias

Métodos `static` em Interfaces do Java 8

Métodos `static` em Interfaces NÃO fazem parte da API

Métodos `static` em Interfaces são `public` e NÃO são `abstract`

Os métodos `skip`, `limit` e `distinct`

O método `filter`

O método `map`

Os métodos `max`, `min`, `count`

O método `collect`