คอฟฟี่เบรค #124. รูปแบบการออกแบบของผู้สร้าง Serialization และ Deserialization ทำงานอย่างไรใน Java

รูปแบบการออกแบบตัวสร้างใน Java

ที่มา: สื่อ ในบทความนี้ เราจะเรียนรู้วิธีการออกแบบและสร้างอ็อบเจ็กต์สำหรับคลาสโดยใช้ รูป แบบ การออกแบบ Builder

เหตุใดเราจึงต้องมีรูปแบบการออกแบบของ Builder

รูปแบบBuilderได้รับการออกแบบมาเพื่อสร้างอ็อบเจ็กต์โดยใช้คลาสสแตติกสาธารณะแบบซ้อนซึ่งมีช่องข้อมูลเดียวกันกับคลาสภายนอก รูปแบบBuilderถูกสร้างขึ้นเพื่อแก้ไขปัญหาที่มีอยู่ใน รูปแบบการออกแบบ FactoryและAbstract Factoryเมื่อคลาสอ็อบเจ็กต์มีค่าฟิลด์และ/หรือข้อมูลจำนวนมาก ก่อนที่เราจะไปยัง รูปแบบ Builderเรามาดูปัญหาที่เกิดขึ้นกับ รูปแบบ FactoryและAbstract Factory กันก่อน สำหรับสถานการณ์ที่ออบเจ็กต์มีค่าฟิลด์หลายค่า:

1. การมีอาร์กิวเมนต์มากเกินไปที่จะส่งผ่านจากโปรแกรมไคลเอ็นต์ไปยัง คลาส Factoryอาจทำให้เกิดข้อผิดพลาดได้ เนื่องจากโดยส่วนใหญ่แล้วประเภทอาร์กิวเมนต์จะเหมือนกัน และเป็นการยากที่จะรักษาลำดับของอาร์กิวเมนต์ในฝั่งไคลเอ็นต์

2. พารามิเตอร์บางตัวอาจเป็นทางเลือก แต่ใน รูปแบบ โรงงานเราถูกบังคับให้ส่งพารามิเตอร์ทั้งหมด และพารามิเตอร์ทางเลือกจะต้องส่งเป็นไฟล์NULL

3. หากวัตถุนั้น "หนัก" และมีการออกแบบที่ซับซ้อน ปัญหาทั้งหมดเหล่านี้จะกลายเป็นส่วนหนึ่งของคลาส Factory ซึ่งมักจะนำไปสู่ความสับสน

ปัญหาข้างต้นสามารถแก้ไขได้เมื่อวัตถุมีพารามิเตอร์จำนวนมาก ในการดำเนินการนี้ คุณเพียงแค่ต้องจัดเตรียมพารามิเตอร์ที่จำเป็นให้กับตัวสร้าง จากนั้นจึงระบุ วิธี การตั้งค่า ต่างๆ เพื่อตั้งค่าพารามิเตอร์ทางเลือก โปรดทราบว่าปัญหาของวิธีนี้คือสถานะของออบเจ็กต์จะยังคงไม่สอดคล้องกันเว้นแต่จะตั้งค่าแอตทริบิวต์ทั้งหมดไว้อย่างชัดเจน

รูปแบบการออกแบบของ Builder คืออะไร?

รูปแบบBuilderแก้ปัญหาการมีพารามิเตอร์ทางเลือกจำนวนมากและสถานะที่ไม่สอดคล้องกันโดยจัดเตรียมวิธีสร้างออบเจ็กต์ทีละขั้นตอน วิธีนี้ใช้วิธีที่ส่งคืนออบเจ็กต์สุดท้ายจริง ๆ

จะใช้รูปแบบการออกแบบ Builder ใน Java ได้อย่างไร

หากเราทำตามขั้นตอนด้านล่าง เราจะได้กระบวนการสร้างอ็อบเจ็กต์ทีละขั้นตอนและรับมันมา:

1. สร้างคลาสที่ซ้อนกันแบบคงที่เป็น คลาส Builderจากนั้นคัดลอกฟิลด์ทั้งหมดจากคลาสภายนอกไปยังคลาสBuilder เราต้องปฏิบัติตามหลักการตั้งชื่อ ดังนั้นหากชื่อคลาสคือPerson คลาส Builder ก็ควรจะเรียกว่าPersonBuilder

2. คลาสBuilderต้องมีตัวสร้างสาธารณะพร้อมฟิลด์ที่จำเป็นทั้งหมดเป็นพารามิเตอร์

3. คลาสBuilderต้องมีเมธอดในการตั้งค่าพารามิเตอร์ทางเลือก และจะต้องส่งคืน อ็อบเจ็กต์ Builder เดียวกัน หลังจากตั้งค่าฟิลด์ทางเลือก

4. ขั้นตอนสุดท้ายคือการจัดเตรียม เมธอด build()ใน คลาส Builderซึ่งจะส่งคืนอ็อบเจ็กต์ที่โปรแกรมไคลเอนต์ต้องการ ในการทำเช่นนี้ เราจำเป็นต้องมี Constructor ส่วนตัวในคลาสหลักโดยมี คลาส Builderเป็นอาร์กิวเมนต์

ตัวอย่าง:

ลองดูตัวอย่างเพื่อทำความเข้าใจรูป แบบการ ออกแบบ 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();
    }
}

ตัวอย่าง รูปแบบ Builder : java.lang.StringBuilderและjava.lang.StringBufferใช้ รูปแบบ Builderเพื่อสร้างอ็อบเจ็กต์

Serialization และ Deserialization ทำงานอย่างไรใน Java

ที่มา: ปานกลาง ฉันเปลี่ยนมาใช้ Java ในเดือนมกราคมของปีนี้หลังจากการฝึกงาน ก่อนหน้านี้ฉันเขียนด้วย PHP และ JavaScript นิดหน่อยเป็นส่วนใหญ่ ฉันไม่เคยพบกับการทำให้เป็นอนุกรมมาก่อน แม้ว่าการทำให้เป็นอนุกรมจะมีอยู่ใน PHP ก็ตาม จริงอยู่ใน Java มีการใช้บ่อยกว่ามาก วันนี้ผมจะแนะนำให้คุณรู้จักกับวิธีการทำงานของซีเรียลไลซ์เซชั่นและดีซีเรียลไลซ์เซชั่นใน Java และวิธีการใช้งานต่างๆ มากมาย

การทำให้เป็นอนุกรมและดีซีเรียลไลซ์คืออะไร

การทำให้เป็นอนุกรมคือการแปลงอ็อบเจ็กต์จากคลาสให้เป็นลำดับไบต์ใน Java Virtual Machine (JVM) เพื่อถ่ายโอนไปยัง Java Virtual Machine อื่น ถ้า Java Virtual Machine สร้างอ็อบเจ็กต์ขึ้นใหม่จากไบต์ กระบวนการนี้เรียกว่าดีซีเรียลไลซ์เซชัน

ตัวอย่างของการทำให้เป็นอนุกรมและดีซีเรียลไลซ์

การทำให้เป็นอนุกรม

มาสร้างคลาสที่วัตถุจะถูกทำให้เป็นอนุกรม:

import java.io.*;

public class Person implements Serializable{

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

public Person(int identity, String nomenclature) {

name = nomenclature;
id = identity;
}
}

คลาสPersonใช้Serializableเพื่อให้อ็อบเจ็กต์สามารถซีเรียลไลซ์/ดีซีเรียลไลซ์ได้ คลาสPersonมีสองฟิลด์: ตัวระบุและชื่อ ซึ่งเปลี่ยนจากค่าเริ่มต้นเมื่อมีการสร้างอินสแตนซ์ของคลาส อินเทอร์เฟซ แบบอนุกรมและคลาสอื่น ๆ ที่ใช้ในโปรแกรม ถูกนำเข้าไปยัง แพ็คเกจ 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();
}
}
}

ดังที่คุณทราบ วิธีการหลักจะเริ่มซีเรียลไลซ์และพิมพ์ข้อความแสดงความสำเร็จ ไม่เช่นนั้นข้อความแสดงข้อผิดพลาดจะถูกพิมพ์ออกมา ในการทำให้ วัตถุ เป็นอนุกรม เราใช้ObjectOutputStreamและ เมธอด writeObject

ดีซีเรียลไลเซชัน

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

การดีซีเรียลไลเซชันเป็นสิ่งที่ตรงกันข้ามกับการซีเรียลไลซ์ หากต้องการสร้าง วัตถุขึ้นใหม่จากลำดับไบต์ ให้ใช้ObjectInputStreamและ เมธอด readObject โปรดทราบว่าเพื่อ ให้สามารถเข้าถึงฟิลด์ใน คลาส Person ออบเจ็กต์จะถูกส่งไปยัง ประเภทข้อมูลPerson คลาสอ็อบเจ็กต์ที่ไม่ได้ใช้อินเทอร์เฟซการทำให้เป็นอนุกรมไม่สามารถทำให้เป็นอนุกรมได้ ดังนั้นคลาสใดๆ ที่อ้างอิงคลาสที่ใช้อินเทอร์เฟซการทำให้เป็นอนุกรมจะต้องใช้อินเทอร์เฟซการทำให้เป็นอนุกรมด้วยตนเอง มิฉะนั้นจะเกิดข้อยกเว้น การทำให้ซีเรียลไลซ์เป็นแพลตฟอร์มที่ไม่ขึ้นกับใคร ซึ่งหมายความว่าสตรีมไบต์ที่กำลังซีเรียลไลซ์สามารถดีซีเรียลไลซ์ได้ด้วย Java Virtual Machine เครื่องอื่น ฟิลด์แบบคงที่และแบบชั่วคราวไม่สามารถทำให้เป็นอนุกรมได้ ดังนั้น หากคุณมีฟิลด์ที่คุณไม่ต้องการทำให้เป็นอนุกรม ให้ทำให้เป็นแบบชั่วคราวหรือแบบคงที่ ในกรณีของฟิลด์คงที่ จะไม่ถูกทำให้เป็นอนุกรมเนื่องจากฟิลด์คงที่เป็นของคลาสและไม่ใช่วัตถุ ด้วยเหตุนี้ สถานะการเปลี่ยนจึงป้องกันไม่ให้ฟิลด์ถูกทำให้เป็นอนุกรม การทำให้เป็นอนุกรมใช้ใน Hibernate, JPA และ RMI การทำให้เป็นอนุกรมยังสามารถปรับแต่งได้ สิ่งนี้เรียกว่าการทำให้เป็นอนุกรมแบบกำหนดเอง