מהו המושג סידור ב- Java?

סידור ב הוא מושג חשוב העוסק בהמרה של אובייקטים לזרם בתים כדי להעביר את אובייקטים של Java ממכונה אחת של Java למחשב השני ולשחזר אותם לצורה המקורית. אסדר את המסמך למאמר זה להלן:

• מהי סידור ב- Java?
• מדוע אנו זקוקים לסידור ב- Java?
• כיצד אנו מבצעים סדרת אובייקט?
• יתרונות וחסרונות של סידור ב- Java
• דוגמאות מעשיות לסידור ב- Java
• ממשק להחלפה
• מילת מפתח חולפת
• גרסה טורית UID
• מחלוקות על סידור ב- Java
• שיטות עבודה מומלצות בעת שימוש בסידור ב- Java

מהי סידור ב- Java?

סידור ב- Java הוא תהליך המרת קוד Java לְהִתְנַגֵד לתוך זרם בתים , להעביר את קוד האובייקט ממכונת Java וירטואלית אחת לאחרת ולשחזר אותו באמצעות התהליך של התפטרות.

מדוע אנו זקוקים לסידור בג'אווה ?

אנו זקוקים לסידור מחדש מהסיבות הבאות:

• תִקשׁוֹרֶת : סידור כולל את הליך האובייקט סידור ו הפצה. זה מאפשר למספר מערכות מחשב לתכנן, לשתף ולבצע אובייקטים בו זמנית.

• מטמון : הזמן הנדרש לבניית אובייקט הוא יותר בהשוואה לזמן הנדרש להסרת סדרתו. סידור ממזער את צריכת הזמן עד מטמון חפצי הענק.

• העתק עמוק : שיבוט התהליך נעשה פשוט באמצעות Serialization. מדויק הֶעתֵק מְדוּיָק של אובייקט מתקבל על ידיסדרת האובייקט ל- a מערך בתים ולאחר מכן לבטל את הסדרה מחדש.

  
  
  

  כיצד להתקין php ב - Windows 7

• לַחֲצוֹת סנכרון JVM: היתרון העיקרי של סידור זה שהואעובד על פני JVM שונים שעשויים לרוץ על שונים אדריכלות אוֹ מערכות הפעלה

• הַתמָדָה: ניתן לאחסן את מדינתו של כל אובייקט ישירות על ידי החלת Serialization עליו ולאחסנה ב- מאגר מידע כדי שזה יכול להיות אוחזר מאוחר יותר.

כיצד אנו מבצעים סדרת אובייקט?

ל אובייקט Java הוא ניתן לסדר אם ורק אם המחלקה שלה או כל אחת משכבות ההורה שלה מיישמות את ג'אווה . אני . ניתן לסידור ממשק או ממשק המשנה שלו, java.io. ניתן להחצנה.

בתהליך הסידור, אנו ממירים את מצב האובייקט לזרם בתים כך שניתן יהיה להעביר אותו מ- JVM אחד למשנהו ולהחזיר את זרם הבתים לאובייקט המקורי.

//מִמְשָׁק

חבילה Serial1 יבוא java.io. מחלקה ציבורית ניתן לסידור ניתן ליישומי Serializable {פרטי סטטי פרטי סופי ארוך ארוךVersionUID = 1L // גרסה סדרתית UID int מזהה שם מחרוזת עובד עובד (int מזהה, שם מחרוזת) {this.id = id this.name = שם }}

// סדר סדר

חבילה Serial1 יבוא java.io. * class מתמיד {public static void main (String args []) {try {עובד emp1 = עובד חדש (20110, 'ג'ון') עובד emp2 = עובד חדש (22110, 'ג'רי') עובד emp3 = עובד חדש (20120, 'סם') FileOutputStream fout = FileOutputStream חדש ('output.txt') ObjectOutputStream out = ObjectOutputStream חדש (fout) out.writeObject (emp1) out.writeObject (emp2) out.writeObject (emp3) out. flush () out.close () System.out.println ('Serialization and Deserialization was executed בהצלחה')} catch (Exception e) {System.out.println (e)}}}

תְפוּקָה:

הסידור וההתעללות מבוצע בהצלחה

התפטרות : זהו התהליך ההפוך של סידור שבו זרם בתים סידורי של אובייקט מהשולח נוצר בקצה המקבל.

// התפטר

חבילה Serial1 יבוא java.io. * class Depersist {public static void main (String args []) {try {ObjectInputStream in = new ObjectInputStream (FileInputStream new ('output.txt')) עובד e1 = (עובד) ב-readObject ( ) עובד e2 = (עובד) in.readObject () עובד e3 = (עובד) in.readObject () System.out.println (e1.id + '' + e1.name) System.out.println (e2.id + '' + e2.name) System.out.println (e3.id + '' + e3.name) in.close ()} לתפוס (Exception e) {System.out.println (e)}}}

תְפוּקָה:

20110 ג'ון
22110 ג'רי

20120 סם

יתרונות וחסרונות של סידור ב- Java

יתרונות:

• תהליך הסידור הוא מובנה תכונה שאינה מחייבת תוכנת צד שלישי כדי לבצע את הסידור

• הוכח כי הליך הסידור הוא פָּשׁוּט ו קַל להבין

• הליך הסידור הוא אוניברסלי ומפתחים מרקע שונה מוכרים לו

• זה קל לשימוש ו פשוט להתאמה אישית

• זרמי נתונים בסידור תומך בהצפנה, דחיסה, אימות ו מחשוב Java מאובטח

• יש הרבה טכנולוגיות קריטיות בהסתמך על סידור.

חסרונות:

• אובייקטים בזמן שדה-סריאליזציה הופך להיות שָׁבִיר והם לא בטוחים שיעברו דה-סריאליזציה יעילה.

• המשתנים החולפים שהוכרזו בזמן סידרה יוצרים מרחב זיכרון, אך לא קוראים לבנאי מה שמביא לכשל באתחול של משתנים חולפים וכתוצאה מכך וריאציה לזרימת Java הרגילה.

• תהליך הסידור הוא לֹא יָעִיל מבחינת ניצול הזיכרון.

• לא עדיף להשתמש בסידור ביישומים הדרושים גישה במקביל ללא הדרישה של ממשקי API של צד שלישי , מכיוון ש- Serialization אינו מציע כל מנגנון בקרת מעבר בכל SE.

• הליך הסידור אינו מוצע שליטה דקה כדי לגשת לחפצים.

דוגמאות מעשיות לסידור ב- Java

• סידור באמצעות ירושה
• סידור באמצעות חבר סטטי

סידור באמצעות ירושה

מקרה 1: אם ניתן לסדר את Superclass, כברירת מחדל, ניתן לסדר את מחלקות המשנה שלו.

במקרה זה, תת מחלקה ניתן לסידור כברירת מחדל אם מעמד-על מיישם את ממשק ניתן לסידור

חבילה SerializationInheritance ייבוא ​​java.io.FileInputStream ייבוא ​​java.io.FileOutputStream ייבוא ​​java.io.ObjectInputStream ייבוא ​​java.io.ObjectOutputStream ייבוא ​​java.io. מחלקה A שניתן לבצע סידור מיישמת ניתן להתבצע באמצעות Serialize {int to public A (int i) {this.i = i}} מחלקה B מרחיבה A {int j ציבור B (int i, int j) {super (i) this.j = j}} מחלקה ציבורית מבחן {public static void main (String [] args) זורק חריג {B b1 = B חדש (200,400) System.out.println ('i =' + b1.i) System.out.println ('j =' + b1.j) FileOutputStream fos = FileOutputStream חדש ('abc.ser') ObjectOutputStream oos = ObjectOutputStream חדש (fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('האובייקט סידר') FileInputStream fis = new FileInputStream ('abc.ser') ObjectInputStream ois = חדש ObjectInputStream (fis) B b2 = (B) ois.readObject () ois.close () fis.close () System.out.println ('האובייקט הוחלף מחדש') System.out.println ('i = '+ b2.i) System.out.println (' j = '+ b2.j)}}

תְפוּקָה:

j = 20
האובייקט עבר סדרתי
האובייקט הוזז
אני = 200
j = 400

מקרה - 2: ניתן לסדר סדרת משנה אם היא מיישמת את ממשק ה- Serializable גם אם Superclass אינו מיישם את ממשק ה- Serializable.

במקרה זה, אם מעמד-על אינו מיישם את ממשק ניתן לסידור ואז, האובייקטים של תת מחלקה ניתן לסדר באופן ידני על ידי הטמעת ממשק Serializable בתת-מחלקה.

חבילה SerializationInheritance ייבוא ​​java.io.FileInputStream ייבוא ​​java.io.FileOutputStream ייבוא ​​java.io.ObjectInputStream ייבוא ​​java.io.ObjectOutputStream ייבוא ​​java.io. מחלקה על בכיתה מסוג Serializable {int אני superclass ציבורי (int i) {this.i = i} מעמד-על ציבורי () {i = 50 System.out.println ('קונסטרוקטור סופר-קלאס שנקרא')}}} מחלקה-מחלקה מאריכה כלי-מחלקה-על מיועדת לסדרה {int j מחלקה ציבורית (int i, int j) {super (i) this.j = j }} מבחן מחלקה ציבורי 2 {סטטי ציבור ריק ריק (מחרוזת [] טענות) זורק חריג {תת מחלקה b1 = מחלקה חדשה (10, 20) System.out.println ('i =' + b1.i) System.out.println ( 'j =' + b1.j) FileOutputStream fos = FileOutputStream חדש ('output.ser') ObjectOutputStream oos = חדש ObjectOutputStream (fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('האובייקט עבר סדרתי') FileInputStream fis = FileInputStream חדש ('output.ser') ObjectInputStream ois = new ObjectInputStream (fis) subclass b2 = (subclass) ois.readObject ( ) ois.close () fis.close () System.out.println ('האובייקט הוסרה מהמחשב') System.out.println ('i =' + b2.i) System.out.println ('j =' + b2.j)}}

האובייקט עבר סדרתי
קונסטרוקטור קלאס על התקשר
האובייקט הוזז
אני = 50
j = 20

מקרה - 3: אם ניתן לסדר את מעמד העל, אך איננו זקוקים לסדרת המשנה.

במקרה זה, ניתן למנוע את סדרת המשנהעל ידי יישום ה- writeObject () ו readObject () שיטות בתת-מחלקה וזה צריך לזרוק NotSerializableException משיטות אלה.

חבילה SerializationInheritance ייבוא ​​java.io.FileInputStream ייבוא ​​java.io.FileOutputStream ייבוא ​​java.io.IOException ייבוא ​​java.io.NotSerializableException ייבוא ​​java.io.ObjectInputStream ייבוא ​​java.io.ObjectOutputStream ייבוא ​​java.io.Serializable בכלי יישומי סידורי {כלי יישום סידורי אני הורה ציבורי (int i) {this.i = i}} ילד בכיתה מרחיב הורה {int j ילד ציבורי (int i, int j) {super (i) this.j = j} ריק ריק לכתובObject (ObjectOutputStream החוצה) זורק IOException {לזרוק חדש NotSerializableException ()} פרטי ריק ריק readObject (ObjectInputStream פנימה) זורק IOException {לזרוק חדש NotSerializableException ()}} מבחן מחלקה ציבורית 3 {ציבור סטטי ריק ריק (מחרוזת [] טענות) זורק חריג {ילד b1 = ילד חדש (100, 200) System.out.println ('i =' + b1.i) System.out.println ('j =' + b1.j) FileOutputStream fos = FileOutputStream חדש ('abc.ser') ObjectOutputStream oos = ObjectOutputStream חדש ( fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('אובייקט עבר סדרתי ') FileInputStream fis = FileInputStream חדש (' abc.ser ') ObjectInputStream ois = חדש ObjectInputStream (fis) ילד b2 = (ילד) ois.readObject () ois.close () fis.close () System.out. println ('האובייקט הוסרה מהביטול') System.out.println ('i =' + b2.i) System.out.println ('j =' + b2.j)}}

תְפוּקָה:

אני = 100
j = 200
חריג בשרשור 'ראשי' java.io.NotSerializableException
ב- SerializationInheritance.child.writeObject (test3.java:48)
ב- sun.reflect.NativeMethodAccessorImpl.invoke0 (שיטה מקורית)

סידור באמצעות חבר סטטי

מתעלמים מסידור של שדה חבר סטטי בתהליך הסידור. סידור הואקשור למצב האחרון של האובייקט. לפיכך, רק הנתונים המשויכים למופע ספציפי של מחלקה הםסידורי אך לא שדה החברים הסטטיים.

חבילה stati ייבוא ​​java.io. * מחלקה StaticSerial מיישמת ניתן לסידור {static int i = 100 סטטי ציבורי ריק ריק (String ... ar) {StaticSerial ob = new StaticSerial () System.out.println ('בזמן הסידור, לחבר סטטי יש ערך: '+ i) נסה את {FileOutputStream fos = FileOutputStream חדש (' F: File.ser ') ObjectOutputStream oos = חדש ObjectOutputStream (fos) oos.writeObject (ob) oos.close () i = 99 FileInputStream fis = FileInputStream חדש ('F: File.ser') ObjectInputStream ois = חדש ObjectInputStream (fis) ob = (StaticSerial) ois.readObject () ois.close () System.out.println ('לאחר עריקת עריכה, לחבר סטטי יש ערך:' + i)} לתפוס (חריג e) {System.out.println (e)}}}

תְפוּקָה:

בזמן הסידור, לחבר הסטטי יש ערך: 100
לאחר עריקת ערעור, לחבר הסטטי יש ערך: 99

ממשק להחלפה

ה ממשק להחלפה ב- Java דומה ל- Serialization, אך ההבדל היחיד הוא שהוא מסוגל להציע סידור מותאם אישית איפה אתה יכול להחליט על האובייקטים שיאבדו בזרם.

הממשק להחלפה זמין ב- java.io והוא מספק שתי שיטות:

• public void writeExternal (ObjectOutput out) זורק IOException
• חלל ציבורי readExternal (ObjectInput in) זורק IOException

ההבדלים העיקריים בין סידור לאקסטרניזציה הם כדלקמן:

• יישום : ממשק להחלפה מפרט את המשתמש בִּמְפוּרָשׁ להזכיר את האובייקטים שיש לסדר. בעוד שבממשק הסידור, כל האובייקטים והמשתנים מסודרים בסדרה זמן ריצה.

• שיטות : ממשק להחלפה מורכב משתי שיטות, כלומר:

  • writeExternal ()

  • readExternal ()

ואילו ממשק Serializable אינו כולל שיטות כלשהן.

• תהליך: תהליך הסידור בממשק חיצוני מספק התאמה אישית לתהליך הסידור. אבל, ממשק הסידור יספק את בְּרִירַת מֶחדָל תהליך סידור.

• תאימות ושליטה לאחור: ממשק חיצוני תומך בסידור ללא קשר ל- בקרת גרסאות והבעיה היחידה היא שעל המשתמש להיות אחראי בזמן סדרת Super Class. מצד שני, ממשק סידור דורש את אותה גרסה של JVM משני הקצוות, אך הוא משלב סדרת אוטומטית של כל האובייקטים והמחלקות כולל מעמד העל.

• בנאי ציבורי ללא ארגונים: צרכי ממשק החצנה בנאי ציבורי ללא ארגונים לשחזר את האובייקט הסדרתי. בעוד שממשק הסידור אינו דורש בנאי No-Arg, במקום זאת הוא משתמש הִשׁתַקְפוּת לשחזר את האובייקט או המחלקה הסדרתית.

חבילה ext יבוא java.io. * מחלקה הדגמה מיישמת java.io.Serializable {public int a public String b Public Demo (int a, String b) {this.a = a this.b = b}} Class Test {static public void main (String [] args) {Demo object = Demo new (1, 'Welcome to Edureka') String file name = 'file.ser' try {FileOutputStream file = new FileOutputStream (name file) ObjectOutputStream out = new ObjectOutputStream (file) out .writeObject (object) out.close () file.close () System.out.println ('Object has been serialised')} catch (IOException ex) {System.out.println ('IOException is caught')} אובייקט הדגמה 1 = null נסה {FileInputStream file = קובץ FileInputStream חדש (שם קובץ) ObjectInputStream in = ObjectInputStream חדש (קובץ) object1 = (Demo) in.readObject () in.close () file.close () System.out.println ('האובייקט כבר deserialized ') System.out.println (' a = '+ object1.a) System.out.println (' b = '+ object1.b)} לתפוס (IOException למשל) {System.out.println (' IOException נתפס ')} לתפוס (ClassNotFoundException לשעבר) {System.out .println ('ClassNotFoundException נתפס')}}}

מילת מפתח חולפת

מילת מפתח חולפת היא מילת מפתח שמורה בג'אווה. הוא משמש כ משתנה לשנות בזמן תהליך הסידור. הכרזת משתנה עם מילת מפתח חולפת מונעת את סידור המשתנה.

גרסה טורית UID

לפני שמתחיל תהליך הסידור, כל מחלקה / אובייקט ניתן לסידור נקשר ל- מספר זיהוי ייחודי מסופק על ידי JVM של המכונה המארחת. מזהה ייחודי זה נקרא גרסה טורית UID . UID זה משמש כזיהוי על ידי ה- JVM של הקצה המקבל כדי לאשר שאותו אובייקט מוחלף בקצה המקבל.

מחלוקות על סידור ב- Java

אורקל'ס אדריכלים מתכוונים להסיר את Serialization מג'אווה מכיוון שהם רואים בכך טעות איומה משנת 1997 . לאחר מחקר קדחתני גילו היזמים באורקל כמה פגמים בתכנון הליך הסידור המהווים איום על הנתונים.

בשנת 1997,מארק ריינהולד קובע - ' אנו רוצים לקרוא לסידור 'המתנה שממשיכה לתת', וסוג המתנה שהיא ממשיכה לתת הוא פגיעות ביטחוניות. קרוב לוודאי ששליש מכל נקודות התורפה בג'אווה היו כרוכות בסידור, זה יכול להיות מעל למחצית. זהו מקור לפגיעות מופלא להפליא, שלא לדבר על אי יציבות. '.

יש סיכויים שסידור יוסר או יוחלף בעדכונים הקרובים של Java ומצד שני, למתחילים בג'אווה, Serialization לא יכול להיות אופציה אידיאליסטית בפרויקטים שלהם

שיטות עבודה מומלצות בעת שימוש בסידור ב- Java

להלן מספר שיטות עבודה מומלצות שיש לבצע

• מומלץ להשתמש javadoc @ תג סדרתי לציון שדות הניתנים להתאמה לרישום.
• ה .להיות עדיף להשתמש בסיומת עבור קבצים המייצגים אובייקטים מסדרתיים.
• לא מומלץ לעבור שדות סטטיים או ארעיים סידור ברירת מחדל.
• שיעורים הניתנים להארכה לא צריך להיות סידורי אלא אם כן חובה.
• שיעורים פנימיים יש להימנע מלהיות מעורב בסידור.

בכך הגענו לסוף מאמר זה. אני מקווה שהבנתם את יסודות הסידור ב- Java, סוגיה ותכונותיה.

בדוק את מאת אדוריקה, חברת למידה מקוונת מהימנה עם רשת של יותר מ -250,000 לומדים מרוצים הפרוסים ברחבי העולם. קורס ההכשרה וההסמכה של Java J2EE ו- SOA של אדוריקה מיועד לסטודנטים ואנשי מקצוע שרוצים להיות מפתח Java. הקורס נועד לתת לך התחלה בתכנות ג'אווה ולהכשיר אותך למושגי הליבה והמתקדמים של ג'אווה יחד עם מסגרות Java שונות כמו Hibernate & אביב .

יש לך שאלה עבורנו? הזכיר זאת בסעיף ההערות במאמר זה 'סידור ב- Java' ונחזור אליך בהקדם האפשרי.