Kaffeepause Nr. 88. Die Macht der Metadaten: Wie man mit Spaghetti-Code arbeitet. Garbage Collection in Java – wie es funktioniert und welche Vorteile es hat

Die Macht der Metadaten: Wie man mit Spaghetti-Code arbeitet

Quelle: Hackernoon Wir alle versuchen, gemeinsame Ansätze und bekannte Muster zu nutzen, um mit minimalem Aufwand und maximaler Wirkung eine Anwendung zu erstellen. Wir verfügen über hervorragende Bibliotheken und leistungsstarke Frameworks, die Routineoperationen für uns erledigen. Wir nutzen dies alles, um uns nur auf die Geschäftslogik zu konzentrieren. Dieses Streben führt uns jedoch oft zu Spaghetti-Code, insbesondere wenn es darum geht, eine Funktion zu implementieren, für die es keine fertige Lösung gibt. In diesem Artikel möchte ich Ihnen ein leistungsstarkes Tool vorstellen, das meiner Erfahrung nach nicht alle Entwickler zu schätzen wissen. Dieses Tool ist in den meisten Programmiersprachen vorhanden und wird sehr häufig in vielen Frameworks verwendet – Annotationen.

Magst du Spaghetti?

Schauen wir uns ein Beispiel an, das mir vor ein paar Jahren begegnet ist. Ich musste eine Excel-Tabelle analysieren, um die analysierten Daten in eine Datenbank zu übertragen. Ich wollte auch einige Daten aus der Datenbank sammeln und eine Tabelle erstellen. Zur Implementierung habe ich die bekannte Java-Bibliothek Apache POI verwendet. Die API der Bibliothek erleichtert Ihnen die Arbeit, da Sie damit manuell ein Blatt, eine Zeile, eine Zelle und andere Elemente erstellen können. Das ist sehr gut, aber wenn es notwendig ist, verschiedene Excel-Tabellen zu erstellen, wird der Code völlig unlesbar und nicht unterstützbar. Infolgedessen erweist sich die erste Version der Anwendung, wie so oft, als einfach schrecklich. Die Implementierung bestand aus einer Datenklasse, die einen String mit allen zum Parsen benötigten Feldern darstellte. Es gab auch einen Parser, mit dem Excel-Felder Zelle für Zelle analysiert und in einer neu erstellten Datenklasseninstanz platziert wurden. Anfangs funktionierte das Programm hervorragend und erfüllte die Anforderungen. Die Probleme begannen, als es an der Zeit war, einige Änderungen vorzunehmen; Der Code wurde nicht gelesen. Selbst ich, der diesen Code geschrieben hat, konnte keinen geeigneten Ort finden, um neue Zeilen zu platzieren, um die neue Funktion zu implementieren, die ich brauchte.

Rettung in Anmerkungen

Die Anwendung wurde aus diesem Annotations-Spaghetti-Code gespeichert. Um nicht unterstützten Code zu entfernen, musste ich die Logik zur Bestimmung der zu analysierenden Spalte, des Datentyps einer Zelle und aller anderen Elemente an einen anderen Ort verschieben. Dazu habe ich eine Annotation erstellt, in der ich für jedes Klassenfeld den Spaltennamen angegeben habe. In der Anmerkung habe ich außerdem eine Variable hinzugefügt, mit der Sie die Farbe und Schriftart der Zelle auswählen können. Dadurch wurde der Code in der Parsing-Klasse deutlich reduziert. Nur ein Prozessor hat die Tabelle basierend auf den Parametern aus den Anmerkungen dynamisch erstellt. Es war ein Sieg. Um dann Änderungen an der Anwendung vorzunehmen, musste ich nur noch eine Klasse mit Anmerkungen erstellen. Die Lösung erinnerte an die Jackson-Bibliothek, die JSON mithilfe von Annotationen analysiert, und ich denke, es besteht kein Grund zu erwähnen, wie praktisch Jackson oder ähnliche Bibliotheken sind.

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

Als sich die Anwendung weiterentwickelte, erhielt sie eine neue Anmerkung, die zum Erstellen einer Zelle in einer Tabellenkalkulation mit einer darin enthaltenen Funktion verwendet werden konnte. Es können verschiedene Felder multipliziert, subtrahiert und alle gängigen Excel-Funktionen genutzt werden. Ich habe auch eine Gesamtzeile hinzugefügt, um die Summe nach Spalte anzuzeigen. Und das alles habe ich erreicht, indem ich den Hauptparser leicht modifiziert und den Klassen einfach Anmerkungen hinzugefügt habe.

@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 in Java – wie es funktioniert und welche Vorteile es hat

Quelle: Dev.to Garbage Collection bedeutet, nicht verwendete Objekte im Speicher zu zerstören oder zu bereinigen. Java führt die Speicherfreigabe automatisch durch, da nach der Erstellung eines Objekts etwas Speicher auf dem Heap belegt wird.

Wie es funktioniert?

Vor Java war C oder C++ die beliebteste Programmiersprache. Wenn Sie diese Sprachen sprechen, sollten Sie wissen, dass sie ihr eigenes Gedächtnis manuell verwalten. C verfügt beispielsweise über Methoden wie calloc() , malloc() und realloc() , mit denen Sie Pufferspeicher verwenden können. Sie müssen ermitteln, wie viel Speicher Sie für Ihr Programm benötigen, und angeben, was von dieser API aufgerufen wird. Sie können dann einen Speicherpuffer abrufen, um einen verknüpften Listenknoten oder etwas anderes zu erstellen. Wenn Ihr Programm irgendwann beendet wird, sind Sie auch dafür verantwortlich, diesen Speicher zu bereinigen. Eine große, in C geschriebene Anwendung weist also ständig Pufferspeicher zu und vergisst manchmal, ihn zu leeren. Dies führt letztendlich zu Speicherverlusten und vielen Problemen in der Anwendung. Im Gegensatz zu C und C++ verfügt die Java-Sprache über eine automatische Speicherverwaltung durch einen Thread namens Garbage Collector. Sein Hauptzweck besteht darin, Heap-Speicher freizugeben, indem unzugängliche Objekte zerstört werden. Der Garbage Collector läuft immer im Hintergrund.

Was sind unzugängliche Objekte in Java?

Wann erhält ein Objekt die Chance, mit der Garbage Collection zu beginnen? Wenn es unzugängliche Objekte gibt – solche, für die keine aktiven Links vorhanden sind. Sehen wir uns ein Beispiel an:

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

In der Hauptmethode habe ich ein StringBuffer- Objekt und einen Verweis darauf erstellt. Zu diesem Zeitpunkt ist das StringBuffer- Objekt nicht für die Garbage Collection geeignet. Jetzt setze ich das StringBuffer- Objekt auf „null“. Das Objekt ist nun für die Garbage Collection geeignet und wird zu einem unzugänglichen Objekt im Heap-Speicher. Das heißt, die Garbage Collection funktioniert im Allgemeinen in Fällen, in denen auf Objekte nicht mehr zugegriffen werden kann. Das bedeutet, dass Objekte normalerweise im Kontext eines „if-Blocks“ oder einer Methode erstellt werden. Daher verlassen Objekte den Gültigkeitsbereich, sobald die Methodenausführung abgeschlossen ist, und können vom Garbage Collector entsorgt werden. Da Verweise von alten Objekten auf neue nur in begrenzter Anzahl vorhanden sind, bedeutet dies, dass es sich bei Objekten, die schon lange in Ihrer Anwendung vorhanden sind, in der Regel nicht um neu erstellte Objekte handelt. Hier sind ein paar Begriffe, mit denen wir vertraut sein sollten; Einer von ihnen ist ein lebendes Objekt. Es handelt sich um ein Objekt in einer Anwendung, auf das von einem anderen Objekt in derselben Anwendung verwiesen wird. Es gibt auch ein „totes“ Objekt. Ein totes Objekt ist ein unzugängliches Objekt, das während eines Methodenaufrufs erstellt wird. Sobald der Methodenaufruf abgeschlossen ist, verlässt das Objekt den Kontext und verbleibt einfach auf dem Heap.

Wann ist ein Objekt für die Garbage Collection geeignet?

Wenn ein Objekt keine Referenzvariable hat, ist das Objekt für die Garbage Collection geeignet.

Wie mache ich ein Objekt für die Garbage Collection verfügbar?

Nachfolgend finden Sie mehrere Möglichkeiten:

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

   Sobald ein Objekt dem Garbage Collector zur Verfügung gestellt wird, wird es nicht sofort zerstört.

Wenn die Java Virtual Machine den Garbage Collector ausführt, wird nur das Objekt zerstört. HINWEIS: Der Garbage Collector sammelt nur Objekte, die mit dem Schlüsselwort „new“ erstellt wurden. Für Objekte ohne das Schlüsselwort „new“ verwenden Sie die Methode finalize() . Es gibt mehrere Methoden, den Garbage Collector in der Java Virtual Machine auszuführen:

1. System.gc()- Methode

2. finalize()- Methode

3. Runtime.getRuntime().gc() -Methode

Die statische gc()- Methode befindet sich in der Systemklasse . Diese Methode fordert die JVM auf, den Garbage Collector aufzurufen. Sehen wir uns an, wie eine Java-Anwendung den Garbage Collector mithilfe der gc()- Methode aufruft.

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

Ergebnis: Die finalize()- Methode wird unmittelbar vor der Bereinigung des Objekts aufgerufen. Diese Methode ist in der Object- Klasse definiert :

protected void finalize() throws Throwable

1. Mit der Finalize- Methode wird die Verbindung zur Datenbank geschlossen.

2. Diese Methode wird vom Garbage Collector aufgerufen, nicht von der JVM.

3. Wir müssen die finalize()- Methode überschreiben . Weil es eine leere Implementierung hat.

4. Es wird nur einmal pro Objekt aufgerufen.

Die Methode getRuntime().gc() ist in der Laufzeitklasse vorhanden. Es gibt das Runtime -Objekt zurück , das der aktuellen Java-Anwendung zugeordnet ist. Schauen wir uns diese Methode in einem Java-Programm an.

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

Ergebnis:

Vorteile der Müllabfuhr:

1. Die Speicherbereinigung erfolgt in Java automatisch, was uns die zusätzliche Belastung erspart, belegten Speicher freizugeben. Dadurch wird der Speicher des Java-Programms effizienter.
2. Die Garbage Collection stellt die Programmintegrität sicher.
3. Wir müssen keinen zusätzlichen Code schreiben, da der Garbage Collector Teil der JVM ist.