Date Archives August 24, 2016

Linux Hierarchy Structure

flowchart-LinuxDirectoryStructure

/ (Root directory)

The Root Directory is the starting point of the file system hierarchy. Everything in the system, including the other directories and files of the system, are stored in the root directory.

Screen Shot 2016-08-24 at 4.37.12 PM

/bin

The /bin directory contains the binaries and other executable programs. Most of the common Linux commands that you may utilize as a user of the system are stored here. Similar to the /bin directory is the /sbin directory, which contains the essential system administration binaries.

Screen Shot 2016-08-24 at 4.38.26 PM

/boot

The /boot directory contains the static boot loader files needed to boot the operating system. It contains the GRUB boot loader files along with the Linux kernels.

Screen Shot 2016-08-24 at 4.41.05 PM

/dev

The /dev directory contains device files which are typically under the control of the operating system and the system administrators. The terminal devices, disk drives, USB’s etc. are all included in the /dev directory and are exposed as files in Linux, instead of being represented as devices.

Screen Shot 2016-08-24 at 4.43.09 PM

/etc

The /etc directory contains the system configuration files. All files in the /etc directory should be text files and cannot be executable binary files. It contains the /etc/passwd and the /etc/shadow files which contain essential user identification and authentication data.

Screen Shot 2016-08-24 at 4.45.05 PM

/home

The /home directory contains a home directory for each user. Each user’s personal files and user-specific configuration files are stored in their respective home directories. Each user has write access only to their own home directory. One can not modify the files in the home directory of the other user unless they have acquired the permissions to do so.

Screen Shot 2016-08-24 at 4.46.00 PM

/lib

The /lib directory contains the essential system libraries and kernel modules which would be required by the binaries located under the /bin or /sbin directories. Similarly, the /lib64 directory contains libraries required for 64-bit support in systems.

Screen Shot 2016-08-24 at 4.46.32 PM

/media

The /media directory is used to temporary mount removable media like external hard disks, CD-ROM’s etc. Once you attach a removable media to a system, a subdirectory will automatically be created inside the /media directory. You shall be able to access the contents of the device from that subdirectory.

Screen Shot 2016-08-24 at 4.47.45 PM

/opt

The /opt directory contains sub-directories for optional or third-party software. Most proprietary software keep their files here in the /opt directory.

Screen Shot 2016-08-24 at 4.48.41 PM

/proc

The /proc directory contains information about the processes running on your system in directories named /proc/PID where PID is the process id. It also contains information about system resources.

Screen Shot 2016-08-24 at 4.49.35 PM

/tmp

The /tmp directory is used by the system and its applications to store their temporary files. All these files are typically cleared on system reboot.

Screen Shot 2016-08-24 at 4.50.19 PM

/usr

The /usr directory is used to contain the applications and file pertaining to a particular user as compared to the files and applications of the system. For example, the essential binaries and essential system administration binaries are stored in the /bin & /sbin directories while the non-essential ones are stored in /usr/bin & /usr/sbin directories respectively.

Screen Shot 2016-08-24 at 4.50.58 PM

/var

The /var directory is an important part of the Linux Directory Structure & contains variable system files whose data that may grow over time. Log files, packages and database files can be found in the /var directory.

Screen Shot 2016-08-24 at 4.51.36 PM

 

source: http://fossbytes.com/linux-lexicon-linux-directory-structure/

Serialization #2

beans

JavaBeans

JavaBeans are classes that encapsulate many objects into a single object (the bean), and  they are serializable.

  • It provides a default, no-argument constructor.
  • It should be serializable and implement the Serializable interface.
  • It may have a number of properties which can be read or written.
  • It may have a number of “getter” and “setter” methods for the properties.

Example

package com.chang;
import java.io.Serializable;

public class StudentsBean implements Serializable{
   private String firstName = null;
   private String lastName = null;
   private int age = 0;

   public StudentsBean(){
   }

   public String getFirstName(){
      return firstName;
   }

   public String getLastName(){
      return lastName;
   }

   public int getAge(){
      return age;
   }

   public void setFirstName(String firstName){
      this.firstName = firstName;
   }
 
   public void setLastName(String lastName){
      this.lastName = lastName;
   }

   public void setAge(Integer age){
      this.age = age;
   }
}

Serialization #1

Definition

Serialization is a process in which current state of Object will be saved in stream of bytes. As byte stream create is platform neutral hence once objects created in one system can be deserialized in other platform.

This Byte stream can be used for different purpose.

  • Write to Disk
  • Store in Memory
  • Sent byte stream to other platform over network
  • Save byte stream in DB(As BLOB)

Java has already provided out of the box way(java.io.Serializable  Interface) to serialize an Object. If you want any class to be serialized then that class needs to implement this interface.

* Serializable interface is just a marker interface. There is no methods in it.

Serialization-deserialization-in-Java-Object-Streams

Example. Serializable Class

The serialVersionUID is used as a version control in a Serializable class. If you do not explicitly declare a serialVersionUID, JVM will do it for you automatically, based on various aspects of your Serializable class.

package com.chang;
import java.io.Serializable;

public class Employee implements Serializable{
   public String firstName;
   public String lastName;

   // serialVersionUID
   private static final long serialVersionUID=1L;
   
}

Serializable class usually makes files variables as private and interact with them using setter and getter.

Example. Serialization Class

package com.chang;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializationClass{
   public static void main(String[] args){
      Employee emp = new Employee();
      emp.firstName = "Chang";
      emp.lastName = "Park";

      try{
         FileOutputStream fileOut = new FileOutputStream("./employee.txt");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.wirteObject(emp);
         out.close();
         fileOut.close();
         System.out.println("Serialized data is saved in  ./employee.txt file");
      } catch (IOException i){
         i.printStackTrace();
      }
    
   }
}

Example. Deserialization Class

package com.chang;
import java.io.*;

public class DeserializationClass{

   public static void main(String[] args){
      Employee emp = null;
      try{
         FileInputStream fileIn = new FileInputStream("./employee.txt");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         emp = (Employee) in.readObject();
         in.close();
         fileIn.close();
      } catch (IOException i){
         i.printStackTrace();
         return;
      } catch (ClassNotFoundException c){
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      System.out.println("First Name of Employee: " + emp.firstName);
      System.out.println("Last Name of Employee: " + emp.lastName);
   }
}