Persistence

Persistent ``things'' exist over a period of time independent of many operations
Transient ``things'' exist only for a short period of time

Examples

A file on a CDROM is very persistent
A file on disk is fairly persistent. Its contents may change
A server process is fairly persistent
An ordinary application is transient
Data in an application is transient. Local variables may be very transient
A dialog is very transient

Application data persistence

If an application requires data to be in existence before it starts, and leaves the data in existence after it finishes, the data must be persistent
The data will need to be stored in file
Changes:
- The application may treat the data are read-only e.g. CONFIG.SYS
- The application may make small changes e.g. bookmarks in a Web browser
- It may make major changes e.g. an editor

Complexity

The data may be simple in structure e.g. server log
An SQL database consists of many tables, with relationships between them

Storing and retrieving simple data

Simple data can be stored in many ways
- fixed sixe record
- variable size record with delimiter such as '\n'
- readable format as strings
- binary format
Data format can be
- assumed by all applications using it
- self-describing format such as ASN.1

Serialisation of data

Persistence is achieved by two techniqes
- serialisation means a piece of data can be written as a sequence of bytes
- serialised data can be written/read to/from disk or other media
Serialisation is also needed to communicate data between applications

Example 1: structure

    struct Customer {
        char last[20];
        char first[20;
        int id;
    }

Example 2: linked list

Linked list:

This can be represented by

Example 3: string

String: "hello"

Example 4: array

Can be represented by

Example 5: circular list

Can be represented by

Example 6: binary tree

Prefix order is: node left right
Trees can be stored and restored by writing them in prefix order, with a special flag for empty tree.

Example 7: graph

These need to be stored in a table

a	b
b	d
a	c
c	d

Identity problem

Consider the graph

with table

a b
b c
c a
This could also be the graph
Content != identity
Need to introduce unique labels

label contents
1 a
2 b
3 c
4 d
with links

1 2
2 3
3 4

Objects

Objects in Java contain primitive data (int, char, etc) and references to other objects
An array is an object, so is a String
Serialising an object means
- serialising each primitive attribute
- inventing a label for each object reference
- serialising the label
- storing the table of cross-references between labels and objects

Serializable interface

If a Java object implements the Serializable interface, then it can be serialised


      public class Specification implements java.io.Serializable {...}

Static fields will not be serialized
Transient fields will not be serialized
If an object contains a reference to another object that is not serializable, then it can't be serialized, and attempts to serialize it will throw a NotSerializableException
Serializing an object will serialize the entire object graph
Most classes in the Java libraries are serializable, including containers such as HashMap

Serializing an object (graph) to file

The class ObjectOutputStream has method writeObject() which can write an object to a stream

e.g. to save a catalog to file catFile


      FileOutputStream fileOut = new FileOutputStream("catFile");
      ObjectOutputStream objOut = new ObjectOutputStream(fileOut);
      objOut.writeObject(catalog);
      objOut.close();

Restoring an object (graph) from file

To restore the catalog, read it back from the file and cast it to the right type


      Catalog catalog = null;
      try {
          FileInputStream fileIn = new FileInputStream("catFile");
          ObjectInputStream objIn = new ObjectInputStream(fileIn);
          Object obj = objIn.readObject();
          objIn.close();
          catalog = (Catalog) obj;
      } catch(Exception e) {...}

Versioning

What happens if you save an object, change the class definition and then try to restore it?
Java calculates a long serialVersionUID for each class definition
If you change the class, this value changes
If you save with one version, and restore with another, the restore will normally fail
To make it succeed
- Calculate the UID of the old definition using the serialver tool
- Add the UID to the new version
```
	    static final long serialVersionUID = ...;
```
This will only work if you have not removed attributes
If you have added attributes, then you may need to fix up their values

Jan Newmarch (http://pandonia.canberra.edu.au)

label	contents
1	a
2	b
3	c
4	d

PERSISTENCE