Kihagyás

Implementacio

Implementáció

Az előzőekben megvizsgáltuk a Mapping osztály kapcsolatait és felépítését. Láttuk, hogy három osztály szerializációját kell biztosítani:

  • Mapping: Mapping.java
  • Linking: Linking.java
  • Binding: Binding.java
  • Constant: Constant.java

A szerializáció implementálásához az kell, hogy az érintett osztály implementálja a java.io.Serializable interfészt.

public class Mapping implements Serializable

Az ObjectInputStream és ObjectOutputStream osztályok tartalmazzák a szerializáláshoz szükséges metódusok implementációit. A használt metódusok:

public final void writeObject(Object x) throws IOException

public final Object readObject() throws IOException, ClassNotFoundException

A szerializálandó osztályok esetében minden mezőnek szerializálhatónak kell lenni. Amely mező nem szerializálható, azt a transient jelzővel kell ellátni. Javasolt beállítani a private static final long serialVersionUID értékét, az érintett osztályok esetében azonos értékre. Ez nem kötelező, de hiánya esetében figyelmeztetést kapunk. Az azonos értékre szükség van és annak ellenőrzésére szolgál, hogy a szerializált objektum küldője és címzettje betöltött-e olyan osztályokat az objektumhoz, amelyek kompatibilisek a szerializálás szempontjából.

A szerializáció végrehajtására önálló osztályt készítünk. Ennek elhelyezésére olyan konvenciókat kell követni, hogy specifikus-e az adott osztályrea nézve, vagy általános. Az utóbbi esetben célszerű a commons közé elhelyezni. A példában specifikusan a Mapping osztályra készítjük el, ezért az osztályt tartozó forrást (Serialize.java) a Mapping mellé helyezzük.

Eclipse beállítása

Amennyiben még nem került telepítésre, az operációs rendszerünknek megfelelő változatot töltsük le erről a cimről. A letöltött csomag egy installert tartalmaz, telepítés során ki kell választani a megfelelő keretrendszert. Javasolt a Java fejlesztői keretrendszer kiválasztása (rögtön az első változat lesz).

A CodeMetropolist előzőleg már letöltöttük és buildeltük is (source mappában az mvn clean package parancsot kell kiadni). Az így előkészített projektet importáljuk az Eclipse keretrendszerbe (File->Import), válasszuk a Maven-nen belül az Existing Maven Project lehetőséget.

Import

A Next-re kattintva a következő dialógusban azt a könyvtárat kell kiválasztani, ahol a project pom file taláható.

Folder

Válasszunk ki minden elemet és importáljuk. Az Eclipse a következő struktúrát hozza létre:

Struktura

Lényegében minden pom fájlhoz önálló könyvtárlistát kapunk. Mi a mappinget használjuk, ebben található az érintett osztály a mapping->src/main/java útvonalon a codemetropolis.toolchain.mapping.model csomag alatt.

Ahhoz, hogy megfelelően működjön minden, az Eclipse-nek meg kell mondani melyik Java verziót használja, alapból nem adja hozzá a nekünk szükséges openjdk-8-at. Ehhez a Window->Preferences menüben a Preferences dialóguson belül a Java->Installed JREs pontban hozzá kell adnunk a szükséges verziót és alapértelemezetté kell azt tenni.

Java

A megfelelő verziót az Add nyomógombbal tudjuk hozzáadni, Linux esetében az usr/lib/jvm alatt találjuk a különböző telepítéseket.

Az implementáció során az itt lévő fileokat módosítjuk (java.io.Serializable interfész implementálása, illetőleg a serialVersionUID beállítása), valamint itt hozzuk létre a Serialize.java fájlt is. A fájl például a következő tartalommal készülhet:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
package codemetropolis.toolchain.mapping.model;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * @author premissa
 * 
 * This class implements the serialize and deserialize methods for the Mapping class.
 * 
 */
public class Serializer {

    private Mapping m;

    /**
     * The name of the file with its path containing the serialized object.
     */
    private String filename;

    /**
     * The constructor.
     * 
     * @param filename containing the serialized object. The string also contains the path.
     * @param m, the instantiated Mapping object
     */
    public Serializer(String filename, Mapping m) {     
        this.filename=filename;     
        this.m =m;
    }

    public void serialize() {

         try{       
              FileOutputStream fout=new FileOutputStream(this.filename);    
              ObjectOutputStream out=new ObjectOutputStream(fout);    
              out.writeObject(this.m);    
              out.flush();   
              out.close();    
              System.out.println("success");    
            }catch(Exception e){
                  System.out.println(e);
            }

    }

    public void deSerialize() {

         try{    
              ObjectInputStream in=new ObjectInputStream(new FileInputStream(this.filename));    
              this.m=(Mapping)in.readObject();                    
              in.close();    
             }catch(Exception e){
                 System.out.println(e);
             }                      
    }

    public Mapping getM() {
        return m;
    }

    public void setM(Mapping m) {
        this.m = m;
    }

    public String getFilename() {
        return filename;
    }

    public void setFilename(String filename) {
        this.filename = filename;
    }


}

Ez az implementáció meglehetősen minimalista, egyszerű, demonstrációs célokat szolgál. Nincs implementálva a kollekciókban lévő objektumok szerializációja, amit az érintett kollekciók ciklikus feldolgozásával lehet végrehajtani.

Az implementáció végeztével fordítsuk újra a projektet, ehhez használhatjuk a maven parancssort, de az Eclipse-n belül is fordíthatunk.

Figyeljük meg a dokumentációt! Fontos szempont, hogy a dokumentáció minden lényeges információt tartalmazzon, de ne legyen szószátyár. Jelen esetben az osztályról annak funkcióját adtuk meg (kifejezetten a Mapping osztály szerializációja), valamint a kód fejlesztőjét. Korábban verziószámot is írtak, de ezt a modern repository-k feleslegessé tették. Amit még ide lehet írni, az a licensz információk lehetnek, de ebben az esetben az osztállyal szorosan összekapcsolódik, nem itt van a helye ennek az információnak.

A private adattagokat szokás dokumentálni, de míg a Mapping esetében egyértelmű, a file neve esetén fontos információ, hogy annak teljes elérési útjának szerepelnie kell.

A konstruktort és a metódusokat akkor szokás dokumentálni, ha egyrészt azok nyilvánosan elérhetők, másrészt a paraméterezésük és a visszaadott értékkel kapcsolatosan információt közlünk. Ha viszont dokumentáljuk, akkor teljes dokumentációt illik odaírni. A getter és setter metódusok dokumentálása teljesen felesleges.


Utolsó frissítés: 2022-01-13 19:22:49