รูปแบบการออกแบบตัวสร้างใน Java
ที่มา: สื่อ ในบทความนี้ เราจะเรียนรู้วิธีการออกแบบและสร้างอ็อบเจ็กต์สำหรับคลาสโดยใช้ รูป แบบ การออกแบบ Builderเหตุใดเราจึงต้องมีรูปแบบการออกแบบของ Builder
รูปแบบBuilderได้รับการออกแบบมาเพื่อสร้างอ็อบเจ็กต์โดยใช้คลาสสแตติกสาธารณะแบบซ้อนซึ่งมีช่องข้อมูลเดียวกันกับคลาสภายนอก รูปแบบBuilderถูกสร้างขึ้นเพื่อแก้ไขปัญหาที่มีอยู่ใน รูปแบบการออกแบบ FactoryและAbstract Factoryเมื่อคลาสอ็อบเจ็กต์มีค่าฟิลด์และ/หรือข้อมูลจำนวนมาก ก่อนที่เราจะไปยัง รูปแบบ Builderเรามาดูปัญหาที่เกิดขึ้นกับ รูปแบบ FactoryและAbstract Factory กันก่อน สำหรับสถานการณ์ที่ออบเจ็กต์มีค่าฟิลด์หลายค่า:-
การมีอาร์กิวเมนต์มากเกินไปที่จะส่งผ่านจากโปรแกรมไคลเอ็นต์ไปยัง คลาส Factoryอาจทำให้เกิดข้อผิดพลาดได้ เนื่องจากโดยส่วนใหญ่แล้วประเภทอาร์กิวเมนต์จะเหมือนกัน และเป็นการยากที่จะรักษาลำดับของอาร์กิวเมนต์ในฝั่งไคลเอ็นต์
-
พารามิเตอร์บางตัวอาจเป็นทางเลือก แต่ใน รูปแบบ โรงงานเราถูกบังคับให้ส่งพารามิเตอร์ทั้งหมด และพารามิเตอร์ทางเลือกจะต้องส่งเป็นไฟล์NULL
-
หากวัตถุนั้น "หนัก" และมีการออกแบบที่ซับซ้อน ปัญหาทั้งหมดเหล่านี้จะกลายเป็นส่วนหนึ่งของคลาส Factory ซึ่งมักจะนำไปสู่ความสับสน
รูปแบบการออกแบบของ Builder คืออะไร?
รูปแบบBuilderแก้ปัญหาการมีพารามิเตอร์ทางเลือกจำนวนมากและสถานะที่ไม่สอดคล้องกันโดยจัดเตรียมวิธีสร้างออบเจ็กต์ทีละขั้นตอน วิธีนี้ใช้วิธีที่ส่งคืนออบเจ็กต์สุดท้ายจริง ๆจะใช้รูปแบบการออกแบบ Builder ใน Java ได้อย่างไร
หากเราทำตามขั้นตอนด้านล่าง เราจะได้กระบวนการสร้างอ็อบเจ็กต์ทีละขั้นตอนและรับมันมา:-
สร้างคลาสที่ซ้อนกันแบบคงที่เป็น คลาส Builderจากนั้นคัดลอกฟิลด์ทั้งหมดจากคลาสภายนอกไปยังคลาสBuilder เราต้องปฏิบัติตามหลักการตั้งชื่อ ดังนั้นหากชื่อคลาสคือPerson คลาส Builder ก็ควรจะเรียกว่าPersonBuilder
-
คลาสBuilderต้องมีตัวสร้างสาธารณะพร้อมฟิลด์ที่จำเป็นทั้งหมดเป็นพารามิเตอร์
-
คลาสBuilderต้องมีเมธอดในการตั้งค่าพารามิเตอร์ทางเลือก และจะต้องส่งคืน อ็อบเจ็กต์ Builder เดียวกัน หลังจากตั้งค่าฟิลด์ทางเลือก
-
ขั้นตอนสุดท้ายคือการจัดเตรียม เมธอด 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 การทำให้เป็นอนุกรมยังสามารถปรับแต่งได้ สิ่งนี้เรียกว่าการทำให้เป็นอนุกรมแบบกำหนดเอง
GO TO FULL VERSION