Pausa caffè #109. Le competenze più richieste nello sviluppo Java in questo momento. 7 suggerimenti opzionali Java per eliminare la confusione di codici

Le competenze più richieste nello sviluppo Java in questo momento

Fonte: Medium Java rimane uno dei linguaggi di programmazione più popolari e richiesti, nonostante abbia quasi un quarto di secolo. Pertanto, è ragionevole supporre che la popolarità di Java continuerà a crescere e che gli sviluppatori Java vedranno una domanda ancora maggiore da parte dei datori di lavoro in futuro. Per creare prodotti di qualità, gli sviluppatori devono tenere il passo con gli strumenti Java più recenti e migliorare le proprie competenze e conoscenze tecniche. Di seguito presentiamo sei competenze essenziali richieste agli sviluppatori Java.

1. Ottima conoscenza di Java 8

Anche se le versioni più recenti di Java sono già ampiamente utilizzate, tutti gli aspiranti sviluppatori Java necessitano di conoscenza ed esperienza approfondite con Java 8. Alcune delle funzionalità più utili di Java 8 includono:

• Metodi standard e statici per la creazione di interfacce con implementazioni di metodi.
• Un'interfaccia funzionale che ha un solo metodo astratto e aiuta gli sviluppatori a evitare di aggiungere altri metodi astratti.
• Espressioni Lambda che aiutano a creare interfacce funzionali.
• API Java Stream per consentire l'esecuzione parallela e sequenziale.
• Nuovi metodi nell'API di raccolta.

Tutte queste caratteristiche rendono Java 8 indispensabile per la programmazione funzionale. La programmazione funzionale fornisce concorrenza e brevità del codice e aiuta a creare applicazioni ad alto carico con codice ottimizzato. Java 8 è diventato anche la base per l'ottimizzazione del codice nativo, consentendo l'ottimizzazione dello sviluppo in altri linguaggi come Scala, Kotlin e Grails.

2. Esperienza con i test

Il test unitario in Java è un argomento piuttosto controverso. Alcuni sviluppatori sostengono che scrivere test unitari sia una perdita di tempo, ma noi crediamo fermamente che le capacità di test unitari siano un must per qualsiasi sviluppatore Java professionista. Il test unitario consente di testare singoli blocchi di codice e garantisce che il prodotto finale funzioni senza errori. Pertanto, se uno sviluppatore desidera migliorare le proprie capacità e conoscenze, deve imparare a utilizzare gli strumenti di test più popolari ed efficaci. Il framework di test principale con cui devi acquisire familiarità è la libreria JUnit 5. Altri strumenti includono:

• Quadro robotico
• Mockito
• PowerMock

Oltre al test unitario, uno sviluppatore Java non dovrebbe dimenticare altri metodi di test (test di sistema, test di accettazione e test di integrazione). Ciò consente di eseguire test completi del software e assicurarsi che non vi siano errori, bug o guasti critici. La cosa principale da ricordare riguardo ai test è che piccoli cambiamenti portano a grandi risultati. Se non esiti a dedicare tempo e impegno ai test unitari, rimarrai stupito dal miglioramento della qualità del tuo lavoro.

3. DevOps

Sebbene non sia obbligatorio, conoscere DevOps e i suoi principi può essere utile per te come sviluppatore e per l'azienda per cui lavori. La flessibilità e l'organizzazione dei processi DevOps consente alle aziende di ottimizzare la qualità dei propri prodotti e snellire le operazioni. e aumentare anche la trasparenza dei processi. DevOps in Java è essenzialmente l'applicazione di DevOps allo sviluppo Java. Ciò comprende:

• Distribuzione e integrazione continue.
• Lavorare con microservizi anziché monoliti.
• Infrastruttura come codice.
• Test automatizzati.

DevOps è un campo vasto e richiede una notevole quantità di tempo e risorse per studiarlo. Ma se sei uno sviluppatore Java, imparare DevOps sarà utile in quanto ti consentirà di diventare un ingegnere DevOps in futuro. Se non vuoi diventare un ingegnere DevOps o la tua azienda non è interessata, va bene lo stesso. Tieni presente che DevOps sta diventando sempre più popolare nella comunità Java.

4. Conoscenza delle librerie e delle API Java.

Poiché Java è uno dei linguaggi di programmazione più diffusi al mondo, non sorprende che abbia un numero enorme di API e librerie disponibili con cui lavorare. Questi strumenti semplificano notevolmente il processo di sviluppo e consentono agli sviluppatori di creare rapidamente software affidabile. Di seguito abbiamo elencato un set di strumenti di base che ogni buon sviluppatore Java conosce e può utilizzare con sicurezza. Questi strumenti ti aiutano a creare rapidamente un'applicazione e a gestire in modo efficace i dati e il relativo spazio di archiviazione:

• Gradle (uno strumento per creare applicazioni);
• Maven (un po' datato ma ancora popolare, utilizzato anche per creare applicazioni);
• Pacchetti standard Java 8;
• Quadri primaverili;
• JPA ORM (Ibernazione, TopLink);
• Database NoSQL (MongoDB, Cassandra).

Per quanto riguarda l'API, per lavorare con l'API Java principale, uno sviluppatore deve avere una buona conoscenza di OpenJDK, Android, Oracle e IS2T. Il grande vantaggio di questi strumenti è che sono tutti dotati di documentazione dettagliata e informativa. Inoltre, gli sviluppatori possono sempre ottenere il supporto della comunità, il che è anche un grande vantaggio.

5. Conoscenza approfondita di Spring e Spring Boot

Spring Framework è il framework più comunemente utilizzato per lo sviluppo di applicazioni basate su Java, quindi è importante che uno sviluppatore sappia come lavorarci. Uno dei principali vantaggi di Spring è l'inserimento delle dipendenze, che consente di creare applicazioni liberamente accoppiate e offre agli sviluppatori maggiore flessibilità. Spring è anche molto leggero e supporta configurazioni XML, annotazioni e programmazione dichiarativa. Quindi, se vuoi padroneggiare le competenze di sviluppo Java, dovresti anche padroneggiare la distribuzione Spring. Spring Boot è un'iterazione di Spring che fornisce uno strumento utile per distribuire rapidamente le applicazioni. Si può dire con certezza che Spring Boot utilizza Spring come base e su di essa costruisce le proprie funzionalità. Mentre Spring si concentra sulla flessibilità, Spring Boot aiuta a ridurre il codice e a semplificare il processo di sviluppo. Offre agli sviluppatori funzionalità pronte all'uso, aiuta a creare app autonome ed è nel complesso più facile da avviare e gestire. Spring Boot è ottimo per microservizi e applicazioni che devono essere creati rapidamente, poiché semplifica e velocizza la configurazione e l'esecuzione di applicazioni per una varietà di ambienti (produzione, test, qualità, CI/CD). Sia Spring che Spring Boot si sono ampliati con le funzionalità di programmazione React, che è un'altra tendenza calda nella comunità degli sviluppatori. Spring 5, ad esempio, ora dispone di WebFlux per implementare un approccio reattivo alla programmazione e alla risoluzione di sistemi distribuiti complessi.

6. Esperienza con i Big Data

I Big Data sono una tendenza in crescita che gli sviluppatori devono seguire e adottare per soddisfare le richieste del mercato. Gli strumenti principali con cui gli sviluppatori Java professionisti possono acquisire familiarità sono:

• Apache Spark
• Apache Kafka
• Hadoop (per l'elaborazione batch)

Apache Spark è una piattaforma di elaborazione Big Data distribuita che fornisce collegamenti nativi per Java. Questo framework è diventato estremamente popolare grazie alle sue funzionalità e prestazioni ed è attualmente lo strumento per big data preferito nella comunità Java. Apache Spark può essere eseguito in modalità cluster standalone e per questo è necessario solo un ambiente Apache Spark e una JVM (per ogni macchina nel cluster). Spark è anche incredibilmente veloce e dispone di un'API Spark molto intuitiva. Hadoop è una piattaforma di archiviazione dati ben nota anche agli sviluppatori Java. Sebbene Hadoop non sia veloce come Spark, rimane uno degli strumenti più popolari per lavorare con i big data. Ciò è dovuto anche al fatto che Hadoop (e soluzioni simili) dispongono di un gran numero di plugin che consentono di risolvere in modo efficiente i problemi di elaborazione dei Big Data e in generale di ottimizzare le prestazioni di Hadoop (incluso il supporto per l'elaborazione dei flussi in tempo reale).

7 suggerimenti opzionali Java per eliminare la confusione di codici

Fonte: Medium "Ho colleghi che non sanno dell'esistenza di Opzionale", scrive uno sviluppatore Java su Reddit. Possiamo considerare che l'Optional migliori la “leggibilità” del codice? Vale la pena usarlo sempre? Dove l'uso dell'Optional è completamente inutile? Dato che molti sviluppatori non sanno ancora come utilizzare correttamente gli Opzionali, fornirò 7 esempi di abusi degli Opzionali e cosa fare al riguardo.

1. Non utilizzare Opzionale per il controllo nullo

L'uso di Opzionale invece del controllo null aggiunge semplicemente disordine. Non vi è alcun vantaggio da questo. È anche un errore utilizzare Optional e i metodi isPresent e get . Gli sviluppatori ritengono che get dovrebbe funzionare come previsto. Quindi aggiungono isPresent e tornano al controllo null. Ricorda che Opzionale non corregge i tuoi controlli nulli. La prossima volta che vedi isPresent e ottieni (o ElseThrow ) modifica questo pezzo di codice. Utilizzare la mappatura e orElse per rimuovere i controlli null standard e utilizzare Opzionale in modo più selettivo. Ecco un buon esempio:

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

Puoi iniziare con il target Opzionale. Lo scopo di Optional è rappresentare valori mancanti facoltativi. Quindi torna al tuo problema e vedi se funziona per te. Un altro modo per gestire il controllo nullo è utilizzare le annotazioni. Nullable o NotNull dovrebbero funzionare correttamente. È vero, possono inquinare il tuo codice e proteggono solo in fase di compilazione. Per controllare il runtime utilizzare Objects.requireNonNull .

2. Gestire correttamente gli errori

A volte null rappresenta eccezioni. E questo è il modo sbagliato di segnalare errori ed eccezioni. “Qualcosa è andato storto, e qui è nullo” è un anti-pattern che dovrebbe essere evitato. Inoltre, non dovresti usare Opzionale per coprire le eccezioni. Ecco un esempio.

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

Perché myObject è vuoto? Questo è un errore o un valore vuoto. Quindi otterresti nuovamente un risultato ambiguo e di conseguenza cancelleresti i vantaggi di Opzionale. Questo codice esiste perché le persone stanno tentando di utilizzare Opzionale per il controllo del flusso. Facoltativo rimuoverà alcuni zeri dalla base di codice. Ma è comunque necessario utilizzare il costrutto try-catch per gestire le eccezioni. Utilizzare try-catch per gestire correttamente le eccezioni. Non rimuovere Opzionale durante la gestione degli errori, aspetta e funzionerà perfettamente. Ma qui c'è un'eccezione: la cattura vuota . Quando non sai cosa restituire in un catch vuoto, un Opzionale vuoto dovrebbe funzionare correttamente.

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. Non restituire null dai metodi opzionali

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

Ciò vanifica lo scopo di Opzionale. Questo è un altro esempio di test scadenti. Poiché l'input è vuoto, significa che abbiamo bisogno di un file IllegalArgumentException . Inoltre, questo è un errore. Nessuno ha bisogno di controllare i metodi di chiamata opzionali. Restituisce un elemento opzionale vuoto e non controlla mai un elemento opzionale per null.

4. Non utilizzare Opzionale con le raccolte.

Non è necessario racchiudere le raccolte in Opzionale. Inoltre, non inserire optional nelle raccolte. Ciò non fa altro che complicare le cose aggiungendo box inutili e scarti aggiuntivi. Non aggiungere facoltativi alle raccolte. Non vi è alcun beneficio visibile da questo. Mantienilo semplice e usa Opzionale per i valori mancanti.

5. Non incatenare per il gusto di incatenare

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

Facoltativo contiene metodi dettagliati che possono aiutare in questo. Invece della catena, sarà sufficiente un semplice controllo nullo. So che Opzionale ha buoni metodi e un buon supporto IDE. Puoi usarli.

6. Utilizzare wrapper di valori primitivi

Non è un grosso problema, ma puoi usare OptionalInt o OptionalLong . Semplicemente rimuovendo i generici non necessari, migliorerai le prestazioni e scriverai un codice più conciso.

7. Dovresti conoscere ofNullable

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

Questo tipo di codice viene solitamente scritto da sviluppatori che non conoscono Optional#ofNullable . La maggior parte degli sviluppatori non capisce nemmeno la differenza tra ofNullable e of . Non capiscono come l'Optional#of possa ritorcersi contro. La maggior parte ricorrerebbe a ofNullable per paura di lanciare una NullPointerException in Optional#of . Ancora una volta, questo vanifica lo scopo di questi due metodi. Se utilizziamo solo ofNullable , perché abbiamo bisogno di Optional#of ? Facoltativo#of genera un NPE quando si passa a null. Questo accade per una ragione. Questo metodo dovrebbe essere utilizzato quando si prevede che il valore sia presente. Se non è presente, fallirà rapidamente. Opzionale#ofNullable converte null in un Opzionale vuoto. Questo metodo accetta null come argomento, che corrisponde a un Opzionale vuoto.