DEV Community: Sassine El-Asmar

Você conhece os 12 Fatores?

Sassine El-Asmar — Sun, 08 May 2022 23:06:43 +0000

A Heroku lançou um manifesto chamado “The Twelve Factor App”.
Este manifesto descreve doze práticas para serem seguidas ao criar aplicações voltadas para nuvem.

Vou listar os 12 fatores deste manifesto com breve resumo de cada um, se quiser ler a documentação oficial "https://12factor.net/pt_br/"

Os Doze Fatores

I. Base de Código

Uma base de código com rastreamento utilizando controle de revisão, muitos deploys

Todos os ativos relacionados a um aplicativo, desde o código-fonte, o script de provisionamento e as definições de configuração, são armazenados em um repositório de *código-fonte acessível à equipe de desenvolvimento, teste e administração do sistema. *

O repositório de código-fonte também é acessível a todos os scripts de automação que fazem parte dos processos de Integração Contínua/Entrega Contínua (CI/CD) que fazem parte do Ciclo de Vida de Desenvolvimento de Software da empresa. (SDLC).

II. Dependências

Declare e isole as dependências

Apenas o código exclusivo e relevante para a finalidade do aplicativo é armazenado no controle do código-fonte.

Artefatos externos como pacotes Node.js, arquivos Java .jar ou DLLs .NET devem ser referenciados em um manifesto de dependências carregado na memória no desenvolvimento, teste e tempo de execução da produção.

Você deseja evitar o armazenamento de artefatos junto com o código-fonte no repositório de código-fonte.

III. Configurações

Armazene as configurações no ambiente

As informações de configuração são injetadas no ambiente de tempo de execução como variáveis de ambiente ou como configurações definidas em um arquivo de configuração independente.

Embora, em certos casos, seja permitido armazenar configurações padrão que podem ser substituídas diretamente no código, configurações como número de porta, URLs de dependência e configurações de estado como DEBUG devem existir separadamente e ser aplicadas na implantação.

A vantagem de manter as definições de configuração separadas da lógica do aplicativo é que você pode aplicar as definições de configuração de acordo com o caminho de implantação.

IV. Serviços de Apoio

Trate os serviços de apoio, como recursos ligados

Tratar componentes externos, como bancos de dados, servidores de e-mail, agentes de mensagens e serviços independentes que podem ser provisionados e mantidos pela equipe de sistemas como recursos anexados.

Tratar recursos como serviços de apoio promove flexibilidade e eficiência no ciclo de vida de desenvolvimento de software (SDLC).

V. Construa, lance, execute (Build, Release, Run)

Separe estritamente os builds e execute em estágios

Divida o processo de implantação em três estágios replicáveis que podem ser instanciados a qualquer momento.

O estágio *Build *é onde o código é recuperado do sistema de gerenciamento de código-fonte e compilado/compilado em artefatos armazenados em um repositório de artefatos, como o Docker Hub ou um repositório Maven.

Depois que o código é compilado, as definições de configuração são aplicadas no estágio *Release *.

Em seguida, no estágio *Run *, um ambiente de tempo de execução é provisionado por meio de scripts usando uma ferramenta como o Ansible.

O aplicativo e suas dependências são implantados no ambiente de tempo de execução recém-provisionado, o processo é completamente efêmero.

VI. Processos

Execute a aplicação como um ou mais processos que não armazenam estado

Nenhum processo único acompanha o estado de outro processo e que nenhum processo acompanha informações como o status da sessão ou do fluxo de trabalho.

Um processo sem estado facilita o dimensionamento.

Quando um processo é sem estado, as instâncias podem ser adicionadas e removidas para lidar com uma carga de carga específica em um determinado momento.

VII. Vínculo de porta

Exporte serviços por ligação de porta

Um serviço ou aplicativo é identificável para a rede pelo número da porta, não por um nome de domínio. O raciocínio é que nomes de domínio e endereços IP associados podem ser atribuídos dinamicamente por manipulação manual e mecanismos automatizados de descoberta de serviços.

Assim, usá-los como ponto de referência não é confiável. No entanto, expor um serviço ou aplicativo à rede de acordo com o número da porta é mais confiável e fácil de gerenciar.

VIII. Concorrência

Dimensione por um modelo de processo

Organizar os processos de acordo com sua finalidade e, em seguida, separar esses processos para que possam ser ampliados e reduzidos de acordo com a necessidade

Caso a carga sobre os servidores da Web aumente, esse grupo pode ser ampliado de maneira isolada para atender às demandas em questão. No entanto, caso ocorra um gargalo devido a uma carga colocada no Serviço de Negócios, essa camada pode ser ampliada de forma independente.

IX. Descartabilidade

Maximizar a robustez com inicialização e desligamento rápido

Os aplicativos devem iniciar e parar normalmente.

Isso significa fazer todas as "limpezas" necessárias antes que um aplicativo seja disponibilizado aos consumidores.

Por exemplo, uma inicialização normal garantirá que todas as conexões de banco de dados e acesso a outros recursos de rede estejam operacionais. Além disso, qualquer outro trabalho de configuração que precise ser realizado já ocorreu.

Em termos de desligamento, a descartabilidade defende a **garantia de que todas as conexões de banco de dados e outros recursos de rede sejam encerrados **corretamente e que todas as atividades de desligamento sejam registradas.

X. Dev/prod semelhantes

Mantenha o desenvolvimento, teste, produção o mais semelhante possível

Basicamente todos os caminhos de implantação são semelhantes, mas independentes e que nenhuma implantação "Salta" para outro passo de implantação.

XI. Logs

Trate logs como fluxo de eventos

O envio de dados de log em um fluxo que vários consumidores interessados podem acessar.

O processo de envio de dados de log precisa ser separado do processamento de dados de log.

Por exemplo, um consumidor pode estar interessado apenas em dados de erro, enquanto outro consumidor pode estar interessado em dados de solicitação/resposta.

Outro consumidor pode estar interessado em armazenar todos os dados de log para arquivamento de eventos. Um benefício adicional é que, mesmo que um aplicativo morra, os dados de log permanecem vivos bem depois.

XII. Processos de Admin

Executar tarefas de administração/gerenciamento como processos pontuais

Processos administrativos são a primeira classe no ciclo de vida de desenvolvimento de software.

Conclusão

Os princípios do aplicativo de 12 fatores são projetados para permitir que os desenvolvedores criem aplicativos destinados a serem executados em escala da web. Eles podem parecer esmagadores no início e, de muitas maneiras, são. Ter que repensar a própria natureza de como você cria software pode ser uma tarefa assustadora.

Felizmente, implementar os princípios do The 12 Factor App não é um negócio de tudo ou nada. Você pode levá-los em pequenos pedaços digeríveis, começando com o primeiro e depois progredindo pelos restantes. O truque é se comprometer a seguir os princípios e então dar o primeiro passo.

RESTful ou Restbut

Sassine El-Asmar — Sun, 08 May 2022 23:05:52 +0000

Você conhece o Modelo de Maturidade de Richardson?

Leonard Richardson propôs um Modelo de Maturidade para avaliar APIs REST que foi usado na Bíblia do REST, o livro REST in Practice, do Jin Webber de 2010 (sim, publicado a 11 anos!).
⠀
Nesse modelo, são propostos 4 níveis de maturidade:

Nível 0

Definitivamente neste nível não podemos nem chamar de REST.
Neste nível estamos apenas usando o protocolo HTTP, sem nenhuma padronização POX (Plain Old XML).

Identificação de recursos – você usa o padrão URI (IRI) para identificar um recurso. Nesse caso, um recurso é um documento da web.

Nível 1

Agrupamos as capacidades em Recursos, tornando suas APIs um pouco mais organizadas, mas ainda não é uma RESTful.

Manipulação de recursos por meio dessas representações – você usa o padrão HTTP para descrever a comunicação. Portanto, por exemplo, GET significa que você deseja recuperar dados sobre o recurso identificado pelo URI. Você pode descrever uma operação com um método HTTP e um URI.

Nível 2 – RESTful

Aqui usamos corretamente os verbos HTTP (ou seja, as APIs usam a Uniform Interface).
Neste ponto, eu já consigo chamar a API de RESTful, apesar de ser difícil encontrar APIs que atingiram completamente os 2 primeiros níveis

Mensagens autodescritivas – você usa tipos MIME padrão e vocabs RDF (padrão) para tornar as mensagens autodescritivas. Assim, o cliente pode encontrar os dados verificando a semântica e não precisa saber a estrutura de dados específica do aplicativo que o serviço usa.

Nível 3

Finalmente no nível 3 usamos Controles Hypermedia, chegando ao HATEOAS.

Hipermídia como mecanismo de estado do aplicativo (também conhecido como HATEOAS) – Você usa hiperlinks e possivelmente modelos de URI para separar o cliente da estrutura URI específica do aplicativo. Você pode anotar esses hiperlinks com semântica, por exemplo, relações de link da IANA, para que o cliente entenda o que eles significam.

{
    "links": {
        "self": "https://sassine.dev/artigos",
        "next": "https://sassine.dev/artigos?page[offset]=1",
        "last": "https://sassine.dev/artigos?page[offset]=40"
    },
    "data": [{
        "type": "artigos",
        "id": "4",
        "attributes": {
            "titulo": "REST(ful) ou REST(but)"
        },
        "relationships": {
            "autor": {
                "links": {
                    "self": "https://sassine.dev/articles/4/author",
                    "related": "https://sassine.dev/articles/4/author"
                }
            },
            "comentarios": {
                "links": {
                    "self": "https://sassine.dev/articles/4/comments",
                    "related": "https://sassine.dev/articles/4/comments"
                }
            }
        },
        "links": {
            "self": "https://sassine.dev/artigos/4"
        }
    }]
}

Apenas analisando esta única resposta, um cliente sabe:

O que foi consultado ( **articles **neste exemplo)
Como está estruturado artigos objetos ( id, titulo, autor, comentarios )
Como recuperar objetos relacionados (ou seja autor, a lista de comentarios)
Que há mais artigos (com 10 base no comprimento da resposta atual e links de paginação)

Agora que já conhece um pouco do modelo, onde sua API está?
Podemos chama-la de RESTful ou está mais para RESTbut?

Tenha um alto desempenho manipulando JSON em Java com Jackson API

Sassine El-Asmar — Sun, 08 May 2022 23:04:30 +0000

Vejo que muita gente ainda tem desconhecimento do poder desta lib, mesmo que já tenha uso em algum desenvolvimento não explorou todo seu conteúdo, pensando nisso montei este artigo para te apresentar as principais funções do Jackson que vão te ajudar muito na manipulação de JSON em Java, quando falamos de REST com Java/Spring... é impossível não pensar no Jackson tratando nossos dados de entrada e saída do nosso serviço como também em outras API que consumimos internamente.

Jackson Object Mapper

A classe Jackson ObjectMapper da FasterXML é a maneira mais simples de analisar JSON com Java.

O Jackson ObjectMapper pode analisar JSON de uma string, fluxo ou arquivo e criar um objeto Java ou gráfico de objeto que representa o JSON analisado. Esse processo é conhecido como** desserialização do JSON*.
Assim como também podemos gerar JSON a partir de objetos Java que seria a **serialização objetos Java para JSON*.

A biblioteca Jackson disponibiliza diversas anotações que podemos usar em nossas classes, facilitando nosso trabalho durante o mapeamento.

Aqui vou falar apenas das que utilizamos no dia a dia mas se quiser saber mais pode acessar a documentação oficial jackson-annotations.

JsonProperty
JsonInclude
JsonIgnore
JsonFormat
JsonSerialize
JsonDeserialize

Json Property

É uma anotação de marcador para definir a propriedade lógica.
@JsonProperty pode ser anotado em método setter ou getter não estático ou campo de objeto não estático.
A propriedade lógica é usada na serialização e desserialização de JSON.

public class ExemploDTO {
   // ... outros campos

   @JsonProperty("nome_do_usuario")
   private String nomeUsuario;

   //... restante da implementação
}

Com o @JsonProperty falamos o nome da chave de origem do JSON e definimos o seu valor a nossa variável.

*O valor da chave “nome_do_usuario” será atrelado a nossa variável nomeUsuario *

Json Include

é usado em propriedades de exclusão com valores nulos / vazios ou padrão.

Classe sem @JsonInclude

public class ExemploDTO {
   private int id;
   private String nome;

  ExemploDTO (int id,String nome) {
    this.id = id;
    this.name = name;
 }
}

{ "id": 15, "nome": null }

Agora com @JsonInclude

@JsonInclude(JsonInclude.Include.NON_NULL)
public class ExemploDTO {
   private int id;
   private String nome;

  ExemploDTO (int id,String nome) {
    this.id = id;
    this.nome= nome;
 }
}

Saída :

{ "id": 15 }

por conta do valor da variável 'nome' ser nulla ela foi excluída do json final.

Existem 6 tipos de Include

ALWAYS
- Valor que indica que a propriedade deve ser sempre incluída, independente do valor da propriedade.
NON_ABSENT
- Valor que indica que as propriedades estão incluídas, a *menos que seu valor seja valor nulo de um tipo referencial *(como Java 8+ 'Optional' ou AtomicReference); isto é, algo que não respeitaria um valor não nulo.
NON_DEFAULT
- O significado dessa configuração depende do contexto: se a anotação é especificada para o tipo POJO (classe) ou não.

Se for tipo POJO apenas as propriedades com valores padrões serão excluídas

Exemplo:

@JsonInclude(JsonInclude.Include.NON_DEFAULT)
public class Empregado {
  private String nome;
  private String departamento;
  private Integer salario;
  private boolean tempoIntegral;
// ...

public class ExemploMain {
  public static void main(String[] args) throws IOException {
      Empregado empregado = new Empregado ();
      empregado .setNome("Sassine");
      empregado .setTempoIntegral(false);
      empregado .setSalario(Integer.valueOf(0));

      ObjectMapper om = new ObjectMapper();
      String jsonString = om.writeValueAsString(empregado );
      System.out.println(jsonString);
  }
}

Saída :

{"nome":"Sassine","salario":0 }

Em nível de campo ou global será excluído todas propriedades que tenham seus valores definidos com valores padrões ou vazios, listas vazias e afins...

Saída seria algo assim:

{"nome":"Sassine" }

NON_EMPTY
- Valor que indica que somente as propriedades com valor nulo, ou o que for considerado vazio, não devem ser incluídas.
NON_NULL
- Valor que indica que somente propriedades com valores não nulos devem ser incluídas.
USE_DEFAULTS
- Pseudo-valor para indicar que os padrões de nível superior fazem sentido, para evitar substituir o valor de inclusão.

Json Ignore

Json ignore funciona semelhante ao Include porem ele pode ser usado para especificar apenas que aquele campo não será deserializado mesmo contendo valor.

public class ExemploDTO {
   @JsonIgnore
   private int id;
   private String nome;

  ExemploDTO (int id,String nome) {
    this.id = id;
    this.nome= nome;
 }
}

{ "nome": null }

Json Format

É uma anotação de Jackson usada para especificar como formatar campos e / ou propriedades para saída JSON.
Especificamente, essa anotação permite que você especifique como formatar os valores de Data e Calendário de acordo com um formato SimpleDateFormat.

public class ExemploDTO {
   @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
   private Date dataVencimento;

   @JsonFormat(shape = JsonFormat.Shape.NUMBER)
   private ExemploEnum tipoUsuario = ExemploEnum.MODERADOR;
}

Saída:

{ "dataVencimento": "2022-04-26", "tipoUsuario" : 2}

Json Serialize

Indica um serializador personalizado a ser usado ao empacotar a entidade

Exemplo usando um serializador customziado

public class ExemploDTO {

   private String name;

   @JsonSerialize(using =  CustomDateSerializer.class)
   private Date dataVencimento;
}

public class CustomDateSerializer extends StdSerializer {

    private static SimpleDateFormat FORMATTER = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");

    public CustomDateSerializer() {
        this(null);
    }

    public CustomDateSerializer() {
        super(t);
    }

    @Override
    public void serialize(Date value, JsonGenerator gen, SerialzerProvider arg2) throws IOException, JsonProcessingException {
        gen.writeString(FORMATTER.format(value));
    }
}

Bonus:
Nas versões novas do java utilizamos a API do java.time, se precisar utilizar um serializador para tal, a lib jsr310 do jackson tem o seguinte import:

ToStringSerializer

Json Deserialize

Assim como o @JsonSerialize indica um serializador custom, o json deserialize aponta um deserializador customizado.

public class JsonDeserializeDTO {
    public String nome;

    @JsonDeserialize(using = CustomDateDeserializer.class)
    public Date dataVencimento;
}

public class CustomDateDeserializer extends StdDeserializer<Date> {
    private static SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy");

    public CustomDateDeserializer() {
        this(null);
    }

    public CustomDateDeserializer(Class<?> vc) {
        this(vc);
    }

    @Override
    public Date deserialize(JsonParser jsonparser, DeserializationContext context) throws IOException {
        String date = jsonparser.getText();
        try {
            return formatter.parse(date);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }
}

Saída:

{ "dataVencimento": "2022-04-26", "nome" : "Sassine"}

Bonus:
Nas versões novas do java utilizamos a API do java.time, se precisar utilizar um deserializador para tal, a lib jsr310 do jackson tem os seguintes itens:

LocalDateTime == LocalDateTimeDeserializer

LocalDate == LocalDateDeserializer

LocalTime == LocalTimeDeserializer

Conclusão

Utilizando essas principais anotações em sua aplicação durante a manipulação dos dados de entrada no formato JSON você estará otimizando muito tempo e linhas de códigos que seriam responsáveis por essas conversões de forma manual.

E isso tudo combinado com o a lib do javax.validation (estarei fazendo um post sobre em breve) torna a serialização e manipulação de JSON em sua API em um escopo extremamente seguro, limpo com diminuição de linhas de códigos para aplicar estas regras de conversão e de negócios e de fácil manutenção.

Monolito e Micro serviços saiba usar cada um no seu contexto

Sassine El-Asmar — Sun, 08 May 2022 23:03:36 +0000

Introdução

De vez em quando, surge um novo paradigma ou tecnologia. Isso traz esperança e entusiasmo. Isso vai salvar todos nós! desta vez é são os Micros serviços… não tão novo assim né.

Porém, como tudo na vida, toda solução teve o seu problema.
O hype faz você esquecer essa pequena cláusula no final do contrato. E os resultados são catastróficos.

O padrão de Micros serviços não é nada novo , na verdade, como quase todo design emergente (além de já existir há alguns anos).
É a Programação Orientada a Objetos aplicada em um nível superior: arquitetura de aplicativos.

Ao criar um programa usando a Programação Orientada a Objetos, você o divide em várias partes, Classes .
Cada classe representa um componente da solução e tem uma função específica.
Ele também funciona apenas em seu próprio subconjunto de dados.
Isso soa familiar né?

Conheça os dois princípios – o bom alfaiate

Ao projetar Classes, você deve seguir dois princípios principais:
Acoplamento fraco e alta coesão.

Para ser honesto, essas devem ser as estrelas orientadoras de cada projeto de software, não apenas as OOP. Mas essa é outra história…

Alta coesão é a situação em que cada componente é fortemente consistente. Todos os seus dados e métodos referem-se a uma área, significado ou função muito específica.

O acoplamento fraco é a situação em que cada componente tem a menor quantidade possível de interações com outros componentes. Ele pode funcionar por conta própria, ocultando detalhes de baixo nível e expõe as interfaces essenciais.

Para micros serviços é o mesmo.

Um** bom design OOP leva a um design de micros serviço ideal**. Não há meio termo, isso deve ser quase o suficiente para responder por que e quando usar micros serviços.
Mas já que há mais, vamos decompô-lo.

Da pra dividir seu aplicativo em sub-processos?

Imagine o quanto é fácil fazer dois objetos interagirem. Você apenas tem que chamar o método de um objeto e você está pronto para ir. Tudo dentro de um único programa.

Em vez disso, os micros serviços vivem em processos diferentes. Possivelmente, em máquinas diferentes.
Você tem que se comunicar em uma rede, usando APIs. E isso adiciona complexidade!

Você deve ter excelentes razões para fazer isso.

Nem por tendência, nem por diversão .
Porque, garanto a você, se você usar micros serviços aleatoriamente, o gerenciamento deles não será nada divertido

APIs permitem ocultar todos os detalhes de implementação por trás delas.
Isso é essencial em alguns casos e oferece benefícios incríveis.

Escalabilidade para tráfego não uniforme
Resiliência a erros
Implementações separadas
Isolamento completo
Requisitos diferentes

Existem muitos motivos, alguns mais comuns do que outros.
Nesses casos, divida o aplicativo!

Provavelmente é mais fácil. Mas lembre-se de respeitar os Dois Princípios! Seja um bom alfaiate, ou você terá dificuldades para compartilhar dados entre seus micros serviços.

Não é o seu caso? Vá para um Monólito

Se o seu sistema estiver totalmente acoplado, use um único aplicativo. Um monólito.

Você terá um gerenciamento de dependência mais limpo e não precisará de orquestrações complexas ou sistemas distribuídos para rastrear erros, compartilhar dados, coletar logs, sincronizar chamadas, proteger interações de rede … e eu posso continuar.

Se seu aplicativo atende a uma longa sequência de chamadas de API , talvez porque uma API exija o resultado das anteriores, isso não é o ideal. Isso também introduziria atrasos na rede…
Se sua aplicação for um procedimento único que requer interação do usuário, bem, a frase é auto explicativa.

Você deve compartilhar um estado entre as chamadas, cada componente não é independente e um único erro na sequência o bloqueará totalmente . Dificilmente há benefício em dividir o aplicativo.

E lembre-se, Monólito não significa bagunça

Alguém vê o Monólito como um monte de código não ordenado.

Eles afirmam que o padrão de micros serviços é a única maneira de ter divisões, ordem e tudo.

😒 Bem, vou revelar algo..

Não é verdade. O design do seu código não depende das divisões do processo.
A Programação Orientada a Objetos também não. Se você dividir seu código direito, se gerenciar suas dependências em uma hierarquia clara, assim como seus arquivos, você pode atingir o mesmo nível de coesão e desacoplamento.

E outro segredo: se você dividir suas APIs em pacotes / módulos / controladores / projetos / o que quer que seja em seu código, você pode decidir servi-los em um único processo ou dividi-los em micros serviços em tempo de construção ou em tempo de execução também, de graça. 🎆🚀

Conclusões

Se usados no contexto certo , pelos motivos certos , eles resolvem problemas e melhoram o desempenho ou os custos.

Mas, por favor, pare de torná-los a única solução para todos os problemas.
Porque também podem ser a raiz de todo o mal.

Chega de NullPointer, comece a utilizar Optional em sua codificação!

Sassine El-Asmar — Sun, 08 May 2022 23:02:29 +0000

Introdução

Sempre que estou entrevistando um novo candidato eu o questiono sobre o uso ou conhecimento do Optional, e quase sempre ouço a mesma resposta "Já utilizei, quando usei o JPA "😢

📦 Caso queira acompanhar a classe completa enquanto lê o artigo acesse ele no GitHub - Optional-Stream-usecase-example

Optional

O uso do Optional vai muito além do JPA ele veio como uma solução para ser utilizado para simplificar as validações de objetos nulos, neste post vou mostrar a vocês todas as formas de utilizar ele no seu dia dia e com isso reduzir em 99.9% as chances de se obter um NullPointer e tornar o seu código mais limpo.

isPresent

Quando manipulamos Optional ele nos entrega uma função que é os .isPresent() que é responsável por nos informar se existe um valor ou se é nulo retorna um booleano falso e existir valor será verdadeiro

 private boolean methodExampleReceivesOptional(Optional<String> opt) {
        return opt.isPresent();
 }

empty

Sempre que tiver um método que o retorno poderá ser nulo invés de retornar null retorne .empty()

private void returnEmptyOptional() {
    Optional<String> opt = Optional.empty();
    if (methodExampleReceivesOptional(opt))
        msg(VALUE_FOUND);
    else
        msg(VALUE_NOT_FOUND);
}

// print: "value not found"

of

Quando tiver certeza que o valor a ser retornado não será nulo, ou quando você for enviar um valor para um método/função que recebe Optional, você devera criar ele utilizando .of(Object)

private void returnOptionalFixValue() {
    var opt = Optional.of("Sassine");
    if (methodExampleReceivesOptional(opt))
        msg(VALUE_FOUND);
    else
        msg(VALUE_NOT_FOUND);
}

// print: "value found"

Se tentarmos passar um valor direto para o método

methodExampleReceivesOptional("Sassine");

não funcionará pois ele não pode receber um valor que não seja Optional

ofNullable

Neste caso não temos certeza se o valor irá existir ou será nulo, vai depender do valor gerado então utilizamos o .ofNullable(Object) esse cara é quem irá te acompanhar para evitar e tratar todos seus NullPointers agora!

private void returnDynamicOptional() {
    Random r = new Random();
    var n = r.nextInt((2 - 1) + 1) + 1;
    var opt = Optional.ofNullable(n == 1 ? null : "Sassine");
    if (methodExampleReceivesOptional(opt))
        msg(VALUE_FOUND);
    else
        msg(VALUE_NOT_FOUND);
}

// print: "value found" or "value not found"

get

Quando temos a confirmação de que o valor existe com o "ifPresent" podemos recuperar o valor contido no Optional e manipularmos da forma que quisermos utilizando a chamada .get()

private void getOptionalValue() {
    Optional<String> valueOpt = Optional.of("Sassine");
    if (methodExampleReceivesOptional(valueOpt))
        msg(valueOpt.get());
    else
        msg(VALUE_NOT_FOUND);
}

// print: Sassine

orElse

Com Optional OfNullable se o seu valor for nulo conseguimos falar para ele nos entregar um valor padrão fixado ou até mesmo chamar outra função para recuperar outro valor utilizando .orElse(Object) ou .orElseGet(() -> args())

    private void returnDefaultValueWhenNull() {
        String ex = null;
        String valueOpt = Optional.ofNullable(ex).orElse("Sassine - Default");
        msg("value found > %s".formatted(valueOpt));
        String valueOpt2 = Optional.ofNullable(ex).orElse(getName());
        msg("value found > %s".formatted(valueOpt2));
        String valueOpt3 = Optional.ofNullable(ex).orElseGet(Person::getName);
        msg("value found > %s".formatted(valueOpt3));
    }

/* 
print1: value found > Sassine - Default
print2: value found > Sassine - Function
print3: value found > Sassine - Class
*/

orElseThrow

Conseguimos fazer com que o Optional lance uma Exception conforme a gente definir quando o valor for nulo utilizando .orElseThrow(() -> new Exception())

private void returnCustomExecutionIfNull() {
    try {
        String ex = null;
        Optional.ofNullable(ex).orElseThrow(() -> new RuntimeException("value not found - exception"));
    } catch (RuntimeException e) {
        msg(e.getMessage());
    }
}

//print: value not found - exception

Optional Java 9+

ifPresentOrElse

Para simplificar os ifPresent e o get, no java 9 foi disponibilizado o .ifPresentOrElse((),()) que simplifica a implementação e a tomada de decisão

private void ifPresentOrElse() {
    String ex = null;
    Optional.ofNullable(ex)
    .ifPresentOrElse(v -> msg(VALUE_FOUND_S.formatted(v)), () -> msg(VALUE_NOT_FOUND));

    Optional.ofNullable("Sassine")
    .ifPresentOrElse(v -> msg(VALUE_FOUND_S.formatted(v)), () -> msg(VALUE_NOT_FOUND));
}

//print: value not found
//print2:  value found > Sassine

getValueOr

Com .or(() -> ...) se o 1 valor não estiver presente ele executa uma ação ... neste exemplo buscar o valor existente na função getName

private void getValueOr() {
    String ex = null;
    Optional.ofNullable(ex)
    .or(() -> Optional.of(getName()))
    .ifPresent(this::msg);
}

//print: Sassine - Function

optionalStream

Optional também permite o uso de .stream(), se um valor estiver presente ele retorna o stream caso contrario retorna uma stream vazia!

private void optionalStream() {
    var list = List.of("AB", "CD");
    Optional.ofNullable(list).stream().forEach(l -> {
        l.forEach(this::msg);
    });
    List<String> x = null;
    Optional.ofNullable(x).stream().forEach(l -> {
        l.forEach(this::msg);
    });
}

//print: ABCD
//print2:

Se quiser dar uma olhada/testar o projeto está em meu github ;)

Java 8 ao Java 18 em dez minutos 🚀

Sassine El-Asmar — Tue, 26 Apr 2022 23:06:19 +0000

Vou apresentar as grandes melhorias de cada versão do Java, agora oferece suporte total para lambdas , programação funcional, digite inferência via var, coleções imutáveis com construtores simples e mais performáticos e string multi-linhas.... além disso, existem novos recursos empolgantes, como classes de dados (record), switch 2.0 e sealed classes.

Java 8

Programação Funcional

No Java 8, programação funcional e lambdas foram adicionados como recursos de linguagem.
Os dois paradigmas principais de programação funcional estão valores imutáveis e elevando funções para cidadãos de primeira classe.

Os dados passam por um pipeline de etapas de modificação, onde cada etapa pega alguma entrada e mapeia para uma nova saída, que podem ser usadas com Streams e Optional .

Streams

Para um programa de computador comum, geralmente você precisa trabalhar com uma lista de valores e realizar uma determinada transformação em cada valor . Antes do Java 8, você tinha que usar um for loop para essa transformação, mas a partir de agora, você pode usar Streams da seguinte maneira:

Stream.of("Oi", "E ai")
    .map(s -> s + " Sassine")
    .forEach(System.out::println);
> Oi Sassine
> E ai Sassine

A função map recebe como entrada um lambda, que será aplicado a todos os elementos do fluxo.

Streams pode trabalhar em Lists, Sets e Maps (via transformação).
Graças ao Streams, você pode se livrar de praticamente todos os loops em seu código! top né ?

Depois vou escrever um post explicando melhor streams e editar aqui; ✨

Optional

Outro problema comum em Java eram as exceções de ponteiro nulo.
Portanto, Java introduziu Optional – que envolve uma referência que pode ou não ser nula. A aplicação de atualizações a este opcional pode ser feita de maneira funcional:.

Optional.of(new Random().nextInt(10))
    .filter(i -> i % 2 == 0)
    .map(i -> "número é par: " + i)
    .ifPresent(System.out::println);
> número é par: 6

No trecho acima, criamos um número aleatório, envolvemos dentro de um objeto opcional e, em seguida, imprimimos o número apenas se for par.

Depois vou escrever um post explicando melhor como utilizar o Optional e editar aqui; ✨

Java 9

JShell

Finalmente, temos um REPL para Java, e seu nome é JShell ! 😊 Em poucas palavras, JShell permite experimentar trechos de Java sem escrever e compilar uma classe Java completa. Em vez disso, você pode executar um comando por vez e ver o resultado imediatamente. Aqui está um exemplo simples:

$ <JDK_HOME>/bin/jshell > System.out.println("Sassine.dev")
> Sassine.dev

Pessoas familiarizadas com linguagens interpretadas como JavaScript ou Python tiveram o prazer de um REPL por muito tempo, mas até agora, esse recurso estava faltando em Java. JShell permite definir variáveis , mas também entidades mais complexas, como funções multilinhas , classes e executar loops.

Além disso, o JShell oferece suporte ao preenchimento automático, o que é útil se você não souber os métodos exatos oferecidos por uma determinada classe Java

Fábrica para coleções imutáveis

A inicialização simples do Lists está faltando no Java há muito tempo, mas esses tempos acabaram agora. 😅 Anteriormente, você tinha que fazer algo assim:

jshell> List<Integer> list = Arrays.asList(1, 2, 3, 4)
list ==> [1, 2, 3, 4]

# Isso agora é simplificado da seguinte forma:

jshell> List<Integer> list = List.of(1, 2, 3, 4)
list  ==> [1, 2, 3, 4]

Este of(...) método sofisticado existe para List , Set e Map . Todos eles criam um objeto imutável em apenas uma linha simples de código.

Java 10

var

Java 10 introduziu a nova palavra-chave var que permite omitir o tipo de uma variável.

var baos = new ByteArrayOutputStream();

Esse recurso ajuda a reduzir o código clichê e melhorar a legibilidade.
Porém, há algumas limitações: você só pode usar var dentro dos corpos dos métodos, e o compilador inferirá o tipo em tempo de compilação, então tudo ainda está estaticamente tipado.

Java 11

Arquivo de fonte única

Anteriormente, quando você escrevia um programa Java simples consistindo em um arquivo, era necessário primeiro compilar o arquivo com javac e depois executá-lo java.
No Java 11, você pode executar as duas etapas com um comando.

Classe exemplo:

public class TesteCompile {
  public static void main(String[] args) {
    System.out.println("olá mundo");
  }
}

Executando a classe:

java ./TesteCompile.java
> olá mundo

Para programas iniciais simples ou experimentos que consistem em apenas uma classe Java, esse recurso para iniciar arquivos de código-fonte único tornará sua vida mais fácil.

Java 12

Switch 2.0

Aqui está uma demonstração rápida de como a expressão difere da antiga instrução switch.

A antiga instrução switch define o fluxo do programa:

jshell> var i = 2
jshell> String s;
jshell> switch(i) {
   ...>     case 1: s = "um"; break;
   ...>     case 2: s = "dois"; break;
   ...>     case 3: s = "três"; break;
   ...>     default: s = "número desconhecido";
   ...> }
jshell> s
s ==> "dois"

Agora a nova expressão switch retorna um valor:

jshell > var i = 2 ;
jshell > var x = switch (i) {
   ... >      case 1 ->  "um";
   ... >      case 2 ->  "dois";
   ... >      case 3 ->  "três";
   ... >      default -> "número desconhecido";
   ... > } ;
x ==>  "dois"

Para resumir, a instrução switch antiga é para o fluxo do programa e a nova expressão switch resolve para um valor.

Observe que essa nova instrução switch é uma espécie de função de mapeamento : há uma entrada (no caso acima i) e há uma saída (aqui x). Na verdade, esse é um recurso de correspondência de padrões que ajuda a tornar o Java mais compatível com os princípios de programação funcional . Uma instrução switch semelhante está disponível no Scala há algum tempo.

Algumas coisas a serem observadas:

Em vez de pontos duplos, usamos setas ->
Não há necessidade de break
O caso padrão pode ser omitido quando todos os casos possíveis são considerados

Para habilitar este recurso com Java 12, use --enable-preview --source 12

Java 13

Strings multilinhas

Você já teve que definir uma string longa de várias linhas como JSON ou XML? Até agora, você provavelmente esmagaria tudo em uma linha e usaria caracteres de nova linha \n, mas isso torna a String muito mais difícil de ler. Aí vem o Java 13 com strings de várias linhas ! 💪

Se liga só !!

public class TesteCompile { 
  public static void main(String [] args) {
    var s = """
        {
            "nome": "Sassine El-Asmar",
            "idade": "23",
            "stacks": ["backend", "frontend", "mobile"]
        } """;
    System.out.println(s);
  }
}

Agora, executamos o método principal por meio de inicialização de arquivo único:

java --enable-preview --source 13 TesteCompile.java

{
  "nome": "Sassine El-Asmar",
  "idade": "23",
  "stacks": ["backend", "frontend", "mobile"]
}

A String resultante se estende por várias linhas, as aspas "" são deixadas intactas e até as guias \t são preservadas!

Java 14

Classes de dados: record (Chega de lombok ?)

Agora existem classes de dados em Java! Essas classes são declaradas com a palavra-chave record e têm Getters automáticos, um construtor e o método equals () etc.
Você pode se livrar de um grande pedaço de código clichê! 🙌

jshell> record Pessoa(String nome, int idade) {}
|  created record Pessoa

jshell> var x = new Employee("Sassine", 23);
x ==> Pessoa[nome=Sassine, idade=23]

jshell> x.name()
$2 ==> "Sassine"

Scala tem um recurso semelhante com classes de caso e Kotlin com classes de dados . Em Java, muitos desenvolvedores usaram o Lombok até agora, que oferecia praticamente os recursos que agora inspiravam o records Java 14.
Mais detalhes podem ser encontrados neste artigo do Baeldung.

Instanceof já devolvendo o objeto tipado

Primeiro verificamos se s é do tipo e String, em seguida, lançamos novamente para recuperar seu comprimento… né?

Não mais! agora, com o Java 14, o compilador é inteligente o suficiente para inferir o tipo automaticamente após a verificação de instância :

Object obj = new String("Oi");
if (obj instanceof String s) {
  System.out.println("String length: " + s.length());
}

Java 15

Classes seladas - sealed

Com a palavra-chave sealed , você pode restringir quais classes podem estender uma determinada classe ou interface.

Aqui está um exemplo:

public sealed interface Fruit permits Apple, Pear {
    String getName();
}

public final class Apple implements Fruit {
    public String getName() { return "Apple"; }
}

public final class Pear implements Fruit {
    public String getName() { return "Pear"; }
}

Então, como isso nos ajuda? Bem, agora você sabe quantos Fruits são. Este é realmente um passo importante na direção de correspondência de padrões totalmente suportada , onde você pode tratar as classes como enums.

Esse sealed recurso combina perfeitamente com a nova switch expressão explicada anteriormente.

Java 16

Todos preview listados acima do java 14+ liberado definitivamente

Ou seja não precisa mais do ” –enable-preview ” para os itens listados acima .

API Vector

A API de vetor fornece um mecanismo para os desenvolvedores tornarem explícito para o compilador que as operações de vetor devem ser usadas. No entanto, isso torna o código mais complicado. Primeiro, é necessário obter uma espécie de vetor.

static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_256;

void vectorComputation(float[] a, float[] b, float[] c) {
    for (int i = 0; i < a.length; i += SPECIES.length()) {
        var m = SPECIES.indexInRange(i, a.length);

        // FloatVector va, vb, vc;
        var va = FloatVector.fromArray(SPECIES, a, i, m);
        var vb = FloatVector.fromArray(SPECIES, b, i, m);
        var vc = va.mul(va)
           .add(vb.mul(vb))
           .neg();

        vc.intoArray(c, i, m);
    }
}

Java 17

Correspondência de padrões para switch (preview)

Expanda a expressividade e a aplicabilidade das expressões switch, permitindo que os padrões apareçam nos rótulos de maiúsculas e minúsculas sem precisar de Instaceof.
Introduziu dois novos padrões: padrões protegidos e entre parênteses.

Implementação antes do JDK17:

public String getValue(Object o) {
        String result = "";
        if(o instanceof Integer i) {
            result = "Integer %d".formatted(i);
        } else if(o instanceof Double d) {
            result = "Double %d".formatted(d);
        } else if(o instanceof Long l) {
            result = "Long %d".formatted(l);
        } else if(o instanceof String s) {
            result = "String %d".formatted(s);
        }
        return result;
}

Vamos refatorar esse método para a nova feature do JDK17:

public String getValue(Object o) {
        return switch(o) { 
        case Integer i -> "Integer %d".formatted(i);
        case Double d -> "Double %d".formatted(d);
        case Long l -> "Long %d".formatted(l);
        case String s -> "String %d".formatted(is);
        default -> o.toString();
        };
}

Dê uma olhada e um exemplo utilizando os novos padrões:

public void quantasPortasTem(Veiculo o) {
        switch(o){ 
        case Carro c && (c.getPortas == 2) -> 
        System.out.println("é um carro duas portas");
        case Carro c && (c.getPortas == 4) ->
        System.out.println("é um carro quatro portas");
        default -> System.out.println("não é um carro.");
        };
}

Java 18

UTF-8 por padrão

A codificação padrão atual pode ser lida em tempo de execução por meio Charset.defaultCharset()da propriedade do sistema "file.encoding". Desde o Java 17 , a propriedade do sistema "native.encoding" pode ser usada para ler a codificação, que – antes do Java 18 – seria a codificação padrão se nenhuma for especificada:

Sendo assim o file.encoding poderia vir como UTF-8 em alguns sistemas, Cp1252 ou default.

Antes:

Default charset : US-ASCII
file.encoding   : default
native.encoding : UTF-8

Agora

Default charset : UTF-8
file.encoding   : UTF-8
native.encoding : Cp1252

Agora no java 18 default não é mais reconhecido e por padrão "file.encoding" é UTF-8

No Linux e MacOS tanto o java 17 e 18 já resultam em todas as opções como UTF-8

Snippets para Java API Doc

Até agora, se quiséssemos integrar trechos de código de várias linhas ao JavaDoc, tínhamos que fazer isso de maneira bastante complicada via <'pre>… e algumas regrinhas que tinhamos que seguir.

Agora com a tag @ snippet conseguimos exibir o trecho do código-fonte completo.

/**
 * Escrevendo um arquivo:
 *
 * {@snippet :
 * try (BufferedWriter writer = Files.newBufferedWriter(path)) {
 *   writer.write(text);
 * }
 * }
 */

Integrar trechos de outros arquivos

No FileWriter.java , marcaríamos o código da seguinte forma:

// @start region="writeFile"
try (BufferedWriter writer = Files.newBufferedWriter(path)) {
  writer.write(text);
}
// @end

e utilizamos a referencia dele assim:

/**
 * Escrevendo um arquivo:
 *
 * {@snippet file="FileWriter.java" region="writeFile"}
 */

fim

Bom, listei as principais funções novas que tivemos entre as versões 8 a 18 😎
mas claro que existem muitas outras além de depreciações de lib;

Quiser saber mais acesse a documentação oficial da Oracle