Pausa para café #109. As habilidades mais exigidas em desenvolvimento Java no momento. 7 dicas opcionais de Java para se livrar da confusão de código

As habilidades mais exigidas em desenvolvimento Java no momento

Fonte: Medium Java continua sendo uma das linguagens de programação mais populares e procuradas, apesar de ter quase um quarto de século. Portanto, é razoável supor que a popularidade do Java continuará a crescer e que os desenvolvedores de Java verão uma demanda ainda maior por parte dos empregadores no futuro. Para criar produtos de qualidade, os desenvolvedores precisam se manter atualizados com as ferramentas Java mais recentes e aprimorar suas habilidades e conhecimentos técnicos. Abaixo apresentamos seis habilidades essenciais exigidas para desenvolvedores Java.

1. Excelente conhecimento de Java 8

Embora as versões mais recentes do Java já sejam amplamente utilizadas, todos os aspirantes a desenvolvedores Java precisam de conhecimento e experiência profundos com Java 8. Alguns dos recursos mais úteis do Java 8 incluem:

• Métodos padrão e estáticos para criação de interfaces com implementações de métodos.
• Uma interface funcional que possui apenas um método abstrato e ajuda os desenvolvedores a evitar a adição de outros métodos abstratos.
• Expressões lambda que ajudam a criar interfaces funcionais.
• API Java Stream para permitir execução paralela e sequencial.
• Novos métodos na API Collection.

Todos esses recursos tornam o Java 8 indispensável para a programação funcional. A programação funcional fornece simultaneidade e brevidade de código e ajuda a criar aplicativos de alta carga com código otimizado. Java 8 também se tornou a base para otimização de código nativo, permitindo a otimização do desenvolvimento em outras linguagens como Scala, Kotlin e Grails.

2. Experiência com testes

O teste unitário em Java é um tópico bastante controverso. Alguns desenvolvedores argumentam que escrever testes unitários é uma perda de tempo, mas acreditamos firmemente que habilidades em testes unitários são obrigatórias para qualquer desenvolvedor Java profissional. O teste de unidade permite testar blocos individuais de código e garante que o produto final funcione sem erros. Portanto, se um desenvolvedor deseja aprimorar suas habilidades e conhecimentos, ele precisa aprender a usar as ferramentas de teste mais populares e eficazes. A principal estrutura de teste com a qual você precisa se familiarizar é a biblioteca JUnit 5. Outras ferramentas incluem:

• Estrutura do Robô
• Mockito
• PowerMock

Além do teste unitário, um desenvolvedor Java não deve se esquecer de outros métodos de teste (teste de sistema, teste de aceitação e teste de integração). Isso permite realizar testes abrangentes do software e garantir que não haja erros, bugs ou falhas críticas. A principal coisa a lembrar sobre os testes é que pequenas mudanças levam a grandes resultados. Se você não hesitar em investir tempo e esforço em testes unitários, ficará surpreso com a melhoria na qualidade do seu trabalho.

3. DevOps

Embora não seja obrigatório, aprender sobre DevOps e seus princípios pode ser benéfico para você como desenvolvedor e para a empresa em que trabalha. A flexibilidade e organização dos processos DevOps permitem às empresas otimizar a qualidade dos seus produtos e agilizar as operações. e também aumentar a transparência dos processos. DevOps em Java é essencialmente a aplicação de DevOps ao desenvolvimento Java. Isso inclui:

• Entrega e integração contínuas.
• Trabalhando com microsserviços em vez de monólitos.
• Infraestrutura como código.
• Testes automatizados.

DevOps é um campo vasto e requer uma quantidade significativa de tempo e recursos para estudá-lo. Mas se você for um desenvolvedor Java, aprender DevOps será benéfico, pois permitirá que você se torne um engenheiro de DevOps no futuro. Se você não quer se tornar um engenheiro DevOps ou se sua empresa não está interessada nisso, tudo bem também. Lembre-se de que o DevOps está se tornando cada vez mais popular na comunidade Java.

4. Conhecimento de bibliotecas e APIs Java.

Como Java é uma das principais linguagens de programação do mundo, não é surpresa que tenha um grande número de APIs e bibliotecas disponíveis para trabalhar. Essas ferramentas simplificam muito o processo de desenvolvimento e permitem que os desenvolvedores criem software confiável rapidamente. Abaixo listamos um conjunto básico de ferramentas que qualquer bom desenvolvedor Java conhece e pode usar com segurança. Essas ferramentas ajudam você a construir rapidamente um aplicativo e gerenciar dados e seu armazenamento de maneira eficaz:

• Gradle (uma ferramenta para construção de aplicações);
• Maven (um pouco desatualizado, mas ainda popular, também usado para construir aplicações);
• Pacotes padrão Java 8;
• Estruturas Spring;
• JPA ORM (Hibernate, TopLink);
• Bancos de dados NoSQL (MongoDB, Cassandra).

Quanto à API, para trabalhar com a API Java principal, um desenvolvedor precisa ter um bom conhecimento de OpenJDK, Android, Oracle e IS2T. A grande vantagem dessas ferramentas é que todas vêm com documentação detalhada e informativa. Além disso, os desenvolvedores sempre podem obter suporte da comunidade, o que também é uma grande vantagem.

5. Conhecimento confiável de Spring e Spring Boot

O Spring Framework é o framework mais comumente usado para desenvolver aplicativos baseados em Java, por isso é importante que o desenvolvedor saiba como trabalhar com ele. Um dos principais benefícios do Spring é a injeção de dependência, que permite criar aplicativos fracamente acoplados e oferece aos desenvolvedores mais flexibilidade. Spring também é muito leve, suportando configurações XML, anotações e programação declarativa. Portanto, se você deseja dominar as habilidades de desenvolvimento Java, também deve dominar a implantação do Spring. Spring Boot é uma iteração do Spring que fornece uma ferramenta conveniente para implantar aplicativos rapidamente. É seguro dizer que o Spring Boot usa o Spring como base e constrói seus próprios recursos sobre ele. Enquanto o Spring se concentra na flexibilidade, o Spring Boot ajuda a reduzir o código e simplificar o processo de desenvolvimento. Ele oferece aos desenvolvedores recursos prontos para uso, ajuda a criar aplicativos independentes e é, em geral, mais fácil de iniciar e gerenciar. Spring Boot é ótimo para microsserviços e aplicativos que precisam ser construídos rapidamente, pois torna rápido e fácil configurar e executar aplicativos para uma variedade de ambientes (produção, teste, qualidade, CI/CD). Tanto o Spring quanto o Spring Boot se expandiram com recursos de programação React, que é outra tendência importante na comunidade de desenvolvedores. Spring 5, por exemplo, agora conta com WebFlux para implementar uma abordagem reativa para programação e resolução de sistemas distribuídos complexos.

6. Experiência com Big Data

Big Data é uma tendência crescente que os desenvolvedores devem seguir e adotar para atender às demandas do mercado. As principais ferramentas com as quais os desenvolvedores Java profissionais podem se familiarizar são:

• Apache Faísca
• Apache Kafka
• Hadoop (para processamento em lote)

Apache Spark é uma plataforma distribuída de processamento de Big Data que fornece ligações nativas para Java. Esta estrutura se tornou extremamente popular devido aos seus recursos e desempenho e é atualmente a ferramenta de big data preferida na comunidade Java. O Apache Spark pode rodar em modo cluster standalone e para isso você só precisa de um ambiente Apache Spark e uma JVM (para cada máquina do cluster). O Spark também é incrivelmente rápido e possui uma API Spark muito fácil de usar. Hadoop é uma plataforma de armazenamento de dados também bem conhecida pelos desenvolvedores Java. Embora o Hadoop não seja tão rápido quanto o Spark, ele continua sendo uma das ferramentas mais populares para trabalhar com big data. Isso também se deve ao fato de que o Hadoop (e soluções similares) possui um grande número de plug-ins que permitem resolver com eficiência problemas de processamento de Big Data e otimizar geralmente o desempenho do Hadoop (incluindo suporte para processamento de fluxo em tempo real).

7 dicas opcionais de Java para se livrar da confusão de código

Fonte: Médio “Tenho colegas que não sabem da existência do Opcional”, escreve um desenvolvedor Java no Reddit. Podemos considerar que Opcional melhora a “legibilidade” do código? Vale a pena usá-lo o tempo todo? Onde o uso de Opcional é completamente desnecessário? Como muitos desenvolvedores ainda não sabem usar o Opcional corretamente, darei 7 exemplos de abusos do Opcional e o que fazer a respeito deles.

1. Não use Opcional para verificação nula

Usar Opcional em vez de verificação nula apenas adiciona confusão. Não há benefício nisso. Também é um erro usar os métodos opcional e isPresent e get . Os desenvolvedores acreditam que get deve funcionar conforme o esperado. Eles então adicionam isPresent e retornam para verificação nula. Lembre-se de que Opcional não corrige suas verificações nulas. Da próxima vez que você vir isPresent e get (ou ElseThrow ) altere este trecho de código. Use mapeamento e orElse para remover verificações nulas padrão e use Opcional de forma mais seletiva. Aqui está um bom exemplo:

var user = userService.getCurrentUser();
if(user == null) {
    return "(unknown)";
}
var username = user.getUsername();
if (username == null) {
    return "(unknown)";
}
return username;
vs

var user = userService.getCurrentUser();
if(user.isEmpty()) {
    return "(unknown)";
}
var username = user.orElseThrow().getUsername();
if (username == null) {
    return "(unknown)";
}
return username;
vs

return userService.getCurrentUser()
                  .map(User::getUsername)
                  .orElse("(unknown)");

Você pode começar com o destino Opcional. O objetivo de Opcional é representar valores ausentes opcionais. Em seguida, volte ao seu problema e veja se funciona para você. Outra maneira de lidar com a verificação de nulos é usar anotações. Nullable ou NotNull devem funcionar bem. É verdade que eles podem poluir seu código e protegem apenas em tempo de compilação. Para verificar o tempo de execução, use Objects.requireNonNull .

2. Faça o tratamento adequado de erros

Às vezes, null representa exceções. E esta é a maneira errada de sinalizar erros e exceções. “Algo deu errado e aqui é nulo” é um antipadrão que deve ser evitado. Além disso, você não deve usar Opcional para cobrir exceções. Aqui está um exemplo.

public Optional<MyObject> getMyObject(final String jql) {
    try {
        return Optional.ofNullable(get(sql));
    } catch (final JqlParseException e) {
        return Optional.empty();
    }
}

Por que myObject está vazio? Isto é um erro ou um valor vazio. Portanto, você obteria novamente um resultado ambíguo e, como resultado, apagaria os benefícios do Opcional. Este código existe porque as pessoas estão tentando usar Opcional para controlar o fluxo. Opcional removerá alguns zeros da sua base de código. Mas você ainda precisa usar a construção try-catch para lidar com exceções. Use try-catch para tratar exceções corretamente. Não remova o Opcional ao lidar com erros, apenas espere e ele funcionará perfeitamente. Mas há uma exceção aqui: captura vazia . Quando você não sabe o que retornar em uma captura vazia, um Opcional vazio deve funcionar bem.

private int readExpirationAsInt(Milk milk)
{
  String expiration = milk.getExpiration();
  try {
    return Integer.parseInt(expiration);
  }
  catch(NumberFormatException ignored) {}

  return 0;
}


private OptionalInt readExpirationAsInt(Milk milk)
{
  String expiration = milk.getExpiration();

  try {
    return Optional.of(Integer.parseInt(expiration));
  }
  catch(NumberFormatException e) {
    return OptionalInt.empty();
  }
}

3. Não retorne nulo de métodos opcionais

public static Optional<POSType> getPOSType(String posName) {
    if (StringUtils.isNotBlank(posName)) {
        return Arrays.stream(POSType.values())
                .filter(type -> type.toString().equalsIgnoreCase(posName))
                .findFirst();
    }
    return null;
}

Isso anula o propósito de Opcional. Este é outro exemplo de testes ruins. Como a entrada está vazia, isso significa que precisamos de um arquivo IllegalArgumentException . Além disso, isso é um erro. Ninguém precisa verificar os métodos de chamada opcionais. Retorne um elemento Opcional vazio e nunca verifique se há nulo em um elemento Opcional.

4. Não use Opcional com coleções.

Não há necessidade de agrupar coleções em Opcional. Além disso, não coloque Opcionais em coleções. Isso só complica as coisas, adicionando boxe inútil e desembrulhamento extra. Não adicione Opcionais às coleções. Não há nenhum benefício visível nisso. Mantenha a simplicidade e use Opcional para valores ausentes.

5. Não acorrente por encadear

Optional.ofNullable(foo).ifPresent(value -> {
  //do something
})

Opcional possui métodos detalhados que podem ajudar com isso. Em vez de cadeia, uma simples verificação de nulo será suficiente. Eu sei que Opcional tem bons métodos e bom suporte IDE. Você pode usá-los.

6. Use wrappers de valores primitivos

Não é um grande problema, mas você pode usar OpcionalInt ou OpcionalLong . Simplesmente removendo genéricos desnecessários, você melhorará o desempenho e escreverá um código mais conciso.

7. Você deve conhecer ofNullable

if (a==null){
  return Optional.empty();
} else {
  return Optional.of(a);
}

Esse tipo de código geralmente é escrito por desenvolvedores que não conhecem opcional#ofNullable . A maioria dos desenvolvedores nem entende a diferença entre ofNullable e of . Eles não entendem como o opcional#of pode sair pela culatra. A maioria recorreria a ofNullable por medo de lançar um NullPointerException em Optional#of . Novamente, isso vai contra o propósito desses dois métodos. Se usarmos apenas ofNullable , por que precisamos de Optional#of ? Opcional#of lança um NPE quando você passa para nulo. Isso acontece por um motivo. Este método deve ser usado quando você espera que o valor esteja presente. Se não estiver lá, falhará rapidamente. Opcional#ofNullable converte nulo em um opcional vazio. Este método aceita null como argumento, que corresponde a um opcional vazio.