Pause café #109. Les compétences les plus demandées en développement Java à l’heure actuelle. 7 conseils facultatifs Java pour se débarrasser de l'encombrement du code

Les compétences les plus demandées en développement Java à l'heure actuelle

Source : Medium Java reste l'un des langages de programmation les plus populaires et les plus demandés, malgré le fait qu'il ait près d'un quart de siècle. Par conséquent, il est raisonnable de supposer que la popularité de Java continuera de croître et que les développeurs Java verront une demande encore plus grande de la part des employeurs à l'avenir. Pour créer des produits de qualité, les développeurs doivent se tenir au courant des derniers outils Java et améliorer leurs compétences et connaissances techniques. Nous présentons ci-dessous six compétences essentielles requises pour les développeurs Java.

1. Excellente connaissance de Java 8

Même si les versions les plus récentes de Java sont déjà largement utilisées, tous les futurs développeurs Java ont besoin de connaissances et d'une expérience approfondies avec Java 8. Certaines des fonctionnalités les plus utiles de Java 8 incluent :

• Méthodes standard et statiques pour créer des interfaces avec des implémentations de méthodes.
• Une interface fonctionnelle qui n'a qu'une seule méthode abstraite et aide les développeurs à éviter d'ajouter d'autres méthodes abstraites.
• Expressions Lambda qui aident à créer des interfaces fonctionnelles.
• API Java Stream pour permettre une exécution parallèle et séquentielle.
• Nouvelles méthodes dans l'API Collection.

Toutes ces fonctionnalités rendent Java 8 indispensable à la programmation fonctionnelle. La programmation fonctionnelle assure la simultanéité et la brièveté du code, et permet de créer des applications à forte charge avec un code optimisé. Java 8 est également devenu la base de l'optimisation du code natif, permettant d'optimiser le développement dans d'autres langages tels que Scala, Kotlin et Grails.

2. Expérience des tests

Les tests unitaires en Java sont un sujet plutôt controversé. Certains développeurs affirment qu'écrire des tests unitaires est une perte de temps, mais nous croyons fermement que les compétences en tests unitaires sont indispensables pour tout développeur Java professionnel. Les tests unitaires vous permettent de tester des blocs de code individuels et garantissent que le produit final fonctionne sans erreur. Par conséquent, si un développeur souhaite améliorer ses compétences et ses connaissances, il doit apprendre à utiliser les outils de test les plus populaires et les plus efficaces. Le principal framework de test avec lequel vous devez vous familiariser est la bibliothèque JUnit 5. Les autres outils incluent :

• Cadre de robot
• Mockito
• PowerMock

Outre les tests unitaires, un développeur Java ne doit pas oublier les autres méthodes de test (tests système, tests d'acceptation et tests d'intégration). Cela vous permet d'effectuer des tests complets du logiciel et de vous assurer qu'il n'y a pas d'erreurs, de bugs ou de pannes critiques. La principale chose à retenir à propos des tests est que de petits changements conduisent à de grands résultats. Si vous n'hésitez pas à consacrer du temps et des efforts aux tests unitaires, vous serez étonné de l'amélioration de la qualité de votre travail.

3. DevOps

Bien que cela ne soit pas obligatoire, l'apprentissage du DevOps et de ses principes peut être bénéfique pour vous en tant que développeur et pour l'entreprise pour laquelle vous travaillez. La flexibilité et l'organisation des processus DevOps permettent aux entreprises d'optimiser la qualité de leur produit et de rationaliser leurs opérations. et également accroître la transparence des processus. DevOps en Java est essentiellement l'application de DevOps au développement Java. Ceci comprend:

• Livraison et intégration continues.
• Travailler avec des microservices au lieu de monolithes.
• Infrastructure en tant que code.
• Tests automatisés.

Le DevOps est un vaste domaine et nécessite beaucoup de temps et de ressources pour l'étudier. Mais si vous êtes un développeur Java, l'apprentissage du DevOps sera bénéfique car il vous permettra de devenir un ingénieur DevOps à l'avenir. Si vous ne souhaitez pas devenir ingénieur DevOps ou si cela n'intéresse pas votre entreprise, ce n'est pas grave non plus. Gardez simplement à l’esprit que DevOps devient de plus en plus populaire dans la communauté Java.

4. Connaissance des bibliothèques et API Java.

Étant donné que Java est l'un des principaux langages de programmation au monde, il n'est pas surprenant qu'il dispose d'un grand nombre d'API et de bibliothèques disponibles avec lesquelles travailler. Ces outils simplifient grandement le processus de développement et permettent aux développeurs de créer rapidement des logiciels fiables. Ci-dessous, nous avons répertorié un ensemble d'outils de base que tout bon développeur Java connaît et peut utiliser en toute confiance. Ces outils vous aident à créer rapidement une application et à gérer efficacement les données et leur stockage :

• Gradle (un outil pour créer des applications) ;
• Maven (un peu dépassé mais toujours populaire, également utilisé pour créer des applications) ;
• Packages standards Java 8 ;
• Cadres de printemps ;
• JPA ORM (Hibernate, TopLink) ;
• Bases de données NoSQL (MongoDB, Cassandra).

Quant à l'API, pour travailler avec l'API Java de base, un développeur doit avoir une bonne connaissance d'OpenJDK, Android, Oracle et IS2T. Le gros avantage de ces outils est qu’ils sont tous accompagnés d’une documentation détaillée et informative. De plus, les développeurs peuvent toujours bénéficier du soutien de la communauté, ce qui constitue également un gros avantage.

5. Connaissance approfondie de Spring et Spring Boot

Le framework Spring est le framework le plus couramment utilisé pour développer des applications basées sur Java, il est donc important qu'un développeur sache comment l'utiliser. L'un des principaux avantages de Spring est l'injection de dépendances, qui vous permet de créer des applications faiblement couplées et offre plus de flexibilité aux développeurs. Spring est également très léger, prenant en charge les configurations XML, les annotations et la programmation déclarative. Donc, si vous souhaitez maîtriser les compétences en développement Java, vous devez également maîtriser le déploiement Spring. Spring Boot est une itération de Spring qui fournit un outil pratique pour déployer rapidement des applications. On peut dire sans se tromper que Spring Boot utilise Spring comme base et construit ses propres fonctionnalités par-dessus. Alors que Spring se concentre sur la flexibilité, Spring Boot permet de réduire le code et de simplifier le processus de développement. Il offre aux développeurs des fonctionnalités prêtes à l'emploi, permet de créer des applications autonomes et est globalement plus facile à lancer et à gérer. Spring Boot est idéal pour les microservices et les applications qui doivent être créés rapidement, car il permet de configurer et d'exécuter rapidement et facilement des applications pour une variété d'environnements (production, test, qualité, CI/CD). Spring et Spring Boot se sont tous deux développés avec les capacités de programmation de React, qui constituent une autre tendance en vogue dans la communauté des développeurs. Spring 5, par exemple, dispose désormais de WebFlux pour mettre en œuvre une approche réactive de la programmation et de la résolution de systèmes distribués complexes.

6. Expérience avec le Big Data

Le Big Data est une tendance croissante que les développeurs doivent suivre et adopter pour répondre aux demandes du marché. Les principaux outils avec lesquels les développeurs Java professionnels peuvent se familiariser sont :

• Apache Spark
• Apache Kafka
• Hadoop (pour le traitement par lots)

Apache Spark est une plateforme de traitement Big Data distribuée qui fournit des liaisons natives pour Java. Ce framework est devenu extrêmement populaire en raison de ses fonctionnalités et de ses performances et est actuellement l'outil Big Data le plus apprécié de la communauté Java. Apache Spark peut fonctionner en mode cluster autonome et pour cela vous n'avez besoin que d'un environnement Apache Spark et d'une JVM (pour chaque machine du cluster). Spark est également incroyablement rapide et dispose d'une API Spark très conviviale. Hadoop est une plateforme de stockage de données également bien connue des développeurs Java. Bien que Hadoop ne soit pas aussi rapide que Spark, il reste l'un des outils les plus populaires pour travailler avec le Big Data. Cela est également dû au fait que Hadoop (et des solutions similaires) disposent d'un grand nombre de plugins qui vous permettent de résoudre efficacement les problèmes de traitement du Big Data et d'optimiser généralement les performances de Hadoop (y compris la prise en charge du traitement des flux en temps réel).

7 conseils facultatifs Java pour se débarrasser de l'encombrement du code

Source : Medium « J'ai des collègues qui ne connaissent pas l'existence d'Optional », écrit un développeur Java sur Reddit. Peut-on considérer que Optionnel améliore la « lisibilité » du code ? Est-ce que ça vaut le coup de l’utiliser tout le temps ? Où l’utilisation de Facultatif est-elle totalement inutile ? Étant donné que de nombreux développeurs ne savent toujours pas comment utiliser facultativement correctement, je vais donner 7 exemples d'abus de facultative et comment y remédier.

1. N'utilisez pas Facultatif pour la vérification nulle

L'utilisation de Facultatif au lieu de la vérification nulle ne fait qu'ajouter du désordre. Il n’y a aucun avantage à cela. C'est également une erreur d'utiliser les méthodes Facultative et isPresent et get . Les développeurs pensent que get devrait fonctionner comme prévu. Ils ajoutent ensuite isPresent et reviennent à la vérification nulle. N'oubliez pas que Facultatif ne corrige pas vos vérifications nulles. La prochaine fois que vous verrez isPresent et get (ou ElseThrow ), modifiez ce morceau de code. Utilisez le mappage et orElse pour supprimer les vérifications nulles standard et utilisez Facultatif de manière plus sélective. Voici un bon exemple :

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)");

Vous pouvez commencer avec la cible facultative. Le but de Facultatif est de représenter les valeurs facultatives et manquantes. Revenez ensuite à votre problème et voyez si cela fonctionne pour vous. Une autre façon de gérer la vérification nulle consiste à utiliser des annotations. Nullable ou NotNull devrait fonctionner correctement. Certes, ils peuvent polluer votre code et ils ne le protègent qu'au moment de la compilation. Pour vérifier le temps d'exécution, utilisez Objects.requireNonNull .

2. Effectuez une gestion appropriée des erreurs

Parfois, null représente des exceptions. Et ce n’est pas une bonne façon de signaler les erreurs et les exceptions. « Quelque chose s’est mal passé, et ici c’est nul » est un anti-modèle qu’il faut éviter. De plus, vous ne devez pas utiliser Facultatif pour couvrir les exceptions. Voici un exemple.

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

Pourquoi monObjet est- il vide ? Il s'agit soit d'une erreur, soit d'une valeur vide. Vous obtiendrez donc à nouveau un résultat ambigu et effacerez ainsi les avantages de Facultatif. Ce code existe parce que les gens essaient d'utiliser Facultatif pour le flux de contrôle. Facultatif supprimera certains zéros de votre base de code. Mais vous devez toujours utiliser la construction try-catch pour gérer les exceptions. Utilisez try-catch pour gérer correctement les exceptions. Ne supprimez pas Facultatif lors de la gestion des erreurs, attendez simplement et cela fonctionnera parfaitement. Mais il y a une exception ici : un catch vide . Lorsque vous ne savez pas quoi retourner dans un catch vide, un facultatif vide devrait fonctionner correctement.

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. Ne retournez pas null à partir des méthodes facultatives

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;
}

Cela va à l’encontre du but de Facultatif. Ceci est un autre exemple de mauvais tests. Puisque l'entrée est vide, cela signifie que nous avons besoin d'un fichier IllegalArgumentException . C’est aussi une erreur. Personne n'a besoin de vérifier les méthodes d'appel facultatives. Renvoie un élément facultatif vide et ne vérifie jamais la valeur null d’un élément facultatif.

4. N'utilisez pas Facultatif avec les collections.

Il n'est pas nécessaire d'emballer les collections en option. De plus, ne mettez pas d'options dans les collections. Cela ne fait que compliquer les choses en ajoutant une boxe inutile et un déballage supplémentaire. N'ajoutez pas d'options aux collections. Il n’y a aucun avantage visible à cela. Restez simple et utilisez Facultatif pour les valeurs manquantes.

5. N’enchaînez pas pour enchaîner

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

Facultatif propose des méthodes détaillées qui peuvent vous aider. Au lieu d'une chaîne, une simple vérification nulle suffira. Je sais qu'Optional a de bonnes méthodes et un bon support IDE. Vous pouvez les utiliser.

6. Utilisez des wrappers de valeurs primitives

Ce n'est pas un gros problème, mais vous pouvez utiliser OptionInt ou OptionLong . En supprimant simplement les génériques inutiles, vous améliorerez les performances et écrirez un code plus concis.

7. Vous devriez connaître ofNullable

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

Ce type de code est généralement écrit par des développeurs qui ne connaissent pasOptional#ofNullable . La plupart des développeurs ne comprennent même pas la différence entre ofNullable et of . Ils ne comprennent pas comment Facultatif#of peut se retourner contre eux. La plupart auraient recours à ofNullable de peur de lancer une NullPointerException dansOptional #of . Encore une fois, cela va à l’encontre de l’objectif de ces deux méthodes. Si nous utilisons uniquement ofNullable , pourquoi avons-nous besoin deOptional#of ? Facultatif#of lève un NPE lorsque vous passez à null. Cela arrive pour une raison. Cette méthode doit être utilisée lorsque vous vous attendez à ce que la valeur soit présente. Si ce n’est pas le cas, cela échouera rapidement. Facultatif#ofNullable convertit null en un facultatif vide. Cette méthode prend null comme argument, qui correspond à un facultatif vide.