CSC/ECE 517 Spring 2014/ch1a 1d mm

This page discusses Serialization, focusing on Ruby programming language. It describes different methods of Serialization in Ruby. In addition, it also compares serialization in different Object Oriented languages.

Introduction

Serialization

Serialization[1] is a process of converting a data structure or an object into a stream of bytes or string to facilitate storage in memory, file (persistence storage) or transmission over a network. The process of Serialization is also referred to as Marshalling[2]. The stream of data has to be in a format that can be understood by both ends of a communication channel so that the object can be marshaled and reconstructed easily.

De-serialization

De-serialization is the process of converting the stream of bytes or string back to objects in memory. It is the process of reconstructing the object later. This process of de-serialization is also referred to as Unmarshalling.

The process of Serialization/De-serialization is not a replacement for database systems. Database Systems are used for their relational and transactional semantics.

Basic Advantages of Serialization

1. Communication between two or more processes on same machine. Object state can be saved and shared in a persistent or in-memory store.

2. Communication between processes on different machines. Serialization facilitates the transmission of an object through a network.

3. Creating a clone of an object.

4. Cross-platform compatibility. Object can be serialized in a common format that is understood by multiple platforms. For example, JSON[3] and XML.

Practical Applications for Serialization

1. HTTP Session Replication by sharing session objects across web servers for load balancing and handling failover scenarios.

2. Serialization facilitates communication in Remote Method Invocation or Remote procedure calls

3. Rails Cookie Handling[4]. Cookies are stored marshalled/unmarshalled to and from client machines.

Serialization in Ruby:

Ruby provides serialization capabilities through its module, Marshal. There are also other libraries like YAML[5] and JSON which can be used in Ruby to generate serialized objects for purposes like platform independence and human readable formats.

Types of Serialization

Serialization in Ruby can be done in two ways. During serialization, the object in memory can be converted into Human Readable formats like YAML (YAML Ain’t Markup Language) and JSON (JavaScript Object Notation), or the object can be converted into binary format.

Converting Ruby Objects in Human Readable Formats

---

The conversion of Ruby objects into YAML and JSON formats are explained below.

Converting Ruby Objects to YAML format

YAML format is a human friendly data serialization standard for all programming languages. YAML (YAML Ain't Markup Language) is perhaps the most common form of serialization in Ruby applications. It is used for configuration files in Rails and other projects, and is nearly ubiquitous. YAML is a plaintext format, as opposed to Marshal's binary format. Objects stored as YAML are completely transparent and editable with nothing more than a text editor. It also has a simple, spartan syntax that's easy to look at and easy to type. It is not encumbered by excessive wordage and symbols seen in XML. In order to use it in Ruby, the yaml.rb file is required to be loaded which provides methods for converting objects into yaml format and creating .yml files.

Serialization using YAML

    #Serialization using YAML's to_yaml method
 
  require "yaml"
     class First
     def initialize(name, age, country)
	@name = name
	@age = age
	@country=country
     end
      def to_s
	"In First:\n#{@name}, #{@age}, #{@country}\n"
     end
   end
 
  x = First.new("Tom", 25, "USA")
  puts x
  puts x.to_yaml

Output:

  In First:
  Tom, 25, USA
  --- !ruby/object:First
  name: Tom
  age: 25
  country: USA

The above code displays the object x, first as a string and then in the yaml format.

Saving YAML data into a file:

 # Serialization using YAML::dump

require 'yaml'

f = File.open( 'first.yml', 'w' )
YAML.dump( ["Tom", 25, "USA"], f )
f.close
		
File.open( 'first.yml' ){ |f|	
    $arr= YAML.load(f)
}	

p( $arr )

Output:

  ["Tom", 25, "USA"]

The dump function can be used to serialize the data and save it into a file in YAML format. As shown in the above example the data in YAML format can be de-serialized using the load function.

YAML libraries also provides an option of selecting only those variables of the object that are needed to be serialized. This is done using the to_yaml_properties method as shown in the below example.

Custom Serialization using YAML

 
    require "yaml"
     class First
     def initialize(name, age, country)
	@name = name
	@age = age
	@country=country
     end
     def to_s
	"In First:\n#{@name}, #{@age}, #{@country}\n"
     end
      def to_yaml_properties
	   ["@name","@age"]  #@country will not be serialized
     end
   end
 
  x = First.new("Tom", 25, "USA")
  puts x
  puts x.to_yaml
  

Output:

  In First:
  Tom, 25, USA
  --- !ruby/object:First
  name: Tom
  age: 25

Converting Ruby Objects to JSON format:

JSON is a light-weight data interchange format. JSON is typically generated by web applications and can be quite daunting, with deep hierarchies that are difficult to navigate. Any Ruby object can easily be serialized into JSON format. Ruby 1.8.7 distribution is not bundled with json gem. However, in Ruby 1.9.2, the json gem is bundled with the core Ruby distribution. The JSON library can be installed using Ruby Gems[6] as shown below:

# gem install json

A JSON string for serialization can be created by using the JSON.generate method:

       require 'json'
       my_hash = {:Welcome => "Ruby"}
       puts JSON.generate(my_hash) => "{\"WELCOME\":\"RUBY\"}"

Output:

{"{\"Welcome\":\"Ruby\"}"=>"{\"WELCOME\":\"RUBY\"}"}

A JSON string received from another program can be parsed by using JSON.parse Ruby thus converts String to Hash.

       require 'json'
       my_hash = JSON.parse('{"Welcome": "Ruby"}')
       puts my_hash["Welcome"] => "Ruby"

Converting Ruby Objects to Binary Formats

---

Binary Serialization is another form of serialization in Ruby which is not in human readable form. Binary Serialization is used when high performance serialization and de-serialization process is required and when the contents are not required to be in readable format. Binary Serialization is done using Marshal which is built into Ruby and the code for it is written in Ruby's Marshal module(marshal.c) and thus no additional files are required in order to use it. The _dump and _load methods defined in marshal are used for serialization. Using marshal module the following types of objects can not be serialized: bindings, procedure objects, singleton objects, instances of IO objects and interfaces.

Since the Binary Serialized data is not in human readable form, the following guidelines need to be followed.

    1.Use print instead of puts[7] when serialized objects are written to a file in order to avoid new line characters to be written 
      in the file.
    
    2.Use a record separator in order to differentiate between two objects.

Binary Serialization Example:

   class Animal
     def initialize  name, age
     @name = name
     @age=age
   end
  end
  class Cat < Animal
   def to_s
    "In Cat C: #{@name} \t #{@age}"
   end
  end
 c = Cat.new("Kitty Kat",5)
 puts "Before Serialization"
 puts c
 #puts d
 serialize_cat= Marshal.dump(c) #dumps the serialized cat object into serialize_cat
 puts "\nAfter Serialization:\n #{serialize_cat}"
 deserialize_cat= Marshal::load(serialize_cat) #deserializes the cat object and loads it back into deserialize_cat
 puts "\nAfter Deserialization\n #{deserialize_cat}"

Output:

  Before Serialization
  In Cat C: Kitty Kat 	 5
  After Serialization:
  oCat:
  @nameI"Kitty Kat:ET:	@agei
  After Deserialization
  In Cat C: Kitty Kat 	 5

Saving Marshal data into a file

Similar to YAML, Marshal can also be used to dump data into a file. The above example showing the serialization using YAML::dump can be written using marshal as shown below.

   f = File.open( 'first.yml', 'w' )
   Marshal.dump( ["Tom", 25, "USA"], f )
   f.close	
   File.open( 'first.yml' ){ |f|	
   $arr= Marshal.load(f)
   }	
   p( $arr )

Output:

  ["Tom", 25, "USA"]

Notice that in the above example there is no "require" statement as opposed to the earlier example of writing serialized data into files using YAML. This is because unlike YAML, marshal is built-in Ruby and no external libraries is required in order to use its functionality.

Custom serialization using Marshal

Marshal can also be used to custom serialize an object i.e. it provides an option to omit the variables of an object that are not required in the serialized data. The following program shows the use of marshal_dump method for achieving custom serialization.

     class First
     def initialize(name, age, country)
        @name = name
        @age = age
        @country=country
     end
     def to_s
           "In First: #{@name}, #{@age}, #{@country}"
     end
     def marshal_dump
           [@name,@age]  #@country will not be serialized
     end
     def marshal_load(data)
      @name=data[0]
      @age=data[1]
      @country="United States of America"
     end
     end

     x = First.new("Tom", 25, "USA")
     puts x
 
     marshal_data = Marshal.dump( x ) 
     y = Marshal.load( marshal_data ) 
     p( y.to_s )




Output:

   In First: Tom, 25, USA
   "In First: Tom, 25, United States of America"

Serialization Performance in Ruby

The different serialization formats described above differ in the efficiency at which they can serialize and deserialize data and thus while serializing large amount of data their efficiency is taken into account. The .report[8] method in Ruby can be used to evaluate the performance of these serialization patterns. Marshal, as it handles data in binary format, is the most efficient form of serialization in Ruby. The following example compares the performance of marshal, JSON and YAML format.[9]

  require 'benchmark'
  require 'rubygems'
  require 'json'
  require 'yaml'
  include Benchmark
  class First
    def initialize(name, age, country)
     @name=name
     @age=age
     @country=country
    end
  end  
   x = First.new("Tom", 25, "USA")
   puts "            User     System     Total      Real"
  benchmark do |t|
   print "Marshal:"
   t.report{1000.times do; Marshal.load(Marshal.dump(x));end}
   print "JSON:   "
   t.report{1000.times do; JSON.load(JSON.dump(x));end}
   print "YAML:   "
   t.report{1000.times do; YAML.load(YAML.dump(x));end}
  end

Output:

             User     System     Total      Real
 Marshal:   0.010000   0.000000   0.010000 (  0.015408)
 JSON:      0.020000   0.010000   0.030000 (  0.022462)
 YAML:      0.460000   0.010000   0.470000 (  0.472149)

The output of the above example shows that, given large chunks of data, marshal is comparatively more efficient format for serialization in Ruby.

Serialization in other Object-Oriented Languages

Comparison

Sl.No	Ruby	Java	.Net Framework	C++
1	Ruby provides a built in module called Marshal for serialization	Java uses an Interface named Serializable interface for classes to implement	.Net provides a Serializable Attribute	Although, there is no built in support for serialization in C++, it can be achieved by using Boost libraries[10]
2	The built in module of Ruby (Marshal) does not support platform independence, however, it can be achieved by using external libraries like YAML and JSON	Similarly, Java's built in serialization is also not platform independent and in order to use serialization in Java across Ruby platform, jruby library should be used.	.Net used Remoting technology to make it platform independent.	Serialization using the Boost libraries is not platform independent.
3	YAML provides a method (to_yaml_properties) which can be used to select the variables who's value is need to be serialized. With Marshal, we need to write a method named marshal_dump defining the variables of an object that has to be serialized.	Provides an option for serializing only the required attributes to be serialized for an object. Use the keyword Transient to ignore certain data that doesn’t need to be serialized	XML Serializer sets XmlIgnoreProperty to true to ignore the default serialization of a field or a property	Serialization using the Boost libraries is custom and thus the user can specify the part of the objects to be serialized.
4	Bindings, procedure objects, singleton objects, instances of IO objects and interfaces can not be serialized. Serializing these objects throws TypeError exceptions.	Thread, OutputStream and its subclasses, and Socket are not serializable in Java.[11]	Objects like DataRow are non serializable in .NET. Whether an object is serializable or not can be checked using the Type.IsSerializable	There are no such objects in C++.

Serialization in Java

To serialize an object in Java, the class needs to implements Serializable interface and use ObjectOutputStream to serialize an object. Similarly, we can use ObjectInputStream to deserialize an object. Below is an example to serialize an object of Class First.

 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
          
public class First implements Serializable {

private static final long serialVersionUID = 1L;
public String name;
public int age;
public String country;

private static void serialize(First f, String path) throws IOException {
 
      FileOutputStream fos = new FileOutputStream(path);
      ObjectOutputStream oos = new ObjectOutputStream(fos);
   
      // Serializing
      oos.writeObject(f);
      oos.close();
      fos.close();
   }
 
private static First deserialize(String path) throws IOException,
 		ClassNotFoundException {
 	// tom.ser will deserialize in object f
 	First f = null;
 	FileInputStream fin = new FileInputStream(path);
 	ObjectInputStream oin = new ObjectInputStream(fin);
 	// DeSerializing and Casting to Class First
 	f = (First) oin.readObject();
 	oin.close();
 	fin.close();
 	return f;
 }
 
 public static void main(String[] args) {
 	try {
 		// Creating object for Tom
 		First f1 = new First();
 		f1.name = "Tom";
 		f1.age = 25;
 		f1.country = "USA";
 		First f2 = null;
 		long start = System.currentTimeMillis();
 		for (int i = 0; i < 1000; i++){
 		// serializing
 		serialize(f1, "/path/to/files/" + i + ".ser");
 		// deserializing
 		f2 = deserialize("/path/to/files" + i + ".ser");
 		}
 		long end = System.currentTimeMillis();
 		long totalDuration = end - start;
 		System.out.println("Serialization/Deserialization for 1000 Iterations duration: " + totalDuration + " Milliseconds");
 		// Printing deserialized object
 		System.out.println("Deserialized => Name: " + f2.name + ", Age: " + f2.age + ", Country: " + f2.country);
 	} catch (IOException ex) {
 		e.printStackTrace();
 	} catch (ClassNotFoundException ex) {
 		e.printStackTrace();
 	}
 }
}

Output:

Serialization/Deserialization for 1000 Iterations duration: 1651 Milliseconds
Deserialized => Name: Tom, Age: 25, Country: USA

See Also

1. Serialization in Ruby JSON

2. Serialization in Rails

3. Article on Rails Serialization

4. Protocol Buffers

5. Ruby Protocol Buffers Gem

6. Avro

7. Ruby Avro Gem

References

1. Serilization in General

2. Marshaling

3. JSON

4. Rails Cookie Handling

5. YAML

6. Ruby Gems

7. Ruby ARGF Documentation

8. Ruby Documentation for Benchmark Gem

9. Serialization Performance Comparison

10. Boost Libraries

11. Java Serialization

12. JSON Tutorial

13. Serializing and De-serializing in Ruby

14. Serialization and De-serialization

15. XML Serialization

16. Java Serialization Tutorial

17. The Book of Ruby

18. Serialization in .Net

19. Serialization in Ruby YAML

20. Installing JSON gem

21. Serialization in Ruby JSON