Pausa para café #89. Os 10 melhores plug-ins do IntelliJ IDEA para aumentar sua produtividade. Tratamento de exceções em Java Streams usando a interface funcional

Os 10 melhores plug-ins do IntelliJ IDEA que aumentarão sua produtividade

Fonte: Hackernoon Recentemente perguntei aos desenvolvedores que usam o IntelliJ IDEA quais plug-ins eles mais gostam para este IDE. Com base nas respostas coletadas, foi obtida uma lista das 10 extensões mais populares.

1. WakaTime

WakaTime permite que você veja métricas, análises e monitore o tempo gasto na programação. Com ele, você saberá exatamente quanto tempo gasta codificando, pois o plugin rastreia automaticamente quando você inicia e para de digitar, com métricas detalhadas para projetos, arquivo, branch, commit/PR, recurso e muito mais.

2.Tamanho da etapa

Este plugin ajuda a resolver problemas relacionados a dívida técnica, manutenção e refatoração de código. Stepsize permite que você:

• faça marcadores no código;
• rastrear dívida técnica diretamente do editor;
• criar TODO;
• priorizar questões técnicas durante o planejamento do sprint;
• Colabore com colegas de equipe durante a manutenção e refatoração do código.

3. Promotor principal X

O Key Promoter X ajuda você a aprender o significado dos atalhos e botões no IntelliJ IDEA. Quando você passa o mouse sobre um botão dentro do IDE, o Key Promoter X mostra um atalho de teclado que você pode usar em vez de clicar com o mouse.

4. ZIO para IntelliJ

ZIO fornecerá sugestões, refatorações e outras melhorias para o ecossistema Scala ZIO. O plugin estende a biblioteca ZIO com funções como:

• refatorações e sugestões;
• suporte para macros zio (por exemplo, @accessible);
• execução de teste integrada.

5.Protobuf

O plugin Protobuf Language para IDEs baseados em IntelliJ fornece suporte para a linguagem Protobuf. Protobuf ajuda com destaque de sintaxe, importação de arquivos da biblioteca e SDK, navegação, dobramento de código, análise semântica e documentação rápida.

6.SonarLint

SonarLint permite corrigir problemas de código antes que eles aconteçam. Como corretor ortográfico, o SonarLint destaca erros e vulnerabilidades de segurança à medida que você escreve o código, com instruções claras sobre como corrigi-los, para que você possa corrigi-los antes que o código seja confirmado. SonarLint no VS Code oferece suporte à análise de código em Java, JavaScript, TypeScript, Python, HTML e PHP.

7. ESLint

ESLint oferece suporte à exibição de avisos eslint como inspeções do IntelliJ, ajuda a realizar correções rápidas para várias regras, oferece suporte a regras eslint personalizadas e anotação e conclusão de configuração eslint.

8. Mais bonito

A extensão Prettier ajuda seu código a ter uma aparência melhor e mais consistente. Ele garante um estilo consistente analisando seu código e reescrevendo-o de acordo com suas regras e comprimento máximo de linha.

9. Quokka

Quokka.js é uma ferramenta de produtividade de desenvolvedor para prototipagem rápida JavaScript/TypeScript. No IDE, ele atualiza a métrica do tempo de execução ao lado do código conforme você digita. Isso acelera bastante a prototipagem, o treinamento e o teste de JavaScript/TypeScript.

10. Ace Jump

AceJump permite mover rapidamente o cursor para qualquer posição visível no editor. Basta pressionar “CRTL+;”, inserir um caractere e, em seguida, inserir o caractere correspondente para Ace Jump. Se nenhuma correspondência for encontrada na tela, o AceJump passará para a próxima correspondência que encontrar.

Tratamento de exceções em Java Streams usando a interface funcional

Fonte: Dev.to Recentemente, estava examinando alguns códigos e me deparei com algo assim:

subject.getIdentities().forEach(i -> {
  try {
    caseService.updateDocument(i.getCase());
  } catch (Exception e) {
    log.error(e);
  }
});

Como sou um grande fã de expressões lambda e adoro a brevidade, o código acima me parece um pouco conciso e um pouco confuso. Para limpá-lo, você deve usar interfaces funcionais. O que precisamos para isso? Sabemos que forEach espera a entrada do consumidor. Se pudéssemos agrupar nossa lógica de tratamento de exceções em um Consumidor, poderíamos usar a lógica em forEach. A lógica principal dentro de forEach é a seguinte linha:

//try catch removed
// i is an Identity and updateDocument returns a UpdateResponse
i -> caseService.updateDocument(i.getCase());

Conhecemos o tipo de entrada e retorno e podemos criar uma interface funcional cujo método lança uma exceção.

@FunctionalInterface
public interface ThrowingFunction<Identity, UpdateResponse> {
  UpdateResponse apply(Identity i) throws Exception;
}

Podemos tornar o código ainda mais conveniente usando genéricos.

@FunctionalInterface
public interface ThrowingFunction<T, R> {
  R apply(T t) throws Exception;
}

Depois que a interface for criada, a lógica original poderá ser digitada:

ThrowingFunction<Identity, UpdateResponse> tf = i -> caseService.updateDocument(i.getCase());

Agora que temos uma interface funcional para nossa lógica, podemos passá-la como parâmetro para um método que trata a exceção e retorna um Consumidor que podemos usar em forEach.

private static <T, R> Consumer<T> wrap(ThrowingFunction<T, R> f) {
  return t -> {
    try  {
      f.apply(t);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  };
}

Parece um pouco estranho, mas essencialmente o método wrap pega um ThrowingFunction como entrada e lida com a execução da função ou captura e lança exceções no Consumidor. Agora podemos agrupar qualquer lógica usada em forEach que possa gerar uma exceção. Parece algo assim:

// target type the original logic
ThrowingFunction<Identity, UpdateResponse> tf = i -> caseService.updateDocument(i.getCase()):

// pass logic to the wrapmethod
// which will execute the function or throw a RunTimeException.
Consumer<Identity> p = wrap(tf);

// use Consumer in foreach
subject.getIdentities().forEach(p);

Ou se você preferir uma linha:

subject.getIdentities().forEach(wrap(i -> caseService.updateDocument(i.getCase())));

Concordo que isso é muito melhor! Você poderia implementar algo assim para lidar com diferentes tipos de interfaces funcionais. Por exemplo, a operação Map leva apenas uma Function como input . Em vez de um método wrapper retornando um Consumidor, você poderia ter um método retornando uma função. Esta é apenas uma maneira de lidar com exceções em threads. Devo mencionar que existem bibliotecas que fazem isso para você. Você também pode usar uma mônada para lidar com sucessos ou fracassos, mas isso está além do escopo desta postagem.