Pausa caffè #124. Modello di progettazione del costruttore. Come funzionano la serializzazione e la deserializzazione in Java

Modello di progettazione del generatore in Java

Fonte: Medium In questo articolo impareremo come progettare e creare oggetti per una classe utilizzando il modello di progettazione Builder .

Perché abbiamo bisogno del modello di progettazione Builder?

Il modello Builder è progettato per creare oggetti utilizzando una classe statica pubblica annidata che dispone degli stessi campi dati della classe esterna. Il pattern Builder è stato creato per risolvere i problemi che erano presenti nei design pattern Factory e Abstract Factory quando un oggetto classe contiene molti valori di campo e/o dati. Prima di passare al pattern Builder , esaminiamo esattamente quali problemi sorgono con i pattern Factory e Abstract Factory per scenari in cui un oggetto ha molti valori di campo:

1. Avere troppi argomenti da passare dal programma client alla classe Factory può causare errori perché nella maggior parte dei casi il tipo di argomento è lo stesso ed è difficile mantenere l'ordine degli argomenti sul lato client.

2. Alcuni parametri possono essere facoltativi, ma nel modello Factory siamo costretti a inviare tutti i parametri e i parametri facoltativi devono essere inviati come file NULL .

3. Se l'oggetto è “pesante” e con un design complesso, tutte queste difficoltà entreranno a far parte delle classi Factory, il che spesso porta a confusione.

I problemi di cui sopra possono essere risolti quando l'oggetto ha un gran numero di parametri. Per fare ciò, devi semplicemente fornire al costruttore i parametri richiesti, e poi vari metodi setter per impostare i parametri opzionali. Tieni presente che il problema con questo metodo è che lo stato dell'oggetto rimarrà incoerente a meno che tutti gli attributi non siano impostati chiaramente.

Cos'è il modello di progettazione di Builder?

Il pattern Builder risolve il problema di avere molti parametri opzionali e stati incoerenti fornendo un modo per costruire un oggetto passo dopo passo. Questo utilizza un metodo che restituisce effettivamente l'oggetto finale.

Come implementare il modello di progettazione Builder in Java?

Se seguiamo i passaggi seguenti, otteniamo il processo passo passo per creare un oggetto e recuperarlo:

1. Creare una classe nidificata statica come classe Builder , quindi copiare tutti i campi dalla classe esterna alla classe Builder . Dobbiamo seguire una convenzione di denominazione, quindi se il nome della classe è Person , la classe Builder dovrebbe essere chiamata PersonBuilder .

2. La classe Builder deve avere un costruttore pubblico con tutti i campi obbligatori come parametri.

3. La classe Builder deve disporre di metodi per impostare i parametri facoltativi e deve restituire lo stesso oggetto Builder dopo aver impostato il campo facoltativo.

4. L'ultimo passo è fornire un metodo build() nella classe Builder , che restituirà l'oggetto necessario al programma client. Per fare ciò dobbiamo avere un costruttore privato nella classe principale con la classe Builder come argomento.

Esempio:

Diamo un'occhiata a un esempio per comprendere chiaramente il modello di progettazione di Builder .

public class Employee {

    private String name;
    private String company;
    private boolean hasCar;//optional
    private boolean hasBike;//optional

    private Employee(EmployeeBuilder employeeBuilder) {
        name = employeeBuilder.name;
        company = employeeBuilder.company;
        hasCar = employeeBuilder.hasCar;
        hasBike = employeeBuilder.hasBike;
    }

    public String getName() {
        return name;
    }

    public String getCompany() {
        return company;
    }

    public boolean isHasCar() {
        return hasCar;
    }

    public boolean isHasBike() {
        return hasBike;
    }

    public static class EmployeeBuilder {
        private String name;
        private String company;
        private boolean hasCar;//optional
        private boolean hasBike;//optional

        //constructor for required fields
        public EmployeeBuilder(String name, String company) {
            this.name = name;
            this.company = company;
        }

        //setter methods for optional fields
        public EmployeeBuilder setHasCar(boolean hasCar) {
            this.hasCar = hasCar;
            return this;
        }

        public EmployeeBuilder setHasBike(boolean hasBike) {
            this.hasBike = hasBike;
            return this;
        }

        //Build the Employee object
        public Employee build() {
            return new Employee(this);
        }
    }
}

class TestBuilder {
    public static void main(String[] args) {
        //Building the object of Employee thru the build() method provided in EmployeeBuilder class.
        Employee employee = new Employee.EmployeeBuilder("Vikram", "ABC").setHasBike(false).setHasBike(true).build();
    }
}

Esempio di pattern Builder : java.lang.StringBuilder e java.lang.StringBuffer hanno utilizzato il pattern Builder per creare oggetti.

Come funzionano la serializzazione e la deserializzazione in Java

Fonte: Medium Sono passato a Java nel gennaio di quest'anno dopo uno stage. Prima di questo, scrivevo principalmente in PHP e un po' in JavaScript. Non avevo mai incontrato la serializzazione prima, sebbene la serializzazione esista effettivamente in PHP. È vero, in Java viene utilizzato molto più spesso. Oggi ti presenterò come funzionano la serializzazione e la deserializzazione in Java e diversi modi per utilizzarle.

Che cosa sono la serializzazione e la deserializzazione

La serializzazione è la trasformazione di un oggetto da una classe in una sequenza di byte nella Java Virtual Machine (JVM) per la trasmissione a un'altra Java Virtual Machine. Se la Java Virtual Machine ricrea un oggetto da byte, il processo viene chiamato deserializzazione.

Esempio di serializzazione e deserializzazione

Serializzazione

Creiamo una classe il cui oggetto verrà serializzato:

import java.io.*;

public class Person implements Serializable{

int id = 0;
String name = "empty";

public Person(int identity, String nomenclature) {

name = nomenclature;
id = identity;
}
}

La classe Person implementa Serializable in modo che il suo oggetto possa essere serializzato/deserializzato. La classe Person ha due campi: identificatore e nome, che cambiano rispetto al valore predefinito quando viene creata un'istanza della classe. L'interfaccia Serializable e altre classi utilizzate nel programma sono state importate nel pacchetto Java.io.

public static void main(String[] args) throws FileNotFoundException, IOException {

String filename = "filename here";
Person person = new Person(1, "John");

// serialization
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(filename));

try {

out.writeObject(person);
System.out.println("Success");
} catch(Exception e) {

System.out.println("Unsuccessful");
} finally {

if(out != null) {

out.close();
}
}
}

Come sai, il metodo main avvia la serializzazione e stampa un messaggio di successo, altrimenti viene stampato un messaggio di errore. Per serializzare gli oggetti utilizziamo ObjectOutputStream e il metodo writeObject .

Deserializzazione

public static void main(String[] args) throws FileNotFoundException, IOException {

String filename = "filename here";
Person person = new Person(1, "John");

// Deserialization
ObjectInputStream in = new ObjectInputStream(new FileInputStream(filename));

try {

Person personObj = (Person)in.readObject();
System.out.println("Person Id is " +personObj.id + " while name is " + personObj.name);
} catch (Exception e) {

e.printStackTrace();
} finally {

if(in != null) {

in.close();
}
}
}

La deserializzazione è il contrario della serializzazione. Per ricostruire un oggetto da una sequenza di byte, utilizzare ObjectInputStream e il metodo readObject . Tieni presente che per fornire l'accesso ai campi nella classe Person , l'oggetto viene convertito nel tipo di dati Person . Un oggetto classe che non implementa l'interfaccia di serializzazione non può essere serializzato. Pertanto, qualsiasi classe che fa riferimento a una classe che implementa un'interfaccia di serializzazione deve essa stessa implementare l'interfaccia di serializzazione, altrimenti verrà generata un'eccezione. La serializzazione è indipendente dalla piattaforma, il che significa che il flusso di byte da serializzare può essere deserializzato da un'altra Java Virtual Machine. I campi statici e temporanei non sono serializzabili, quindi se hai un campo che non vuoi serializzare, rendilo temporaneo o statico. Nel caso di un campo statico, non viene serializzato perché un campo statico appartiene a una classe e non a un oggetto. Per questo motivo, lo stato di transizione impedisce la serializzazione del campo. La serializzazione viene utilizzata in Hibernate, JPA e RMI. La serializzazione può anche essere personalizzata. Questa si chiama serializzazione personalizzata.