จะหลีกเลี่ยงการทำซ้ำโครงสร้างข้อมูลเมื่อส่วนต่างของแอพเขียนเป็นภาษาอื่นได้อย่างไร

ตัวอย่างเช่นสมมติว่าคุณกำลังเขียนแอปในJava

ของแอปสื่อสารกับเซิร์ฟเวอร์ API เขียนในหลาม

เซิร์ฟเวอร์ Python สื่อสารกับฐานข้อมูลSQL

นอกจากนี้คุณยังมีเว็บไซต์ของแอปเขียนในJavaScript

ด้วย 4 ภาษาที่แตกต่างกันมันง่ายที่จะจบลงด้วยการทำซ้ำโครงสร้างข้อมูลเดิม 4 ครั้ง

ตัวอย่างเช่นUserประเภทอาจมีลักษณะเช่นนี้ (pseudocode):

type User {
  integer id;
  string name;
  timestamp birthday;
}

Userส่วนหนึ่งของโครงการทุกคนจะต้องชนิดของการแสดงบางอย่างสำหรับ ส่วนของ Java และ Python ต้องการclassการประกาศสองแบบที่ต่างกัน ฐานข้อมูลจะต้องมีUserการประกาศตาราง และเว็บไซต์ส่วนหน้าจะต้องเป็นตัวแทนUserด้วย

การทำซ้ำประเภทนี้ 4 ครั้งแตกต่างกันจริงๆแบ่งห้ามทำซ้ำ-Yourselfหลักการ นอกจากนี้ยังมีปัญหาที่หากUserมีการเปลี่ยนแปลงประเภทการเปลี่ยนแปลงเหล่านี้จำเป็นต้องทำซ้ำในทุกส่วนของโครงการ

ฉันรู้ว่าห้องสมุดprotobufของ Google นำเสนอวิธีการแก้ปัญหาที่คุณเขียนโครงสร้างข้อมูลโดยใช้ไวยากรณ์พิเศษจากนั้นห้องสมุดจะสร้างการประกาศโครงสร้างสำหรับคุณในภาษาการเขียนโปรแกรมหลายภาษา แต่สิ่งนี้ยังไม่ได้จัดการกับปัญหาของการต้องตรวจสอบตรรกะการตรวจสอบซ้ำสำหรับประเภทของคุณ

ไม่มีใครมีคำแนะนำหรือลิงค์ไปยังหนังสือ / บล็อกโพสต์เกี่ยวกับเรื่องนี้หรือไม่?

คุณทำไม่ได้. หรือจริงๆคุณไม่ควร

หากคุณนึกถึงแอปเซิร์ฟเวอร์และเว็บไซต์ของคุณเป็นบริบทที่แยกจากกันมันก็สมเหตุสมผลที่จะมีโครงสร้างที่ซ้ำกัน สาเหตุที่อาจเป็นสิ่งที่ดี:

• โครงสร้างคล้ายกัน แต่ไม่เหมือนกัน แม้ว่า 90% ของโครงสร้างจะเหมือนกันในทุกบริบท มันคือ 10% ที่จะทำให้คุณปวดหัวมาก
• รูปแบบและการใช้งานอาจแตกต่างกัน เมื่อมีการใช้ภาษาและกรอบงานที่แตกต่างกันมันจะกลายเป็นเรื่องยากเกินไปที่จะมีการใช้งานที่เหมือนกันในทุกภาษา
• โครงสร้างที่ใช้ร่วมกันกลายเป็นการพึ่งพาซึ่งต้องจัดการ การมีการพึ่งพาร่วมกันนั้นทำให้การพัฒนาซับซ้อนขึ้นอย่างมากเนื่องจากการเปลี่ยนแปลงที่ยิ่งใหญ่ในบริบทหนึ่งนั้นเป็นสิ่งที่น่ารังเกียจ ดังนั้นจึงจำเป็นต้องใช้ความพยายามอย่างมากในการประสานงานการพัฒนาการพึ่งพาที่ใช้ร่วมกันนี้
• บริบทที่แตกต่างกันมีการปรับใช้ที่แตกต่างกัน แม้ว่าคุณจะสามารถแบ่งปันโครงสร้างข้อมูลเดียวกันและรหัสการตรวจสอบเดียวกันในบริบททั้งหมดได้ แต่ก็ยังสามารถเกิดขึ้นได้ว่ามีการปรับใช้เวอร์ชันใหม่ของบริบทหนึ่งในขณะที่คนอื่นอยู่ในเวอร์ชันเก่าดังนั้นสถานการณ์ที่มีการซิงโครไนซ์ ได้รับการแก้ไข

ในขณะที่หลักการของ DRY นั้นยอดเยี่ยมฉันคิดว่าการแชร์โครงสร้างข้อมูลข้ามบริบทหรือเลเยอร์สร้างปัญหามากกว่าที่จะแก้ โดยเฉพาะอย่างยิ่งหากโครงการมีขนาดใหญ่พอที่คนอื่นจะทำงานในบริบทที่แตกต่างกัน

ฉันคิดว่า @Euphoric ระบุเหตุผลที่ดีสองประการที่จะไม่คัดลอกรหัสของคุณ อย่างไรก็ตามหากคุณต้องทำเช่นนั้นฉันขอแนะนำให้ใช้การสร้างรหัส

ค้นหารูปแบบที่เป็นที่ยอมรับของข้อมูล

ในการทำเช่นนั้นอย่างมีประสิทธิภาพคุณต้องค้นพบสิ่งที่เป็นรูปแบบมาตรฐานของข้อมูล มันเป็น SQL schema ของคุณหรือคลาสในโปรแกรม Java ของคุณ?

สืบทอดมา (โดยอัตโนมัติ) รูปแบบอื่น ๆ จากมัน

หลังจากนั้นให้หาวิธีสร้างรูปแบบอื่น ๆ ทั้งหมดจากแบบบัญญัติ ตัวอย่างเช่นสมมติว่ารูปแบบบัญญัติของคุณคือ SQL schema คุณสามารถสร้างรหัส JavaScript, Java และ Python จากที่ง่าย (SQL จะแยกวิเคราะห์ได้ง่ายและเป็นตัวเลือกที่ดีสำหรับแหล่งที่มาแบบบัญญัติ)

รองรับความแตกต่าง

ควรทำเครื่องหมายส่วนต่างๆของรหัสที่สร้างเป็น "อย่าแตะต้อง" - วิธีนี้คุณจะรองรับความแตกต่างที่จำเป็นระหว่างการแสดงที่ต่างกันทั้งหมด (ตัวอย่างเช่น: รหัสที่กำหนดเองที่คุณเขียนสำหรับ JS frontend และแบ็กเอนด์ Java) จำเป็นต้องได้รับการเก็บรักษาไว้ตลอดการฟื้นฟู
นำตัวอย่างจาก Git; เมื่อเปิดโปรแกรมแก้ไขเพื่อให้คุณป้อนกระทำข้อความไฟล์ที่มีอยู่แล้วมีข้อความบางอย่าง แต่มันมี# -------- >8 --------เครื่องหมายที่จะทราบว่าคุณปลายเนื้อหาและที่ของข้อความที่สร้างขึ้นโดยอัตโนมัติเริ่มต้น

ยังถ้าคุณสามารถ - หลีกเลี่ยงการทำซ้ำดังกล่าว มันเป็น PITA แม้ว่ารหัสส่วนใหญ่ของคุณจะถูกสร้างขึ้นโดยอัตโนมัติ

คำตอบนี้เป็นเรื่องเล่าสักระยะแทนที่จะเป็น "นี่คือแนวทางปฏิบัติที่ดีที่สุด" - สิ่งที่ฉันอธิบายคือสิ่งที่ฉันเคยทำเมื่อฉันมีปัญหาเดียวกับคุณและต้องการให้มีข้อมูลเดียวกันแสดงในส่วนต่าง ๆ ของระบบ (หรือค่อนข้างในสองระบบที่แตกต่างกัน)