Kaffeepause Nr. 109. Die derzeit gefragtesten Fähigkeiten in der Java-Entwicklung. 7 optionale Java-Tipps, um Code-Unordnung zu beseitigen

Die derzeit gefragtesten Fähigkeiten in der Java-Entwicklung

Quelle: Medium Java bleibt eine der beliebtesten und gefragtesten Programmiersprachen, obwohl sie fast ein Vierteljahrhundert alt ist. Daher ist davon auszugehen, dass die Beliebtheit von Java weiter zunehmen wird und Java-Entwickler in Zukunft eine noch größere Nachfrage von Arbeitgebern verzeichnen werden. Um qualitativ hochwertige Produkte zu erstellen, müssen Entwickler mit den neuesten Java-Tools Schritt halten und ihre technischen Fähigkeiten und Kenntnisse verbessern. Im Folgenden stellen wir sechs wesentliche Fähigkeiten vor, die für Java-Entwickler erforderlich sind.

1. Ausgezeichnete Kenntnisse in Java 8

Auch wenn neuere Versionen von Java bereits weit verbreitet sind, benötigen alle angehenden Java-Entwickler fundierte Kenntnisse und Erfahrungen mit Java 8. Zu den nützlichsten Funktionen von Java 8 gehören:

• Standard- und statische Methoden zum Erstellen von Schnittstellen mit Methodenimplementierungen.
• Eine funktionale Schnittstelle, die nur über eine abstrakte Methode verfügt und Entwicklern hilft, das Hinzufügen weiterer abstrakter Methoden zu vermeiden.
• Lambda-Ausdrücke, die beim Erstellen funktionaler Schnittstellen helfen.
• Java Stream API zur Ermöglichung der parallelen und sequentiellen Ausführung.
• Neue Methoden in der Collection API.

All diese Eigenschaften machen Java 8 für die funktionale Programmierung unverzichtbar. Funktionale Programmierung sorgt für Parallelität und Kürze des Codes und hilft bei der Erstellung hochlastiger Anwendungen mit optimiertem Code. Java 8 wurde auch zur Grundlage für die Optimierung nativen Codes und ermöglichte die Optimierung der Entwicklung in anderen Sprachen wie Scala, Kotlin und Grails.

2. Erfahrung mit Tests

Unit-Tests in Java sind ein ziemlich kontroverses Thema. Einige Entwickler argumentieren, dass das Schreiben von Unit-Tests Zeitverschwendung sei, wir sind jedoch fest davon überzeugt, dass Unit-Test-Kenntnisse für jeden professionellen Java-Entwickler ein Muss sind. Mithilfe von Unit-Tests können Sie einzelne Codeblöcke testen und sicherstellen, dass das Endprodukt fehlerfrei funktioniert. Wenn ein Entwickler seine Fähigkeiten und Kenntnisse verbessern möchte, muss er daher lernen, die beliebtesten und effektivsten Testtools zu verwenden. Das wichtigste Test-Framework, mit dem Sie sich vertraut machen müssen, ist die JUnit 5-Bibliothek. Zu den weiteren Tools gehören:

• Roboter-Framework
• Mockito
• PowerMock

Neben Unit-Tests sollte ein Java-Entwickler auch andere Testmethoden (Systemtests, Akzeptanztests und Integrationstests) nicht vergessen. Dadurch können Sie umfassende Tests der Software durchführen und sicherstellen, dass keine Fehler, Bugs oder kritische Ausfälle vorliegen. Das Wichtigste beim Testen ist, dass kleine Änderungen zu großen Ergebnissen führen. Wenn Sie nicht zögern, Zeit und Mühe in Unit-Tests zu investieren, werden Sie von der Verbesserung der Qualität Ihrer Arbeit überrascht sein.

3. DevOps

Obwohl es nicht zwingend erforderlich ist, kann das Erlernen von DevOps und seinen Prinzipien für Sie als Entwickler und für das Unternehmen, für das Sie arbeiten, von Vorteil sein. Die Flexibilität und Organisation von DevOps-Prozessen ermöglicht es Unternehmen, die Qualität ihrer Produkte zu optimieren und Abläufe zu rationalisieren. und erhöhen zudem die Transparenz der Prozesse. DevOps in Java ist im Wesentlichen die Anwendung von DevOps auf die Java-Entwicklung. Das beinhaltet:

• Kontinuierliche Bereitstellung und Integration.
• Arbeiten mit Microservices statt Monolithen.
• Infrastruktur als Code.
• Automatisierte Tests.

DevOps ist ein weites Feld und erfordert viel Zeit und Ressourcen, um es zu studieren. Aber wenn Sie ein Java-Entwickler sind, wird das Erlernen von DevOps von Vorteil sein, da es Ihnen ermöglicht, in Zukunft ein DevOps-Ingenieur zu werden. Wenn Sie kein DevOps-Ingenieur werden möchten oder Ihr Unternehmen kein Interesse daran hat, ist das auch in Ordnung. Denken Sie daran, dass DevOps in der Java-Community immer beliebter wird.

4. Kenntnisse über Java-Bibliotheken und APIs.

Da Java eine der führenden Programmiersprachen der Welt ist, überrascht es nicht, dass es über eine große Anzahl verfügbarer APIs und Bibliotheken verfügt, mit denen man arbeiten kann. Diese Tools vereinfachen den Entwicklungsprozess erheblich und ermöglichen Entwicklern die schnelle Erstellung zuverlässiger Software. Nachfolgend haben wir eine Reihe grundlegender Tools aufgelistet, die jeder gute Java-Entwickler kennt und sicher verwenden kann. Mit diesen Tools können Sie schnell eine Anwendung erstellen und Daten und deren Speicherung effektiv verwalten:

• Gradle (ein Tool zum Erstellen von Anwendungen);
• Maven (etwas veraltet, aber immer noch beliebt, wird auch zum Erstellen von Anwendungen verwendet);
• Java 8-Standardpakete;
• Frühlings-Frameworks;
• JPA ORM (Hibernate, TopLink);
• NoSQL-Datenbanken (MongoDB, Cassandra).

Was die API betrifft, so muss ein Entwickler für die Arbeit mit der Java-Kern-API über gute Kenntnisse von OpenJDK, Android, Oracle und IS2T verfügen. Der große Vorteil dieser Tools besteht darin, dass sie alle mit einer ausführlichen und informativen Dokumentation geliefert werden. Darüber hinaus können Entwickler jederzeit Community-Unterstützung erhalten, was ebenfalls ein großer Vorteil ist.

5. Sichere Kenntnisse von Spring und Spring Boot

Das Spring Framework ist das am häufigsten verwendete Framework für die Entwicklung von Java-basierten Anwendungen. Daher ist es wichtig, dass ein Entwickler weiß, wie man damit arbeitet. Einer der Hauptvorteile von Spring ist die Abhängigkeitsinjektion, die die Erstellung lose gekoppelter Anwendungen ermöglicht und Entwicklern mehr Flexibilität bietet. Spring ist außerdem sehr leichtgewichtig und unterstützt XML-Konfigurationen, Anmerkungen und deklarative Programmierung. Wenn Sie also Java-Entwicklungsfähigkeiten beherrschen möchten, sollten Sie auch die Spring-Bereitstellung beherrschen. Spring Boot ist eine Iteration von Spring, die ein praktisches Tool für die schnelle Bereitstellung von Anwendungen bietet. Man kann mit Sicherheit sagen, dass Spring Boot Spring als Basis verwendet und darauf seine eigenen Funktionen aufbaut. Während bei Spring die Flexibilität im Vordergrund steht, trägt Spring Boot dazu bei, Code zu reduzieren und den Entwicklungsprozess zu vereinfachen. Es bietet Entwicklern sofort einsatzbereite Funktionen, hilft beim Erstellen eigenständiger Apps und ist insgesamt einfacher zu starten und zu verwalten. Spring Boot eignet sich hervorragend für Microservices und Anwendungen, die schnell erstellt werden müssen, da es die schnelle und einfache Einrichtung und Ausführung von Anwendungen für eine Vielzahl von Umgebungen (Produktion, Test, Qualität, CI/CD) ermöglicht. Sowohl Spring als auch Spring Boot wurden um React-Programmierfunktionen erweitert, was ein weiterer heißer Trend in der Entwickler-Community ist. Spring 5 verfügt beispielsweise jetzt über WebFlux, um einen reaktiven Ansatz zur Programmierung und Lösung komplexer verteilter Systeme zu implementieren.

6. Erfahrung mit Big Data

Big Data ist ein wachsender Trend, den Entwickler verfolgen und übernehmen müssen, um den Marktanforderungen gerecht zu werden. Die wichtigsten Tools, mit denen sich professionelle Java-Entwickler vertraut machen können, sind:

• Apache Spark
• Apache Kafka
• Hadoop (für Stapelverarbeitung)

Apache Spark ist eine verteilte Big-Data-Verarbeitungsplattform, die native Bindungen für Java bereitstellt. Dieses Framework erfreut sich aufgrund seiner Funktionen und Leistung großer Beliebtheit und ist derzeit das beliebteste Big-Data-Tool in der Java-Community. Apache Spark kann im Cluster-Standalone-Modus ausgeführt werden und hierfür benötigen Sie lediglich eine Apache Spark-Umgebung und eine JVM (für jede Maschine im Cluster). Spark ist außerdem unglaublich schnell und verfügt über eine sehr benutzerfreundliche Spark-API. Hadoop ist eine Datenspeicherplattform, die auch Java-Entwicklern bekannt ist. Obwohl Hadoop nicht so schnell ist wie Spark, bleibt es eines der beliebtesten Tools für die Arbeit mit Big Data. Dies liegt auch daran, dass Hadoop (und ähnliche Lösungen) über eine große Anzahl von Plugins verfügen, mit denen Sie Big-Data-Verarbeitungsprobleme effizient lösen und die Hadoop-Leistung generell optimieren können (einschließlich Unterstützung für Echtzeit-Stream-Verarbeitung).

7 optionale Java-Tipps, um Code-Unordnung zu beseitigen

Quelle: Medium „Ich habe Kollegen, die nichts von der Existenz von Optional wissen“, schreibt ein Java-Entwickler auf Reddit. Können wir davon ausgehen, dass Optional die „Lesbarkeit“ des Codes verbessert? Lohnt es sich, es ständig zu verwenden? Wo ist die Verwendung von Optional völlig unnötig? Da viele Entwickler immer noch nicht wissen, wie man Optional richtig verwendet, gebe ich 7 Beispiele für Optional-Missbräuche und was man dagegen tun kann.

1. Verwenden Sie „Optional“ nicht für die Nullprüfung

Die Verwendung von Optional anstelle der Nullprüfung führt nur zu Unordnung. Daraus ergibt sich kein Nutzen. Es ist auch ein Fehler, Optional und die Methoden isPresent und get zu verwenden . Die Entwickler glauben, dass get wie erwartet funktionieren sollte. Anschließend fügen sie isPresent hinzu und kehren zur Nullprüfung zurück. Denken Sie daran, dass Optional Ihre Nullprüfungen nicht korrigiert. Wenn Sie das nächste Mal sehen, dass isPresent und get (oder ElseThrow ) diesen Codeabschnitt ändern. Verwenden Sie „mapping“ und „orElse“ , um standardmäßige Nullprüfungen zu entfernen, und verwenden Sie „Optional“ selektiver. Hier ist ein gutes Beispiel:

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

Sie können mit dem optionalen Ziel beginnen. Der Zweck von Optional besteht darin, optionale, fehlende Werte darzustellen. Kehren Sie dann zu Ihrem Problem zurück und prüfen Sie, ob es für Sie funktioniert. Eine andere Möglichkeit, mit der Nullprüfung umzugehen, ist die Verwendung von Anmerkungen. Nullable oder NotNull sollten gut funktionieren. Sie können zwar Ihren Code verunreinigen und schützen nur zur Kompilierungszeit. Um die Laufzeit zu überprüfen, verwenden Sie Objects.requireNonNull .

2. Führen Sie eine ordnungsgemäße Fehlerbehandlung durch

Manchmal stellt Null Ausnahmen dar. Und das ist die falsche Art, Fehler und Ausnahmen zu signalisieren. „Etwas ist schief gelaufen, und hier ist es null“ ist ein Anti-Muster, das vermieden werden sollte. Außerdem sollten Sie Optional nicht verwenden, um Ausnahmen abzudecken. Hier ist ein Beispiel.

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

Warum ist myObject leer? Dies ist entweder ein Fehler oder ein leerer Wert. Sie würden also erneut ein mehrdeutiges Ergebnis erhalten und dadurch die Vorteile von Optional zunichtemachen. Dieser Code existiert, weil Leute versuchen, Optional für die Ablaufsteuerung zu verwenden. Optional werden einige Nullen aus Ihrer Codebasis entfernt. Sie müssen jedoch weiterhin das Try-Catch-Konstrukt verwenden, um Ausnahmen zu behandeln. Verwenden Sie Try-Catch, um Ausnahmen korrekt zu behandeln. Entfernen Sie „Optional“ nicht, wenn Sie Fehler behandeln, sondern warten Sie einfach und es wird perfekt funktionieren. Aber hier gibt es eine Ausnahme – leerer Catch . Wenn Sie nicht wissen, was Sie in einem leeren Catch zurückgeben sollen, sollte ein leeres Optional problemlos funktionieren.

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. Geben Sie von optionalen Methoden nicht Null zurück

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

Dies macht den Zweck von Optional zunichte. Dies ist ein weiteres Beispiel für schlechte Tests. Da die Eingabe leer ist, benötigen wir eine IllegalArgumentException -Datei . Auch das ist ein Fehler. Niemand muss optionale Aufrufmethoden überprüfen. Geben Sie ein leeres optionales Element zurück und überprüfen Sie niemals ein optionales Element auf Null.

4. Verwenden Sie „Optional“ nicht für Sammlungen.

Es ist nicht erforderlich, Sammlungen in Optional einzuschließen. Fügen Sie außerdem keine Optionals in Sammlungen ein. Dies macht die Sache nur noch komplizierter, da unnötiges Einpacken und zusätzliches Auspacken hinzukommen . Fügen Sie den Sammlungen keine Optionals hinzu. Daraus ergibt sich kein sichtbarer Nutzen. Halten Sie es einfach und verwenden Sie Optional für fehlende Werte.

5. Fesseln Sie nicht um der Fesselung willen

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

Optional verfügt über detaillierte Methoden, die dabei helfen können. Anstelle einer Kette reicht eine einfache Nullprüfung aus. Ich weiß, dass Optional gute Methoden und gute IDE-Unterstützung bietet. Sie können sie verwenden.

6. Verwenden Sie Wrapper für primitive Werte

Es ist kein großes Problem, aber Sie können OptionalInt oder OptionalLong verwenden . Durch einfaches Entfernen unnötiger Generika verbessern Sie die Leistung und schreiben prägnanteren Code.

7. Sie sollten über ofNullable Bescheid wissen

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

Diese Art von Code wird normalerweise von Entwicklern geschrieben, die nichts über Optional#ofNullable wissen . Die meisten Entwickler verstehen nicht einmal den Unterschied zwischen ofNullable und of . Sie verstehen nicht, wie Optional#of nach hinten losgehen kann. Die meisten würden auf ofNullable zurückgreifen , aus Angst, eine NullPointerException in Optional#of auszulösen . Auch dies macht den Zweck dieser beiden Methoden zunichte. Wenn wir nur ofNullable verwenden , warum brauchen wir dann überhaupt Optional#of ? Optional#of löst einen NPE aus, wenn Sie an null übergeben. Dies geschieht aus einem bestimmten Grund. Diese Methode sollte verwendet werden, wenn Sie erwarten, dass der Wert vorhanden ist. Wenn es nicht da ist, wird es schnell scheitern. Optional#ofNullable konvertiert Null in ein leeres Optional. Diese Methode verwendet null als Argument, was einem leeren Optional entspricht.