Java - Blog.Seconet.it

Java

Nov 13 2023

Esplorando il Magico Mondo di @Data in Spring Boot: Un Viaggio Amichevole nel Risparmio di Tempo e Codice!

Ciao amici sviluppatori! Oggi siamo qui per parlare di una delle annotazioni più magiche e utili di Spring Boot: @Data. Preparatevi per un viaggio nel risparmio di tempo e codice, poiché esploreremo come questa annotazione può rendere la nostra vita di sviluppatori più facile e divertente.

Che cos’è @Data?

Innanzitutto, cosa è questa @Data di cui tutti parlano? In termini semplici, @Data è un’annotazione fornita da Lombok, una libreria magica che aiuta a ridurre la verbosità del codice in Java. Quando applichiamo @Data a una classe, Lombok genera automaticamente metodi come toString, equals, hashCode, e, più importante, i metodi di accesso (getters e setters). Sì, avete letto bene, tutto quello che serve per una classe Java ordinaria, senza il fastidio di scriverlo tutto a mano!

Come Usare @Data in Spring Boot?

Immaginiamo di dover creare una semplice classe Person con alcuni attributi. Senza @Data, dovremmo scrivere manualmente tutti i metodi di accesso, il metodo toString, equals, hashCode, e via dicendo. Ma con @Data, tutto questo succede come per magia!

@Data
public class Person {
    private String firstName;
    private String lastName;
    private int age;
}

Ecco tutto! Con poche righe di codice, abbiamo una classe completa con metodi di accesso e altri metodi ausiliari generati automaticamente. Che risparmio di tempo! Inoltre, se aggiungiamo o rimuoviamo attributi dalla classe, non dobbiamo preoccuparci di mantenere aggiornati tutti quei metodi, Lombok lo fa per noi.[Read more]

Magia dietro le Quinte

Come Lombok fa questa magia? Quando compiliamo il nostro progetto, Lombok intercetta il processo di compilazione e genera automaticamente il codice per i metodi che richiede, basandosi sugli attributi della classe. Questo significa che possiamo concentrarci sullo sviluppo della logica del nostro programma senza la distrazione del boilerplate code.

Evitare la Verbosità, Abbracciare la Chiarezza

Oltre al risparmio di tempo, l’uso di @Data rende il codice più chiaro e leggibile. Senza la necessità di dichiarare manualmente tutti quei metodi di accesso, il nostro codice diventa più snello, focalizzato sulla logica effettiva della nostra applicazione. La chiarezza è la chiave per un codice manutenibile e comprensibile!

Considerazioni Finali

Quindi, amici sviluppatori, se non avete ancora abbracciato l’incantesimo di @Data in Spring Boot, è il momento di farlo! Risparmierete tempo, renderete il vostro codice più pulito e manterrà il vostro spirito di sviluppatore alto. Che il vostro codice sia leggero come una piuma e che il vostro sviluppo sia sempre privo di bozza

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Java

Mag 19 2023

Come Decodificare un token JWT in Java

Un JSON Web Token (JWT) viene spesso utilizzato nella sicurezza dell’API REST. Anche se il token può essere analizzato da framework come Spring Security OAuth , potremmo voler elaborare il token nel nostro codice.

In questo tutorial, decodificheremo e verificheremo l’integrità di un JWT .

Struttura di un JWT

Innanzitutto, capiamo la struttura di un JWT :

Header
Payload
Signature (firma)

La firma è facoltativa. Un JWT valido può essere costituito solo dalle sezioni di intestazione e payload. Tuttavia, utilizziamo la sezione della firma per verificare il contenuto dell’intestazione e il payload per L’autorizzazione si sicurezza.

Le sezioni sono rappresentate come stringhe con codifica base64url separate da un delimitatore punto (‘.’). In base alla progettazione, chiunque può decodificare un JWT e leggere il contenuto delle sezioni di intestazione e payload. Ma abbiamo bisogno di accedere alla chiave segreta utilizzata per creare la firma per verificare l’integrità di un token.

Più comunemente, il JWT contiene le “affermazioni” di un utente. Questi rappresentano i dati sull’utente, che l’API può utilizzare per concedere autorizzazioni o tracciare l’utente che fornisce il token. La decodifica del token consente all’applicazione di utilizzare i dati e la convalida consente all’applicazione di considerare attendibile che il JWT sia stato generato da una fonte attendibile.

Diamo un’occhiata a come possiamo decodificare e convalidare un token in Java.

Decodifica di un JWT

Possiamo decodificare un token utilizzando le funzioni Java integrate.

Per prima cosa, suddividiamo il token nelle sue sezioni:

String[] chunks = token.split("\\.");

Dovremmo notare che l’espressione regolare passata a String.split utilizza un ‘. ‘ con escape. carattere da evitare ‘.’ che significa “qualsiasi carattere”.

Il nostro array di blocchi ora dovrebbe avere due o tre elementi corrispondenti alle sezioni del JWT.

Successivamente, decodifichiamo l’intestazione e le parti del payload utilizzando un decodificatore base64url:

Base64.Decoder decoder = Base64.getUrlDecoder();

String header = new String(decoder.decode(chunks[0]));
String payload = new String(decoder.decode(chunks[1]));

Eseguiamo questo codice con un JWT (possiamo decodificare online per confrontare i risultati):

eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJBQkMxMjMiLCJleHAiOjE2ODQ1NjcyODgsImlhdCI6MTY4NDQ4MDg4OH0._p0r5iAzPfJCMamBSRGNSqQJu4xqtjyx7_EtQN1f9jE

L’output ci darà l’intestazione decodificata di qualsiasi payload:

{"alg":"HS256","typ":"JWT"}{"sub":"ABC123", "exp": 1684567288,"iat": 1684480888}

Se in un JWT sono definite solo le sezioni di intestazione e payload, abbiamo finito e le informazioni sono state decodificate correttamente.

Verifica del JWT

Successivamente, possiamo verificare l’integrità dell’intestazione e del payload per assicurarci che non siano stati alterati utilizzando la sezione della firma.

Dipendenze

Per la verifica, possiamo aggiungere jjwt al nostro pom.xml :

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.7.0</version>
</dependency>

Abbiamo bisogno di una versione di questa libreria dalla versione 0.7.0 in poi.

Configurazione dell’algoritmo di firma e della specifica della chiave

Per iniziare a verificare il payload e l’intestazione, abbiamo bisogno sia dell’algoritmo di firma utilizzato originariamente per firmare il token sia della chiave segreta:

SignatureAlgorithm sa = SignatureAlgorithm.HS256;
SecretKeySpec secretKeySpec = new SecretKeySpec(secretKey.getBytes(), sa.getJcaName());

In questo esempio, abbiamo codificato il nostro algoritmo di firma in HS256 . Tuttavia, potremmo decodificare il JSON dell’intestazione e leggere il campo alg per ottenere questo valore.

Dovremmo anche notare che la variabile secretKey è una rappresentazione String della chiave segreta. Potremmo fornirlo alla nostra applicazione tramite la sua configurazione o tramite un’API REST esposta dal servizio che emette il JWT.

Esecuzione della verifica

Ora che abbiamo l’algoritmo di firma e la chiave segreta, possiamo iniziare a eseguire la verifica.

Ricombiniamo l’intestazione e il payload in un JWT senza segno, unendoli con il ‘.’ delimitatore:

String tokenWithoutSignature = chunks[0] + "." + chunks[1];
String signature = chunks[2];

Ora abbiamo il token non firmato e la firma fornita. Possiamo usare la libreria per convalidarlo:

DefaultJwtSignatureValidator validator = new DefaultJwtSignatureValidator(sa, secretKeySpec);

if (!validator.isValid(tokenWithoutSignature, signature)) {
    throw new Exception("Could not verify JWT token integrity!");
}

Analizziamolo.

Innanzitutto, creiamo un validatore con l’algoritmo e il segreto scelti. Quindi gli forniamo i dati del token non firmato e la firma fornita.

Quindi il validatore genera una nuova firma e la confronta con la firma fornita. Se sono uguali, abbiamo verificato l’integrità dell’intestazione e del payload

Terminato

abbiamo esaminato la struttura di un JWT e come decodificarlo in JSON.

Quindi abbiamo utilizzato una libreria per verificare l’integrità di un token utilizzando la sua firma, l’algoritmo e la chiave segreta.

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Articoli Java Javascript PHP

Mar 16 2023

Un’API per tutti – Cloudmersive –

Cloudmersive è un’interessante piattaforma di servizi API basata su cloud che offre una vasta gamma di strumenti e funzionalità per lo sviluppo di applicazioni software. L’API di Cloudmersive consente agli sviluppatori di integrare facilmente le loro applicazioni con funzionalità avanzate come la conversione di file, l’elaborazione di immagini, la scansione di documenti, l’analisi di testo e molto altro.

Cloudmersive API offre una vasta gamma di API che coprono un’ampia gamma di funzionalità. Tra queste ci sono API per la conversione di file in diversi formati, inclusi PDF, DOCX, XLSX, PPTX e molti altri. Ci sono anche API per l’elaborazione di immagini, tra cui la ridimensionamento, il ritaglio e la conversione di immagini in vari formati.

Cloudmersive offre anche funzionalità per la scansione di documenti, consentendo agli sviluppatori di creare applicazioni che possono analizzare documenti come CV, fatture, documenti legali e altro ancora. Ci sono anche API per l’analisi di testo, che consentono di analizzare il testo per estrarre informazioni come nomi, date, luoghi e altro ancora.

Una delle cose migliori di Cloudmersive API è la facilità d’uso. La documentazione è chiara e ben organizzata, e ci sono esempi di codice per molte delle API disponibili. Inoltre, il processo di integrazione dell’API con la propria applicazione è semplice e veloce. In pochi minuti è possibile integrare una o più API nella propria applicazione.

Cloudmersive offre anche una piattaforma gratuita per l’uso delle API. Ciò significa che gli sviluppatori possono testare e utilizzare le API gratuitamente, senza dover pagare alcun costo iniziale.

Le API di Cloudmersive sono progettate per aiutare le aziende a gestire le proprie infrastrutture cloud in modo efficiente. Cloudmersive offre una serie di strumenti per la gestione dei dati, tra cui il monitoraggio dei dati, la gestione dei dati, la creazione di report e l’analisi dei dati, offre anche una serie di strumenti di gestione dello storage, tra cui la gestione dello spazio di archiviazione, la gestione della capacità e la gestione della sicurezza. Inoltre offre anche una serie di strumenti di analisi dei dati, tra cui la creazione di report, l’analisi dei dati e la gestione dei dati.

La documentazione delle API è molto ben fatta ed è correlata di esempi da cui partire in diversi linguaggi tra cui Java, PHP, C#, Javascript, Ruby, C/C++ etc.

Cosa aspettare allora? Su le maniche e iniziamo a creare le nostre applicazioni che sfruttano questo servizio gratis.

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Java

Mar 14 2023

Eclipse Shortcuts

Gli shortcuts in Eclipse sono uno strumento utile per accelerare la tua produttività. Con la giusta combinazione di tasti, è possibile svolgere le attività più comuni in Eclipse in pochi secondi. Gli shortcuts sono uno strumento prezioso per gli sviluppatori. Sono semplici da usare e possono aiutare a risparmiare tempo prezioso.

In Eclipse utilizzando la combinazione Ctrl + Shift + L avremo la lista completa di tutti gli shortcuts disponibili nell’ide, questa combinazione da tastiera è la più importante quando non ci ricordiamo la combinazione dei tasti per la nostra scrittura del codice.

Vediamo un elenco non esaustivo di quelli più comuni:

Ctrl + Shift + F: Formatta il codice
Ctrl + Space: Mostra suggerimenti di codifica
Ctrl + Shift + L: Visualizza la lista dei tasti di scelta rapida
Ctrl + Shift + T: Apre una nuova finestra di dialogo per cercare una classe
Ctrl + Shift + R: Apre una finestra di dialogo per cercare un file
Ctrl + Shift + [X/Y]: Cambia il carattere/stringa selezionata (Uppercase/Lowercase)
Ctrl + D: Cancella la riga
Ctrl + M: Massimizza la finestra di codice
Ctrl + 1: Visualizza la finestra quick fix
Ctrl + Shift + S: Salva tutte le modifice
Ctrl +S: Salva le modifiche al file aperto
Ctrl + Shift + / (tastiera numerica): Comprime tutti i metodi di classe alle definizioni
Ctrl + Shift + * (tastiera numerica): Espande tutti i metodi di classe
Ctrl + E: Switch editor
Alt + Shift +R: Rinomina – Refactoring
Alt + Enter: Proprietà del file aperto
Ctrl + Alt + Shift +L: Ricerca veloce

Altri shortcuts

Scrivi “sysout” + Ctrl + space: risultato System.out.println();
Scrivi “main” + Crtl + space: risultato verrà generato il metodo main della classe
Scrivi “for” + Ctrl + space: risultato verrà visualizzata una finestra per la generazione dei cicli for
Scrivi “while” +Ctrl + space: risultato verrà visualizzata una finestra per la generazione dei cicli while
Scrivi “if” + Ctrl +space: risultato verrà visualizzata una una finestra per la generazione condizione if

Dunque gli shortcuts ci consentono di eseguire rapidamente una determinata azione, Eclipse ha un sacco di scorciatoie per codificare Java più velocemente. Non è necessario impararle a memoria tutte, ma l’uso di quelle più comuni farà di noi uno sviluppatore migliore 😉

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Java

Mar 9 2023

Costruttore di copie in Java vs Clone

I costruttori di copie sono una funzionalità di programmazione Java che consente di creare una nuova istanza di una classe a partire da un’altra istanza esistente. Questo è utile quando si desidera creare una nuova istanza di una classe che sia simile a un’altra istanza già esistente. Ad esempio, potresti creare una nuova istanza di una classe che rappresenta un giocatore di calcio che ha le stesse caratteristiche di un giocatore esistente, ma con un nome diverso. Un costruttore di copie è un metodo speciale che viene chiamato quando si istanzia una nuova classe a partire da un’altra istanza esistente. Il costruttore di copie prende l’istanza esistente come argomento e ne crea ...Leggi di più

una nuova istanza con le stesse proprietà.

Facciamo un Esempio:

public class Calciatore {
    private String name;
    private int age;
 
    public Calciatore(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public Calciatore (Calciatore another) {
        this(another.name, another.age);
    }
 
    // Getters and setters
}

Come abbiamo visto il codice è molto semplice, Il costruttore di copia crea un nuovo oggetto con gli stessi valori dell’oggetto originale. Esiste inoltre una altra funzione predefinita in Java, la funzione clone() che è un metodo predefinito nella classe Object in Java che può essere usato per creare una copia di un oggetto.

Tuttavia, la funzione clone() ha una sintassi più complessa rispetto ai costruttori di copia, poiché richiede che l’oggetto sia clonabile e che si implementi l’interfaccia Cloneable. Inoltre, la funzione clone() può essere sovrascritta per creare una copia profonda dell’oggetto.

Ecco un esempio di seguito della funzione clone:

public class Main {

    public static void main(String[] args) {

        // Crea un oggetto originale
        Person personaOriginale = new Person("John", 25);

        // Crea una copia dell'oggetto originale
        Person personaClonata = personaOriginale.clone();

        // Stampa i valori dei due oggetti
        System.out.println("Persona originale: " + personaOriginale);
        System.out.println("Persona clonata: " + personaClonata);
    }
}

class Person implements Cloneable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public Person clone() {
        try {
            return (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }

    @Override
    public String toString() {
        return "Persona [name=" + name + ", age=" + age + "]";
    }
}

Ma quindi, è meglio utilizzare il costruttore di copie o la funzione clone in java?

Dipende dalle tue esigenze. Se hai bisogno di creare una copia di un oggetto, il costruttore di copia è l’opzione migliore. Se hai bisogno di una copia profonda dell’oggetto, allora la funzione clone è l’opzione migliore.

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere nei commenti!

Sergio Cornacchione 1 Commenti

Java

Mar 6 2023

Multithread in Java e priorità

La funzionalità multithreading in Java è quella che consente l’esecuzione simultanea di due o più parti di un programma per il massimo utilizzo della CPU. Ogni parte del programma viene chiamata thread. Quindi, i thread sono processi leggeri all’interno di un processo.

I thread possono essere creati utilizzando due meccanismi:

Estensione della classe Thread
Implementazione dell’interfaccia eseguibile

Creazione di thread estendendo la classe Thread
Creiamo una classe che estende la classe java.lang.Thread . Questa classe ...Leggi di più

sovrascrive il metodo run() disponibile nella classe Thread. Un thread inizia la sua vita all’interno del metodo run(). Creiamo un oggetto della nostra nuova classe e chiamiamo il metodo start() per avviare l’esecuzione di un thread. Start() richiama il metodo run() sull’oggetto Thread.

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread 1 in esecuzione");
            }
        });
 
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread 2 in esecuzione");
            }
        });
 
        t1.start();
        t2.start();
    }
}

Creazione di thread implementando l’interfaccia Runnable
Creiamo una nuova classe che implementa l’interfaccia java.lang.Runnable e sovrascrive il metodo run(). Quindi istanziamo un oggetto Thread e chiamiamo il metodo start() su questo oggetto.

public class MultithreadingDemo implements Runnable {
    public void run()
    {
        try {
            // Visualizzazione del thread in esecuzione
            System.out.println(
                    "Thread " + Thread.currentThread().getId()
                            + " is running");
        }
        catch (Exception e) {
            // eventuale eccezione
            System.out.println("Exception is caught" + e.getMessage());
        }
    }
}
// Main Class
class Multithread {
    public static void main(String[] args)
    {
        int n = 8; // Number of threads
        for (int i = 0; i < n; i++) {
            Thread object
                    = new Thread(new MultithreadingDemo());
            object.start();
        }
    }
}

In conclusione

Se estendiamo la classe Thread, la nostra classe non può estendere nessun’altra classe perché Java non supporta l’ereditarietà multipla. Ma, se implementiamo l’interfaccia Runnable, la nostra classe può ancora estendere altre classi base.
Possiamo ottenere le funzionalità di base di un thread estendendo la classe Thread perché fornisce alcuni metodi integrati come yield(), interrupt() ecc. che non sono disponibili nell’interfaccia Runnable.
L’uso di runnable ti darà un oggetto che può essere condiviso tra più thread.

Parliamo ora di come ottenere e impostare la priorità di un thread in java.

public final int getPriority(): il metodo java.lang.Thread.getPriority() restituisce la priorità del thread specificato.
public final void setPriority(int newPriority): il metodo java.lang.Thread.setPriority() modifica la priorità del thread nel valore newPriority. Questo metodo genera IllegalArgumentException se il valore del parametro newPriority supera il limite minimo(1) e massimo(10).

Il thread con la priorità più alta avrà una possibilità di esecuzione prima degli altri thread. Supponiamo che ci siano 3 thread t1, t2 e t3 con priorità 4, 6 e 1. Quindi, il thread t2 verrà eseguito per primo in base alla priorità massima 6, dopodiché verrà eseguito t1 e quindi t3.

Ora smanettoni vi starete chiedendo cosa succede se assegniamo le stesse priorità ai thread ?

Semplice, se due thread hanno la stessa priorità, non possiamo aspettarci quale thread verrà eseguito per primo. Dipende dall’algoritmo del thread scheduler (Round-Robin, First Come First Serve, ecc.)

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Java

Mar 5 2023

Exceptions in Java Checked vs Unchecked

Migliaia di parole spese intorno a questo argomento, reclutatori che pongono questa domanda ai candidati come fosse un paradigma indispensabile (non per dire che non sia importante !) , eppure tutto ruota intorno ad una parola chiave “throw”, ma cerchiamo di capire meglio.

L’eccezione è un evento indesiderato o imprevisto, che si verifica durante l’esecuzione di un programma, cioè in fase di esecuzione, che interrompe il normale flusso delle istruzioni del programma. In Java, ci sono due tipi di eccezioni:

Eccezioni verificate
Eccezioni non controllate

Le eccezioni verificate o controllate in Java ...Leggi di più

sono quelle che vengono controllate in fase di compilazione. Esempi di eccezioni verificate includono IOException, SQLException e FileNotFoundException.

Le eccezioni controllate vengono controllate in fase di compilazione e pertanto il compilatore richiede al programmatore di gestire o dichiarare queste eccezioni. Ciò significa che il programmatore deve includere un blocco try-catch (ma questa è una regola ormai assodata e basilare per un programmatore )o un’istruzione throws per le gestire le eccezioni.

La gestione delle eccezioni, serve quindi ad evitare l’arresto anomalo del programma o produrre risultati imprevisti. Il modo migliore per gestire le eccezioni verificate è utilizzare il blocco try-catch. Ciò consente al programmatore di rilevare l’eccezione e intraprendere l’azione appropriata.

Vediamo un esempio:

public static void main(String[] args) {
      try {
         int[] myNumbers = {1, 2, 3};
         System.out.println(myNumbers[10]);
      } catch (Exception e) {
         System.out.println("Errore!");
      }
   }

Cosa abbiamo fatto? Abbiamo dichiarato e creato un array di interi di 3 elementi, ma ne vogliamo stampare 10, chiaro che questo genera un’eccezione, ma la nostra è una eccezione verificata o controllata completamente. Si perchè nell’eccezione controllata, ci sono due tipi: eccezioni completamente controllate e eccezioni parzialmente controllate. Ad esempio lo script in alto poteva essere parzialmente controllata eliminando il try-catch e usando la parola chiave throws:

  public static void main(String[] args) throws Exception
    {
         int[] myNumbers = {1, 2, 3};
         System.out.println(myNumbers[10]);
         System.out.println("Errore!");
    }

Il compilatore Java non avrebbe fatto nessuna obiezione e il nostro programmino sarebbe stato compilato.

Le eccezioni non controllate in Java sono quelle che non vengono controllate in fase di compilazione. Sono anche conosciute come eccezioni di runtime. Le eccezioni non controllate sono il tipo più comune di eccezione in Java e si verificano quando un programma è in esecuzione. Esempi di eccezioni non controllate includono NullPointerException, ArrayIndexOutOfBoundsException e ClassCastException.Quindi eccezioni nelle classi Error e RuntimeException sono eccezioni non controllate, tutto il resto sotto throwable è controllato.

Le eccezioni non controllate non vengono controllate in fase di compilazione e pertanto il compilatore non richiede al programmatore di gestire o dichiarare queste eccezioni.

Ecco un esempio:

 public static void main(String args[])
    {
        int x = 0;
        int y = 10;
        int z = y / x;
    }

Chiaro che una divisione per 0 genera in run-time una eccezione. Queste eccezioni sono in genere causate da errori di programmazione !

In conclusione, le eccezioni non controllate e controllate sono due diversi tipi di eccezioni in Java. Le eccezioni non controllate non vengono controllate in fase di compilazione, mentre le eccezioni controllate vengono controllate in fase di compilazione. È importante gestire entrambi i tipi di eccezioni, poiché possono causare l’arresto anomalo del programma o produrre risultati imprevisti. Il modo migliore per gestire le eccezioni è utilizzare il blocco try-catch.

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Java

Mar 3 2023

Le collection di tipo set in java

Le collezioni di tipo Set in Java sono un tipo di contenitore che non consente elementi duplicati. In altre parole, ogni elemento all’interno di un Set deve essere unico

^[1]. L’interfaccia Set è implementata dalle classi HashSet, LinkedHashSet e TreeSet.La classe HashSet implementa l’interfaccia Set utilizzando una tabella hash. Questo significa che gli elementi all’interno di un HashSet non sono ordinati e possono essere acceduti in modo casuale

^[2].La classe LinkedHashSet estende la classe HashSet e mantiene l’ordine di inserimento degli elementi. Ciò significa che gli elementi all’interno di un LinkedHashSet possono essere acceduti nell’ordine in cui sono stati inseriti

^[2].La classe TreeSet implementa l’interfaccia SortedSet e mantiene gli elementi ordinati in base al loro valore. Ciò significa che gli elementi all’interno di un TreeSet possono essere acceduti in ordine crescente o decrescente...Leggi di più

^[2].Per aggiungere elementi a un Set, si può utilizzare il metodo add(). Per rimuovere elementi da un Set, si può utilizzare il metodo remove().

^[1]Per verificare se un elemento esiste all’interno di un Set, si può utilizzare il metodo contains().

Ecco un esempio di codice:

import java.util.HashSet;

public class Main {
  public static void main(String[] args) {
    // Creazione del set
    HashSet<String> set = new HashSet<String>();

    // Aggiunta degli elementi al set
    set.add("elemento1");
    set.add("elemento2");
    set.add("elemento3");

    // Stampa del set
    System.out.println(set);

    // Rimozione dell'elemento "elemento2" dal set
    set.remove("elemento2");

    // Verifica se l'elemento "elemento1" esiste nel set
    System.out.println(set.contains("elemento1"));
  }
}

Nell’esempio sopra abbiamo visto come aggiungere elementi alla collection di tipo set, ma come facciamo a rimuovere un elemento ? Semplice utilizziamo il metodo remove.

// Rimozione dell'elemento "elemento2" dal set
    set.remove("elemento2");

Se invece abbiamo bisogno di cercare un elemento possiamo utilizzare il metodo contains

 // Verifica se l'elemento "elemento1" esiste nel set
    System.out.println(set.contains("elemento1"));

Set vs List un List è una sequenza ordinata di elementi che consente duplicati, mentre un Set è una sequenza non ordinata di elementi distinti che non consente duplicati. Un’altra differenza tra i due è che un List può contenere qualsiasi numero di valori nulli, mentre un Set può contenere al massimo un elemento nullo.
Sia List che Set sono interfacce che appartengono al framework Collection ed estendono l’interfaccia Collection. La scelta tra l’utilizzo di un elenco o di un set dipende dal caso d’uso specifico. Se l’ordine e i duplicati sono importanti, è necessario utilizzare un elenco. Se sono necessari solo elementi distinti e l’ordine non è importante, è comodo utilizzare un set.
Vale la pena notare che ci sono diverse classi in Java che implementano entrambe le interfacce, come ArrayList per List e HashSet per Set[1].

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Java

Feb 27 2023

Creare un servizio Rest – Jpa – MVC con Spring Boot in soli 5 minuti

Una API (Application Programming Interface) è un insieme di funzioni e procedure per accedere a un servizio o a un sistema operativo. Un’API consente a un programmatore di scrivere codice che interagisce con un servizio o un sistema operativo.

Un servizio web, d’altra parte, è una collezione di API che consentono a un’applicazione di comunicare con un altro sistema attraverso la rete. Un servizio web può essere esposto nella forma di un’API, ma può anche essere esposto come una pagina web o una pagina HTML. Un servizio web può essere creato utilizzando una varietà di tecnologie, come ad esempio XML, JSON, SOAP e REST. In questo esempio cito a modo un Servizio poichè quello che vedremo è una vera è propria applicazione web (se implementato con le le relative pagine View), ma viene esposto come un’ API.

Non perdiamo tempo e mettiamoci subito al lavoro d’altronde abbiamo solo 5 minuti. ...Leggi di più

Iniziamo a creare il nostro progetto Spring Boot. Possiamo farlo utilizzando l’Initializr recondoci col browser a questo indirizzo https://start.spring.io/ oppure se utilizziamo l’Ide STS (Spring Tool Suite) in File->New–>Spring Starter Project.
Dobbiamo aggiungere come dipendenze Spring data JPA e Spring Web la schermata sarà simile a questa:

A seconda del nome scelto per il Package avremo già quasi tutto pronto, ma per fare il progetto con ordine creeremo altri 3 package (controller – dao – model). La schermata sarà simile alla seguente:

In ogni nuovo package avremo in questo esempio 3 nuovi file di cui 2 classi e una interfaccia, iniziamo dal controller, annotiamo il mapping e settiamo la classe come controller ecco il codice:

@Controller
public class AlienController {
	
	@Autowired
	AlienRepo repo;
	
	//Response in json format
	@RequestMapping("/aliens")
	@ResponseBody
	public List<Alien> getAliens() {
		return repo.findAll();
	}
	
	@RequestMapping("/alien/{aid}")
	@ResponseBody
	public Optional<Alien> getAliensById(@PathVariable("aid") int aid) {
		return repo.findById(aid);
	}

}

Notiamo subito che c’è una notazione @Autowired, è la nostra interfaccia all’entità del repository. Quindi ci spostiamo nel package controller e creiamo la nostra interfaccia ecco il codice:

public interface AlienRepo extends JpaRepository<Alien, Integer> {	 
}

La nostra interfaccia non implementa nessun metodo perchè JpaRepository contine già i metodi chiamati dal controller

Non ci resta che creare L’Entity, ci spostiamo nel nostro package model e creiamo la nostra classe entità che sarà la copia della nostra tabella del database. Nota che in questo esempio viene usato il database in memory H2, quando chiuderai il progetto o lo fai ripartire tutti i dati saranno persi, naturalmente puoi usare altri db che preferisci, ma passiamo al codice:

@Entity
public class Alien {
	
	 @Id
	private int aid;
	private String aname;
	private String tech;
	
	
	public int getAid() {
		return aid;
	}
	public void setAid(int aid) {
		this.aid = aid;
	}
	public String getAname() {
		return aname;
	}
	public void setAname(String aname) {
		this.aname = aname;
	}
	
	public String getTech() {
		return tech;
	}
	public void setTech(String tech) {
		this.tech = tech;
	}
	@Override
	public String toString() {
		return "Alien [aid=" + aid + ", aname=" + aname + ", tech=" + tech + "]";
	}
}

Questa classe è molto semplice, viene annotata come @Entity e contiene solo 3 campi, tutti gli altri metodi vengono scritti automaticamente dal nostro IDE (in eclipse tasto dx –>source–>Generate getter & setter )

Abbiamo quasi terminato, andiamo nella cartella src/main/resources e apriamo il file application.properties inizialmente sarà vuoto dobbiamo popolarlo con solo 3 righe come segue:

spring.h2.console.enabled=true
spring.sql.init.platform=h2
spring.datasource.url=jdbc:h2:mem:seco

Abbiamo abilitato la console H2 e impostato la connessione.

INCREDIBILE ABBIAMO FINITO, COME PROMESSO IN MENO DI 5 MINUTI !

Possiamo far partire il nostro progetto avremo su http://localhost:8080/h2-console la nostra console del db:

Dopo l’ accesso popolate la tabella Alien che è stata generata automaticamente con qualche insert tipo queste righe:

insert into alien values (101, 'Mario', 'Java');
insert into alien values (102, 'Beppe', 'Net');
insert into alien values (103, 'Renato', 'Php');
insert into alien values (104, 'Segio', 'Jquery');
insert into alien values (105, 'Domi', 'C#');
insert into alien values (106, 'Rino', 'CSS');

Non ci resta che testare il nostro servizio:

Su http://localhost:8080/aliens ci verrà restituito in formato Json tutti i nostri record, mentre su http://localhost:8080/alien/102 ci verrà restituito il record con ID 102.

Buon lavoro ! Vuoi il codice dell’esempio ? Scrivi

Se in questa articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Java

Feb 20 2023

ChatGPT nelle tue applicazioni Java (esempio completo)

Premessa

La chat GPT (Generative Pre-trained Transformer) è una tecnologia di intelligenza artificiale
che consente a un computer di comprendere le conversazioni e di rispondere in modo appropriato.
Si tratta di una tecnologia di apprendimento automatico che utilizza reti neurali per apprendere da grandi quantità di dati e fornire risposte più pertinenti. (magari nei prossimi articoli spiegherò come addestrarlo per esigenze specifiche)

GPT è stato sviluppato da OpenAI ed è stato reso open source. La tecnologia GPT è stata utilizzata
per creare chatbot che possono essere implementati in numerosi linguaggi di programmazione, qui vedremo come integrarlo in Java. ...Leggi di più

Innanzitutto, dovrai registrarti per una chiave API accedendo alla pagina dell’API OpenAI . Segui le istruzioni per creare un account e ottenere una tua chiave API. Inoltre, la registrazione ti consente di accedere a tutte le funzionalità di OpenAI, come la creazione di modelli di machine learning e l’utilizzo dei servizi di ricerca.

Iniziamo subito con il codice:

Creiamo il nostro progetto Java-Maven (ci servirà per gestire una unica dipendenza) con qualsiasi IDE con cui siamo abituati a lavorare. Qui vedrai delle schermate Intellij IDEA

Generato il progetto apriamo il file pom.xml che troviamo alla radice del progetto aggiungiamo questa dipendenza tra i tag <dependencies> e </dependencies>

  <dependency>
            <groupId>org.json</groupId>
            <artifactId>json</artifactId>
            <version>20220924</version>
  </dependency>

Aggiungiamo una classe che chiameremo ChatGPT e inseriamo il seguente codice che spiegheremo in seguito:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

public void chatGPT(String text) throws Exception{
        String url = "https://api.openai.com/v1/completions";
        String OPENAI_API_KEY = "QUI LA TUA CHIAVE API";
        HttpURLConnection con = (HttpURLConnection) new URL(url).openConnection();
        con.setRequestMethod("POST");
        con.setRequestProperty("Content-Type", "application/json");
        con.setRequestProperty("Authorization", "Bearer " + OPENAI_API_KEY);

        JSONObject data = new JSONObject();
        data.put("model", "text-davinci-003");
        data.put("prompt", text);
        data.put("max_tokens", 2048);
        data.put("temperature", 0.5);

        con.setDoOutput(true);
        con.getOutputStream().write(data.toString().getBytes());

        String output = new BufferedReader(new InputStreamReader(con.getInputStream())).lines()
                .reduce( (a,b) -> a+b).get();

       System.out.println(new JSONObject(output).getJSONArray("choices").getJSONObject(0).getString("text"));
    }

La prima parte del codice è abbastanza semplice, abbiamo creato una istanza alla classe URLConnection che fornisce una connessione bidirezionale tra un client e un server su una rete, che può essere usata per inviare e ricevere dati, quindi abbiamo definito l’url da chiamare e settato il tipo di richiesta, il contenuto della richiesta e l’autorizzazione di accesso (la key API).

Abbiamo ora bisogno di un parser Json che renda intellegibile la risposta di chatGPT, quindi creiamo un oggetto e lo settiamo su alcune proprietà che l’API saprà interpretare, il modello (davinci-003), la risposta (testo), il max_token(Questo parametro è utile per limitare la lunghezza della risposta generata dal modello ed evitare che diventi troppo lunga) e la temperature (Il parametro “temperature” nell’API ChatGPT è un modo per controllare la quantità di rischio che l’API prende con le sue risposte. Un valore più alto significa che l’API è più propensa a rischiare con le sue risposte, mentre un valore più basso significa che l’API è più propensa a dare risposte più certe.)

Infine stampiamo in consolle la risposta fornita da chatGPT creando una variabile di tipo String chiamata output. Utilizzando BufferedReader per leggere i dati da un InputStreamReader, che a sua volta ottiene i dati dall’InputStream della connessione (con), che vengono ridotti in una singola stringa e assegna il risultato alla variabile output.

Abbiamo quasi terminato

Apriamo la classe Main che è stata generata automaticamente dal progetto e aggiungiamo nel metodo main questo codice avremo quindi una cosa di questo tipo:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) throws Exception {

        Scanner input = new Scanner(System.in);
        System.out.print("Inserisci la tua domanda: ");
        String question = input.nextLine();

        new ChatGPT().chatGPT(question);

        input.close();

    }
}

Abbaiamo inserito semplicemente un oggetto scanner per ottenere dall’utente la domanda da sottoporre a chatGPT

Finito ! Facciamo il run del nostro progetto e dopo qualche secondo chatGPT ci fornirà una risposta alla nostra domanda.

Puoi scaricare l’intero codice da qui: blog.seconet.it/ChatGPT nelle tue applicazioni Java

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Archivi categoria: Java

Che cos’è @Data?

Come Usare @Data in Spring Boot?

Magia dietro le Quinte

Evitare la Verbosità, Abbracciare la Chiarezza

Considerazioni Finali