Pause café #89. 10 meilleurs plugins IntelliJ IDEA pour augmenter votre productivité. Gestion des exceptions dans Java Streams à l'aide de l'interface fonctionnelle

10 meilleurs plugins IntelliJ IDEA qui augmenteront votre productivité

Source : Hackernoon J'ai récemment demandé aux développeurs qui utilisent IntelliJ IDEA quels plugins ils préféraient pour cet IDE ? Sur la base des réponses collectées, une liste des 10 extensions les plus populaires a été obtenue.

1. WakaTime

WakaTime vous permet de voir des métriques, des analyses et de suivre le temps passé à la programmation. Avec lui, vous saurez exactement combien de temps vous passez à coder, car le plugin suit automatiquement lorsque vous commencez et arrêtez de taper, avec des métriques détaillées pour les projets, les fichiers, les branches, les validations/PR, les fonctionnalités, etc.

2.Taille du pas

Ce plugin aide à résoudre les problèmes liés à la dette technique, à la maintenance et à la refactorisation du code. Stepsize vous permet de :

• créer des signets dans le code ;
• suivre la dette technique directement depuis l'éditeur ;
• créer TODO ;
• prioriser les problèmes techniques lors de la planification du sprint ;
• Collaborer avec vos coéquipiers pendant la maintenance et la refactorisation du code.

3. Promoteur clé X

Key Promoter X vous aide à découvrir la signification des raccourcis et des boutons dans IntelliJ IDEA. Lorsque vous passez votre souris sur un bouton de l'EDI, Key Promoter X vous montre un raccourci clavier que vous pouvez utiliser au lieu de cliquer avec la souris.

4. ZIO pour IntelliJ

ZIO vous fournira des suggestions, des refactorisations et d'autres améliorations pour l'écosystème Scala ZIO. Le plugin étend la bibliothèque ZIO avec des fonctions telles que :

• refactorisations et suggestions ;
• prise en charge des macros zio (par exemple, @accessible) ;
• test intégré.

5.Protobuf

Le plugin Protobuf Language pour les IDE basés sur IntelliJ prend en charge le langage Protobuf. Protobuf aide à la coloration syntaxique, à l'importation de fichiers depuis la bibliothèque et le SDK, à la navigation, au pliage de code, à l'analyse sémantique et à une documentation rapide.

6.SonarLint

SonarLint vous permet de résoudre les problèmes de code avant qu'ils ne surviennent. En tant que correcteur orthographique, SonarLint met en évidence les erreurs et les failles de sécurité au fur et à mesure que vous écrivez du code, avec des instructions claires sur la façon de les corriger, afin que vous puissiez les corriger avant que le code ne soit validé. SonarLint dans VS Code prend en charge l'analyse de code en Java, JavaScript, TypeScript, Python, HTML et PHP.

7. ESLint

ESLint prend en charge l'affichage des avertissements eslint sous forme d'inspections IntelliJ, permet d'effectuer des correctifs rapides pour plusieurs règles, prend en charge les règles eslint personnalisées, ainsi que l'annotation et l'achèvement de la configuration eslint.

8. Plus jolie

L' extension Prettier aide votre code à être plus beau et plus cohérent. Il garantit un style cohérent en analysant votre code et en le réécrivant selon ses règles et sa longueur de ligne maximale.

9.Quokka

Quokka.js est un outil de productivité des développeurs pour le prototypage rapide JavaScript/TypeScript. Dans l'EDI, il met à jour la métrique du temps d'exécution à côté du code au fur et à mesure que vous tapez. Cela accélère considérablement le prototypage, la formation et les tests de JavaScript/TypeScript.

10. AceJump

AceJump vous permet de déplacer rapidement le curseur vers n'importe quelle position visible dans l'éditeur. Appuyez simplement sur « CRTL+ ; », saisissez un caractère, puis saisissez le caractère correspondant pour Ace Jump. Si aucune correspondance n'est trouvée à l'écran, AceJump passera à la correspondance suivante qu'il pourra trouver.

Gestion des exceptions dans Java Streams à l'aide de l'interface fonctionnelle

Source : Dev.to J'ai récemment parcouru du code et je suis tombé sur quelque chose comme ceci :

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

Comme je suis un grand fan des expressions lambda et de la brièveté, le code ci-dessus me semble un peu concis et un peu déroutant. Pour l'effacer, vous devez utiliser des interfaces fonctionnelles. De quoi avons-nous besoin pour cela ? Nous savons que forEach attend la contribution du consommateur. Si nous pouvions envelopper notre logique de gestion des exceptions dans un consommateur, nous pourrions alors utiliser la logique de forEach. La logique principale à l’intérieur de forEach est la ligne suivante :

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

Nous connaissons le type d'entrée et de retour, et nous pouvons créer une interface fonctionnelle dont la méthode lève une exception.

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

Nous pouvons rendre le code encore plus pratique en utilisant des génériques.

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

Une fois l'interface créée, la logique originale peut devenir typée :

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

Maintenant que nous disposons d'une interface fonctionnelle pour notre logique, nous pouvons la transmettre en tant que paramètre à une méthode qui gère l'exception et renvoie un Consumer que nous pouvons utiliser dans 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);
    }
  };
}

Cela semble un peu étrange, mais essentiellement, la méthode wrap prend une ThrowingFunction en entrée et gère l'exécution de la fonction ou attrape et lève des exceptions dans le consommateur. Nous pouvons maintenant envelopper toute logique utilisée dans forEach qui pourrait lever une exception. Cela ressemble à ceci :

// 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 si vous préférez une ligne :

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

D'accord, c'est bien mieux ! Vous pouvez implémenter quelque chose comme ceci pour gérer différents types d'interfaces fonctionnelles. Par exemple, l' opération Map prend uniquement une Function comme entrée . Au lieu d’une méthode wrapper renvoyant un consommateur, vous pourriez avoir une méthode renvoyant une fonction. Ce n'est qu'une façon de gérer les exceptions dans les threads. Je dois mentionner qu'il existe des bibliothèques qui font cela pour vous. Vous pouvez également utiliser une monade pour gérer les succès ou les échecs, mais cela dépasse le cadre de cet article.