Coffee break #124. Pattern ng disenyo ng tagabuo. Paano Gumagana ang Serialization at Deserialization sa Java

Pattern ng disenyo ng tagabuo sa Java

Source: Medium Sa artikulong ito, matututunan natin kung paano magdisenyo at gumawa ng mga bagay para sa isang klase gamit ang pattern ng disenyo ng Builder .

Bakit natin kailangan ang pattern ng disenyo ng Tagabuo?

Ang pattern ng Tagabuo ay idinisenyo upang lumikha ng mga bagay gamit ang isang nested pampublikong static na klase na may parehong mga field ng data gaya ng panlabas na klase. Ang Builder pattern ay nilikha upang malutas ang mga problema na naroroon sa Factory at Abstract Factory na mga pattern ng disenyo kapag ang isang class object ay naglalaman ng maraming field value at/o data. Bago tayo magpatuloy sa Builder pattern , tingnan natin kung anong mga problema ang lumitaw sa mga pattern ng Factory at Abstract Factory para sa mga sitwasyon kung saan ang isang object ay may maraming field value:

1. Ang pagkakaroon ng napakaraming argumento na ipapasa mula sa programa ng kliyente patungo sa klase ng Pabrika ay maaaring magdulot ng mga error dahil kadalasan ang uri ng argumento ay pareho at mahirap panatilihin ang pagkakasunud-sunod ng mga argumento sa panig ng kliyente.

2. Ang ilang mga parameter ay maaaring opsyonal, ngunit sa Factory pattern napipilitan kaming ipadala ang lahat ng mga parameter, at ang mga opsyonal na parameter ay dapat ipadala bilang NULL file .

3. Kung ang bagay ay "mabigat" at may kumplikadong disenyo, kung gayon ang lahat ng mga paghihirap na ito ay magiging bahagi ng mga klase ng Pabrika, na kadalasang humahantong sa pagkalito.

Ang mga problema sa itaas ay maaaring malutas kapag ang bagay ay may malaking bilang ng mga parameter. Upang gawin ito, kailangan mo lamang ibigay ang tagapagbuo ng mga kinakailangang parameter, at pagkatapos ay iba't ibang paraan ng setter upang itakda ang mga opsyonal na parameter. Tandaan na ang problema sa pamamaraang ito ay ang estado ng bagay ay mananatiling hindi naaayon maliban kung ang lahat ng mga katangian ay malinaw na nakatakda.

Ano ang pattern ng disenyo ng Tagabuo?

Ang Builder pattern ay nilulutas ang problema ng pagkakaroon ng maraming opsyonal na parameter at hindi pare-parehong estado sa pamamagitan ng pagbibigay ng paraan upang bumuo ng isang bagay nang sunud-sunod. Gumagamit ito ng isang paraan na aktwal na nagbabalik ng panghuling bagay.

Paano ipatupad ang pattern ng disenyo ng Tagabuo sa Java?

Kung susundin namin ang mga hakbang sa ibaba, makukuha namin ang hakbang-hakbang na proseso ng paglikha ng isang bagay at pagkuha nito:

1. Lumikha ng isang static na nested na klase bilang klase ng Tagabuo , at pagkatapos ay kopyahin ang lahat ng mga patlang mula sa panlabas na klase patungo sa klase ng Tagabuo . Kailangan nating sundin ang isang kombensyon ng pagbibigay ng pangalan, kaya kung ang pangalan ng klase ay Person , kung gayon ang klase ng Builder ay dapat tawaging PersonBuilder .

2. Ang klase ng Tagabuo ay dapat magkaroon ng pampublikong tagapagbuo na may lahat ng kinakailangang mga patlang bilang mga parameter.

3. Ang klase ng Builder ay dapat may mga pamamaraan upang itakda ang mga opsyonal na parameter, at dapat itong ibalik ang parehong object ng Builder pagkatapos itakda ang opsyonal na field.

4. Ang huling hakbang ay ang magbigay ng build() na paraan sa Builder class , na magbabalik ng object na kailangan ng client program. Para magawa ito kailangan nating magkaroon ng pribadong constructor sa pangunahing klase na may Builder class bilang argumento.

Halimbawa:

Tingnan natin ang isang halimbawa upang makakuha ng malinaw na pag-unawa sa pattern ng disenyo ng Tagabuo .

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

Halimbawa ng Builder pattern : java.lang.StringBuilder at java.lang.StringBuffer ay ginamit ang Builder pattern upang bumuo ng mga bagay.

Paano Gumagana ang Serialization at Deserialization sa Java

Source: Medium Lumipat ako sa Java noong Enero ng taong ito pagkatapos ng internship. Bago ito, karamihan ay sumulat ako sa PHP at isang maliit na JavaScript. Hindi pa ako nakatagpo ng serialization bago, kahit na ang serialization ay aktwal na umiiral sa PHP. Totoo, sa Java ito ay ginagamit nang mas madalas. Ngayon ay ipapakilala ko sa iyo kung paano gumagana ang serialization at deserialization sa Java at ilang paraan para magamit ang mga ito.

Ano ang serialization at deserialization

Ang serialization ay ang pagbabago ng isang bagay mula sa isang klase patungo sa pagkakasunod-sunod ng mga byte sa Java Virtual Machine (JVM) para sa paghahatid sa isa pang Java Virtual Machine. Kung muling likhain ng Java Virtual Machine ang isang bagay mula sa mga byte, ang proseso ay tinatawag na deserialization.

Halimbawa ng serialization at deserialization

Serialization

Gumawa tayo ng isang klase na ang object ay isa-serialize:

import java.io.*;

public class Person implements Serializable{

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

public Person(int identity, String nomenclature) {

name = nomenclature;
id = identity;
}
}

Ang klase ng Tao ay nagpapatupad ng Serializable upang ang object nito ay ma-serialize/deserialized. Ang klase ng Tao ay may dalawang field: identifier at pangalan, na nagbabago mula sa default na halaga kapag nilikha ang isang instance ng klase. Ang Serializable interface at iba pang klase na ginamit sa programa ay na-import sa Java.io package.

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

Tulad ng alam mo, ang pangunahing paraan ay nagsisimula sa serialization at nagpi-print ng isang mensahe ng tagumpay, kung hindi, isang mensahe ng error ay naka-print. Upang i-serialize ang mga bagay ginagamit namin ang ObjectOutputStream at ang writeObject method .

Deserialization

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

Ang deserialization ay ang kabaligtaran ng serialization. Upang muling buuin ang isang bagay mula sa isang pagkakasunud-sunod ng mga byte, gamitin ang ObjectInputStream at ang readObject method . Tandaan na para makapagbigay ng access sa mga field sa klase ng Tao , ang object ay inihagis sa Person data type . Ang isang object ng klase na hindi nagpapatupad ng serialization interface ay hindi maaaring serialized. Samakatuwid, ang anumang klase na tumutukoy sa isang klase na nagpapatupad ng serialization interface ay dapat mismong magpatupad ng serialization interface, kung hindi, isang exception ang itatapon. Ang serialization ay independiyente sa platform, ibig sabihin ang byte stream na ini-serialize ay maaaring deserialized ng isa pang Java Virtual Machine. Ang mga static at transient na field ay hindi serializable, kaya kung mayroon kang field na hindi mo gustong i-serialize, gawin itong pansamantala o static. Sa kaso ng isang static na field, hindi ito serialized dahil ang isang static na field ay kabilang sa isang klase at hindi isang object. Dahil dito, pinipigilan ng transition state ang field na maging serialized. Ginagamit ang serialization sa Hibernate, JPA at RMI. Maaari ding i-customize ang serialization. Ito ay tinatawag na custom serialization.