Pause café #88. Le pouvoir des métadonnées : comment travailler avec du code spaghetti. Garbage collection en Java - comment ça marche et quels sont ses avantages

Le pouvoir des métadonnées : comment travailler avec du code spaghetti

Source : Hackernoon Nous essayons tous d'utiliser des approches communes et des modèles connus pour créer une application avec un minimum d'effort et un impact maximum. Nous disposons d'excellentes bibliothèques et de frameworks puissants qui effectuent des opérations de routine pour nous. Nous utilisons tout cela pour nous concentrer uniquement sur la logique métier. Cependant, cette recherche nous conduit souvent au code spaghetti, en particulier lorsqu'il s'agit d'implémenter une fonction sans solution toute faite. Dans cet article, je souhaite partager avec vous un outil puissant que, d'après mon expérience, tous les développeurs n'apprécient pas. Cet outil est présent dans la plupart des langages de programmation, et il est très souvent utilisé dans de nombreux frameworks – les annotations.

Aimez-vous les spaghettis?

Regardons un exemple que j'ai rencontré il y a quelques années. J'avais besoin d'analyser une feuille de calcul Excel pour mettre les données analysées dans une base de données. Je voulais également collecter certaines données de la base de données et créer une feuille de calcul. Pour l'implémentation, j'ai utilisé la célèbre bibliothèque Java - Apache POI. L'API de la bibliothèque facilite votre travail car elle vous permet de créer manuellement une feuille, une ligne, une cellule et d'autres éléments. C'est très bien, mais lorsqu'il faut générer diverses feuilles de calcul Excel, le code devient complètement illisible et insupportable. En conséquence, comme cela arrive habituellement, la première version de l'application s'avère tout simplement terrible. L'implémentation consistait en une classe de données qui représentait une chaîne avec tous les champs nécessaires à l'analyse. Il existait également un analyseur dans lequel les champs Excel étaient analysés cellule par cellule et placés dans une instance de classe de données nouvellement créée. Au début, le programme fonctionnait très bien et faisait ce qu'on attendait de lui. Les problèmes ont commencé quand est venu le temps d’apporter quelques modifications ; le code n'a pas été lu. Même moi, qui ai écrit ce code, je n'ai pas pu trouver un endroit approprié pour placer de nouvelles lignes afin d'implémenter la nouvelle fonction dont j'avais besoin.

Sauvetage dans les annotations

J'ai enregistré l'application à partir de ce code spaghetti d'annotation. Pour me débarrasser du code non pris en charge, je devais déplacer la logique permettant de déterminer quelle colonne analyser, quel type de données contenait une cellule et tout le reste vers un emplacement différent. Pour ce faire, j'ai créé une annotation dans laquelle j'ai spécifié le nom de colonne pour chaque champ de classe. Dans l'annotation, j'ai également ajouté une variable qui permet de sélectionner la couleur et la police de la cellule. Ainsi, le code de la classe d'analyse a été considérablement réduit. Un seul processeur a créé dynamiquement la feuille de calcul en fonction des paramètres extraits des annotations. C'était une victoire. Ensuite, pour apporter des modifications à l'application, il me suffisait de créer une classe avec des annotations. La solution rappelait la bibliothèque Jackson, qui analyse JSON à l'aide d'annotations, et je pense qu'il n'est pas nécessaire de dire à quel point Jackson ou des bibliothèques similaires sont pratiques.

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ColumnExcel {

    String name() default "";

    int position();

    ExcelColumnDataFormat cellTypePattern() default ExcelColumnDataFormat.NONE;

    IndexedColors cellColor() default IndexedColors.AUTOMATIC;

    ExcelTotalFormula total() default ExcelTotalFormula.NONE;

}

ColumnExcel columnExcel = field.getAnnotation(ColumnExcel.class);

Au fur et à mesure que l'application évoluait, elle a reçu une nouvelle annotation qui pouvait être utilisée pour créer une cellule dans une feuille de calcul avec une fonction à l'intérieur. Divers champs peuvent être multipliés, soustraits et toutes les fonctions Excel courantes peuvent être utilisées. J'ai également ajouté une ligne totale pour afficher la somme par colonne. Et j'ai fait tout cela simplement en modifiant légèrement l'analyseur principal et en ajoutant simplement des annotations aux classes.

@ColumnExcel(
            name = "Views",
            position = 4,
            total = ExcelTotalFormula.SUM)
    private BigDecimal variableC;

    @ColumnExcelFormula(
            name = "Conversion",
            position = 5,
            cellTypePattern = CellDataTypeFormatPattern.PERCENTAGE
    )
    public String variableD(int rowNumber) {
        return new CellAddress(rowNumber, 4).formatAsString() + "*"
		+ new CellAddress(rowNumber, 2).formatAsString();
    }

    @ColumnExcelTotalFormula(position = 4, cellTypePattern = CellDataTypeFormatPattern.RUR)
    public static String getVariableCTotalFormula(int firstRowNum, int lastRowNum) {
        return "SUM( " + new CellAddress(firstRowNum, 4).formatAsString() + ":"
		+ new CellAddress(lastRowNum, 4).formatAsString() + ")";
    }

Garbage collection en Java - comment ça marche et quels sont ses avantages

Source : Dev.to Le garbage collection consiste à détruire ou à nettoyer les objets inutilisés en mémoire. Java gère automatiquement la désallocation de mémoire car une fois qu'un objet est créé, il utilise de la mémoire sur le tas.

Comment ça fonctionne?

Avant Java, le langage de programmation le plus populaire était le C ou le C++. Si vous parlez ces langues, sachez qu’elles gèrent leur propre mémoire manuellement. Par exemple, C possède des méthodes telles que calloc() , malloc() et realloc() qui vous permettront d'utiliser la mémoire tampon. Vous devez déterminer la quantité de mémoire dont vous avez besoin pour votre programme et spécifier ce qui est appelé par cette API. Vous pouvez ensuite obtenir une mémoire tampon pour créer un nœud de liste chaînée ou autre chose. Lorsque votre programme se termine, à un moment donné, vous êtes également responsable du nettoyage de cette mémoire. Ainsi, une grande application écrite en C continue d’allouer de la mémoire tampon et oublie parfois de la vider. Cela provoque finalement des fuites de mémoire et de nombreux problèmes dans l'application. Contrairement au C et au C++, le langage Java est doté d'une gestion automatique de la mémoire via un thread appelé garbage collector. Son objectif principal est de libérer de la mémoire en détruisant les objets inaccessibles. Le garbage collector s’exécute toujours en arrière-plan.

Que sont les objets inaccessibles en Java ?

Quand un objet a-t-il la possibilité de démarrer le garbage collection ? S'il existe des objets inaccessibles - ceux pour lesquels il n'y a pas de liens actifs. Voyons un exemple :

public static void main(String[] args)
{
// StringBuffer object sb is not eligible for garbage collection
StringBuffer sb = new StringBuffer("Flower Brackets");
System.out.println(sb);
// StringBuffer object sb is eligible for garbage collection
sb = null;
}

Dans la méthode principale, j'ai créé un objet StringBuffer et une référence à celui-ci. À ce stade, l’ objet StringBuffer n’est pas éligible pour le garbage collection. Maintenant, je vais définir l' objet StringBuffer sur "null". L'objet est désormais éligible au garbage collection et devient un objet inaccessible dans la mémoire tas. Autrement dit, le garbage collection fonctionne généralement dans les cas où les objets deviennent inaccessibles. Cela signifie que les objets sont généralement créés dans le contexte d’un « bloc if » ou d’une méthode. Ainsi, les objets sortent de la portée une fois l’exécution de la méthode terminée et peuvent être supprimés par le ramasse-miettes. Étant donné que les références d'anciens objets à de nouveaux objets existent en nombre limité, cela signifie que les objets présents dans votre application depuis longtemps ne sont généralement pas des objets nouvellement créés. Voici quelques termes que nous devrions connaître : l'un d'eux est un objet vivant. Il s'agit d'un objet dans une application référencé par un autre objet dans la même application. Il y a aussi un objet « mort ». Un objet mort est un objet inaccessible créé lors d'un appel de méthode, et une fois l'appel de méthode terminé, l'objet sort de son contexte et reste simplement sur le tas.

Quand un objet est-il éligible au garbage collection ?

Si un objet n'a aucune variable de référence, alors l'objet est éligible pour le garbage collection.

Comment rendre un objet disponible pour le garbage collection ?

Vous trouverez ci-dessous plusieurs manières :

1. null reference variable
   Student obj = new Student();
   obj = null;

2. re-assign reference variable
   Student obj1 = new Student();
   Student obj2 = new Student();
   obj1 = obj2;

3. reate anonymous object
   new Student();

   Une fois qu’un objet est mis à disposition du garbage collector, il n’est pas immédiatement détruit.

Lorsque la machine virtuelle Java exécute le garbage collector, seul l'objet est détruit. REMARQUE : Le garbage collector collecte uniquement les objets créés à l'aide du mot-clé « new », pour les objets sans le mot-clé « new », utilisez la méthode finalize() . Il existe plusieurs méthodes pour exécuter le garbage collector dans la machine virtuelle Java :

1. Méthode System.gc()

2. méthode finaliser()

3. Méthode Runtime.getRuntime().gc()

La méthode statique gc() se trouve dans la classe System . Cette méthode demande à la JVM d'appeler le garbage collector. Voyons comment une application Java appelle le garbage collector à l'aide de la méthode gc() .

public class GarbageCollector
{
public static void main(String[] args)
{
Employee obj1 = new Employee();
Employee obj2 = new Employee();
obj1 = null;
obj2 = null;
System.gc();
}
public void finalize()
{
System.out.println("object garbage collected");
}
}

Résultat: La méthode finalize() est appelée juste avant le nettoyage de l'objet. Cette méthode est définie dans la classe Object :

protected void finalize() throws Throwable

1. La méthode Finalize permet de fermer la connexion à la base de données.

2. Cette méthode est appelée par le garbage collector et non par la JVM.

3. Nous devons remplacer la méthode finalize() . Parce qu'il a une implémentation vide.

4. Il n'est appelé qu'une seule fois par objet.

La méthode getRuntime().gc() est présente dans la classe d'exécution. Il renvoie l' objet Runtime associé à l'application Java actuelle. Regardons cette méthode dans un programme Java.

public class Demo
{
public static void main(String[] args)
{
Demo obj1 = new Demo();
Demo obj2 = new Demo();
// nullifying reference variable
obj1 = null;
// nullifying reference variable
obj2 = null;
// running Garbage Collector
Runtime.getRuntime().gc();
}
@Override
protected void finalize() throws Throwable
{
System.out.println("Garbage collector called");
System.out.println("Object garbage collector: " + this);
}
}

Résultat:

Avantages de la collecte des déchets :

1. Le garbage collection en Java s'effectue automatiquement, ce qui nous évite la charge supplémentaire de libérer la mémoire utilisée. Cela rend la mémoire du programme Java plus efficace.
2. La collecte des déchets garantit l’intégrité du programme.
3. Nous n'avons pas besoin d'écrire de code supplémentaire puisque le garbage collector fait partie de la JVM.