ฉันไม่ได้อยู่ในสถานการณ์ที่ข้อผิดพลาดของคอมไพเลอร์ที่เกิดจากคำหลักเหล่านี้จะช่วยฉันจากข้อผิดพลาด
ไม่มากนักที่จะบันทึกผู้สร้างแอปพลิเคชันจากข้อบกพร่องเพื่อให้ผู้เขียนห้องสมุดตัดสินใจว่าส่วนใดของการใช้งานที่พวกเขากำลังมุ่งมั่นที่จะรักษาไว้
ถ้าฉันมีห้องสมุด
class C {
public void foo() { ... }
private void fooHelper() { /* lots of complex code */ }
}
ฉันอาจต้องการเปลี่ยนfoo
การใช้งานและอาจเปลี่ยนไปfooHelper
ในทางที่รุนแรง หากกลุ่มคนตัดสินใจใช้fooHelper
แม้จะมีคำเตือนทั้งหมดในเอกสารของฉันฉันก็อาจไม่สามารถทำได้
private
ช่วยให้ผู้เขียนห้องสมุดแบ่งห้องสมุดออกเป็นวิธีที่สามารถจัดการได้ (และprivate
คลาสผู้ช่วย) โดยไม่ต้องกลัวว่าพวกเขาจะถูกบังคับให้รักษารายละเอียดภายในเหล่านั้นไว้เป็นเวลาหลายปี
อะไรจะทำให้คุ้มค่าสำหรับคอมไพเลอร์ในการบังคับใช้การซ่อนข้อมูล?
สังเกตด้านบนใน Java private
ไม่ได้บังคับใช้โดยคอมไพเลอร์ แต่โดย Java ตรวจสอบ bytecode
การสะท้อนกลับสามารถแทนที่กลไกนี้ได้หรือไม่? อะไรจะทำให้คุ้มค่าสำหรับคอมไพเลอร์ในการบังคับใช้การซ่อนข้อมูล?
ใน Java การสะท้อนไม่เพียง แต่สามารถแทนที่กลไกนี้ private
Java มีสองชนิด ชนิดprivate
ที่ป้องกันไม่ให้คลาสภายนอกหนึ่งเข้าถึงprivate
สมาชิกนอกคลาสอื่นที่ถูกตรวจสอบโดยตัวตรวจสอบ bytecode แต่ยังprivate
s ที่ใช้โดยคลาสภายในผ่านวิธีการเข้าถึงแพคเกจสังเคราะห์ส่วนตัวเช่นใน
public class C {
private int i = 42;
public class B {
public void incr() { ++i; }
}
}
ตั้งแต่คลาสB
(ชื่อจริง ๆC$B
) ใช้i
คอมไพเลอร์สร้างวิธีB
การเข้าถึงสังเคราะห์ที่ช่วยให้การเข้าถึงC.i
ในทางที่จะผ่าน bytecode verifier น่าเสียดายเนื่องจากClassLoader
อนุญาตให้คุณสร้างคลาสจาก a byte[]
จึงเป็นเรื่องง่ายที่จะได้รับสิทธิ์ส่วนตัวที่C
ได้สัมผัสกับคลาสภายในโดยการสร้างคลาสใหม่ในC
แพ็คเกจของซึ่งเป็นไปได้หากC
ไม่ได้ปิดผนึกขวด
การprivate
บังคับใช้ที่เหมาะสมต้องการการประสานงานระหว่าง classloaders, ตัวตรวจสอบ bytecode และนโยบายความปลอดภัยที่สามารถป้องกันการเข้าถึงแบบไตร่ตรอง
มันสามารถใช้เพื่อป้องกันสถานะลับของชั้นเรียนจากการถูกโจมตีหรือไม่?
ใช่. "การสลายตัวแบบปลอดภัย" เป็นไปได้เมื่อโปรแกรมเมอร์สามารถทำงานร่วมกันได้ในขณะที่การรักษาคุณสมบัติความปลอดภัยของโมดูลแต่ละตัว - ฉันไม่จำเป็นต้องเชื่อถือผู้เขียนโมดูลรหัสอื่นที่จะไม่ละเมิดคุณสมบัติความปลอดภัยของโมดูลของฉัน
ภาษาที่มีความสามารถในวัตถุเช่นJoe-Eใช้การซ่อนข้อมูลและวิธีการอื่นเพื่อทำให้การย่อยสลายอย่างปลอดภัยเป็นไปได้:
Joe-E เป็นส่วนย่อยของภาษาการเขียนโปรแกรม Java ที่ออกแบบมาเพื่อสนับสนุนการเขียนโปรแกรมที่ปลอดภัยตามระเบียบวินัยความสามารถของวัตถุ Joe-E มีวัตถุประสงค์เพื่ออำนวยความสะดวกในการสร้างระบบความปลอดภัยเช่นเดียวกับการอำนวยความสะดวกในการตรวจสอบความปลอดภัยของระบบที่สร้างขึ้นใน Joe-E
กระดาษที่เชื่อมโยงจากหน้านั้นเป็นตัวอย่างของการprivate
บังคับใช้ที่ทำให้เกิดการสลายตัวที่ปลอดภัย
ให้การห่อหุ้มที่ปลอดภัย
รูปที่ 1. เครื่องมือช่วยการบันทึกข้อมูลแบบผนวกเท่านั้น
public final class Log {
private final StringBuilder content;
public Log() {
content = new StringBuilder();
}
public void write(String s) {
content.append(s);
}
}
พิจารณารูปที่ 1 ซึ่งแสดงวิธีที่หนึ่งอาจสร้างเครื่องมืออำนวยความสะดวกการบันทึกต่อท้ายเท่านั้น หากส่วนที่เหลือของโปรแกรมเขียนใน Joe-E ผู้ตรวจสอบรหัสสามารถกำหนดได้ว่าสามารถเพิ่มรายการบันทึกได้เท่านั้นและไม่สามารถแก้ไขหรือลบออกได้ การตรวจสอบนี้มีประโยชน์เพราะต้องการการตรวจสอบLog
ชั้นเรียนเท่านั้นและไม่ต้องการการตรวจสอบรหัสอื่นใด ดังนั้นการตรวจสอบคุณสมบัตินี้จึงจำเป็นต้องใช้เหตุผลในท้องถิ่นเกี่ยวกับรหัสการบันทึกเท่านั้น