ජාවා වැඩසටහනක් සහ PHP වැඩසටහනක් අතර දත්ත හුවමාරු කරන අන්දම

එක දිගටම ජාවා සම්බන්ද මූලධර්ම සාකච්ඡා කරපු නිසා අපි මේ පාඩමෙන් ප්‍රායෝගික පැත්තට බර කරුණු ටිකක් අධ්‍යයනය කරමු. මේ වන විට පරිගණක වැඩසටහනක් යනු හුදෙක්ම එක් පරිගණකයකට සීමාවූ දෙයක් නොවන බව අපි කවුරුත් දන්න දෙයක්නේ. බොහොමයක් පරිගණක වැඩසටහන් අන්තර්ජාලයට සම්බන්දව පවතිනවා. උදාහරණ විදියට internet messenger වැඩසටහන් , virus guards, වැනි වැඩසටහන් දක්වන්න පුලුවන්. වයිරස් ගාඩ් එකක් සැලකුවොත් එය අන්තර්ජාලය හා සම්බන්ද වන අවස්ථා තමයි අලුත් virus definition තිබේ දැයි පරීක්‍ෂා කිරීම, අලුත් virus definition තිබේනම් ඒවා ලබා ගැනීම, සැක සහිත ගොණුවක් අදාල ආයතනයට upload කිරීම වැනි අවස්ථා. මෙහිදී මූලිකවම සිදුවන්නේ දුරස්ථ සර්වරයක ඇති වැඩසටහනක් හා කිසියම් සන්නිවේදනයක් කිරීමයි. 

අපි මෙම පාඩමෙන් අධ්‍යයනය කිරීමට යන්නේ ජාවා වැඩසටහනකින් දුරස්ථ වැඩසටහනක් සමග සම්බන්ද වන ආකාරයයි. මාතෘකාවට අනුව අපි දුරස්ථ වැඩසටහන ලෙස යොදාගන්නේ PHP script එකක්. නමුත් මෙම දුරස්ථ වැඩසටහන Python හෝ Perl script එකක් හෝ වෙනත් ඕනෑම server side script එකක් වීමට පුලුවන්. 

ජාවා Data Streams භාවිතා කරන අයුරු

මේ වනවිට අපි ඉතා වැදගත් stream වර්ග කිහිපයක් ගැන කතාකලා. byte stream, character stream, buffered stream එම stream පිලිබඳ ඔබට මේ වනවිට හොඳ අවබෝධයක් ඇති බව උපකල්පනය කරමින් අපි මෙම පාඩමෙන් සාකච්ඡා කිරීමට යන්නේ data streams පිලිබඳවයි. 

Data stream බාවිතයෙන් stream එකකට  primitive data ලිවීමට සහ data stream එකකින් primitive data කියවීමට පුලුවන්. එනම් int, float, double, long, boolean, char, byte මෙන්ම primitive data type එකක් නොවුවද String සඳහා data streams සහය දක්වනවා.

DataInputStream සහ DataOutputStream නම් class වර්ග 2 යොදාගෙන data streams නිරූපණය කෙරෙනවා. එවන් stream එකකින් දත්ත කියවීමට DataInputStream ද ඒවාට ලිවීමට DataOutputStream class එකද යොදාගැනෙනවා.

හොඳින් මතක තබාගත යුතු කාරණාවක් තමයි සෑම විටම data stream object එකක් construct කල යුත්තේ byte stream එකක් wrap කිරීමෙන් බව.

DataInputStream භාවිතාකරන අන්දම...

මෙහිදී readInt(), readLong(), readUTF()... යනාදී වශයෙන්  primitive data කියවීමට වැදගත් methods ගණනාවක් යොදාගන්න පුලුවන්. Java Documentation එක බැලිමෙන් මෙම methods සවිස්තරාත්මකව දැනගැනීමට පුලුවන්. 

කලින් අධ්‍යයනය කල stream වලදී මෙන් නොව data stream වලදී File එකේ අවසානය (EOF) හඳුනාගැනීමට සෘජු ක්‍රමයක් නැහැ. එම නිසා EOFException එක catch කිරීමෙන් file එකක අවසානය හඳුනාගතයුතු වනවා. 

DataOutputStream භාවිතාකරන අන්දම...

මෙහිදී writeInt(), writeLong(), writeUTF()... යනාදී වශ්යෙන් primitive data ලිවීමට වැදගත් වන methods ගනණාවක් තිබෙනවා. මීට පෙර stream වලට පොදුවූ flush(), close() යනාදී methods ද මෙම data stream විසින් inherit කරගෙන සිටිනවා.

අපි දැන් බලමු data stream එකක ක්‍රියාකාරීත්වය වටහාගැනීමට පහසුවන අන්දමේ සරල ජාවා වැඩසටහනක්.

/**       
*class  : Test 
*Author : Kanishka Dilshan       
*Purpose: Demonstrate how to use data streams  
*Blog   : http://javaxclass.blogspot.com       
*/ 

import java.io.*;

class Test {
 public static void main(String args[]){
  try{
   DataOutputStream dout=new DataOutputStream(
     new BufferedOutputStream(
     new FileOutputStream("myDataFile.dat")));
   
   dout.writeUTF("Kanishka");
   dout.writeFloat(83.23f);
   dout.writeBoolean(true);   
   
   dout.writeUTF("Ravindu");
   dout.writeFloat(98.12f);
   dout.writeBoolean(false); 
   
   dout.writeUTF("Madhawa");
   dout.writeFloat(84.65f);
   dout.writeBoolean(false);
   
   dout.close();
   
   DataInputStream din=new DataInputStream(
     new BufferedInputStream(
     new FileInputStream("myDatafile.dat")));
   try{
    while(true){
     String name=din.readUTF();
     float marks=din.readFloat();
     boolean val=din.readBoolean();
     System.out.println(name+"   "+marks+"   "+val);
    }
   }catch(EOFException e){
    System.out.println("End of the data file");
   }finally{
    try{
    
    }catch(Exception e){
     din.close();
    }
   }
  }catch(Exception e){
   System.err.println(e.getMessage());
  }
 }
}

Output :

ඉහත code එක මගින් සිදුවන ක්‍රියාවලිය වටහා ගැනීමට උත්සාහ කරමු.

Line  13,14,15 මගින් සුදුසු byte stream එකක් output data stream එකක් මගින් wrap කිරීම සිදුකර ඇත.

Line 17,18,19 මෙහිදී කිසියම් පිලිවෙලකට අනුව data stream එකට දත්ත ලිවීම සිදුකර ඇත. එනම් මුලින් String data ද දෙවනුව float data ද අවසන boolean data ද stream එකට එනම් myDataFile.dat file එකට ලියා ඇත.

Line 31,31,33 මෙහිදී byte stream එකක් input data stream එකක් මගින් wrap කිරීම සිදුකර ඇත. මෙහිදී සාදාගන්නා din object එක හරහා data කියවීම සිදුකෙරේ.

Line 34 - Line 48 මෙහිදී අදාල data file එක අවසන් වනතෙක් කියවීම සිදුකර එම දත්ත console එකෙහි දර්ශනය කරයි.  line 35 න් ආරම්භ වන while loop එක infinite loop එකක් ලෙස පෙනුනද file එකේ අවසානයේ EOFException එකක් throw කරන නිසා file එක අවසානය වනතෙක් පමණක් loop එක ක්‍රියාත්මක වේ.

Streaming වල තවත් වැදගත් කොටසක් වන Standard streams පිලිබඳ අපි මීලඟ පාඩමෙන් සාකච්ඡා කරමු.

Buffered Stream යොදාගෙන File Copy කරන අන්දම

අපි මීට පෙර පාඩමෙන් Buffered stream පිලිබඳව අධ්‍යයනය කලා. අපි මෙම පාඩමෙන් එම සිද්ධාන්ත යොදාගනිමින් File copy කිරීම සඳහා වැඩසටහනක් ලිවීමට උත්සාහ කරමු. මේ සඳහා අපි එම buffered stream classes තුල ඇති read() ,write() , flush(), close() යන methods භාවිතයට ගනිමු. පහත දැක්වෙන්නේ ඒ සඳහා වන කේත කොටසයි.
FileOperations.java

/**       
*class  : FileOperations 
*Author : Kanishka Dilshan       
*Purpose: Using buffered Streams to copy a file  
*Blog   : http://javaxclass.blogspot.com       
*/ 

import java.io.*;

class FileOperations {
 public static final int BUFF_SIZE=8*1024*1024;//8 MB
 
 public boolean fileCopy(String source,String dest){
  boolean isCopied=false;
  BufferedInputStream buffIn=null;
  BufferedOutputStream buffOut=null;
  byte buffer[]=new byte[BUFF_SIZE];
  try{
   buffIn=new BufferedInputStream(new FileInputStream(source),8*1024*1024);
   buffOut=new BufferedOutputStream(new FileOutputStream(dest),8*1024*1024);
   
   int len;
   while((len=buffIn.read(buffer))>0){
    buffOut.write(buffer,0,len);
    buffOut.flush();
   }
   isCopied=true; //file copied successfully
  }catch(FileNotFoundException e){
   System.err.println("Cannot find the file : " + e.getMessage());
  }catch(IOException e){
   System.err.println("IO Error : " + e.getMessage());
  }finally{
   if(buffIn!=null){
    try{
     buffIn.close();
    }catch(IOException e){}
   }   
   if(buffOut!=null){
    try{
     buffOut.close();
    }catch(IOException e){}
   }
  }
  return isCopied;
 }
}  

FileCopy.java

class FileCopy{
 public static void main(String args[]){
  if(args.length!=2){
   System.out.println("Incorrect syntax!");
   System.out.println("Use Following Syntax");
   System.out.println("java FileCopy #source_file# #estination_file#");
   System.exit(0);
  }
  
  FileOperations fo=new FileOperations();
  boolean status=fo.fileCopy(args[0],args[1]);
  if(status==true){
   System.out.println("File was copied successfully!");
  }else{
   System.out.println("File was not copied");
  }
  
 }
}

අපි දැන් ඉහත වැඩසටහනේ ක්‍රියාකාරීත්වය අධ්‍යයනය කරමු.
Line 11 : මෙහිදී BUFF_SIZE ලෙස 8MB constant අගයක් declare කර ගැනීම සිදුකෙරෙනවා. පසුව  buffer එකේ ඇතිදෑ කියවීමට සහ buffer එකට ලිවීමට මෙම constant අගයට අනුව සකසන byte array එකක් යොදාගනු ලබනවා.

Line 12 : boolean isCopied=false; මෙය යොදාගන්නේ file එක සාර්ථකව කොපි වූවාද නැද්ද යන්න return කිරීම සඳහායි.

Line 17 : byte buffer[]=new byte[BUFF_SIZE]; මෙහිදී 8MB ප්‍රමාණයකින් යුතු "buffer" නම් byte array එකක් සකසාගනු ලැබේ.

Line 19, 20 : buffIn සහ buffOut යනුවෙන් buffered stream object 2ක් සකසාගනු ලැබේ(class type සලකා බලන්න) මින් buffIn object එක යොදාගනුයේ source file එක කියවීමටය. එමෙන්ම buffOut යොදාගනුයේ destination file එකට ලිවීමටය. මෙම object සැදිමේදී ඒවාට අදාල buffer size එකද විශේෂයෙන් සඳහන් කර ඇත.

Line 23 : මෙම while loop එක තුලදී මූලිකවම කාර්‍යයන් 2 ක් සිදුකෙරේ len=buffIn.read(buffer) මගින් සිදුකරන්නේ input stream එකෙන් කියවන ලද අගයන් buffer නම් byte array එකේ store කර len නම් int විචල්‍යය තුල කියවන ලද ඩේටා ප්‍රමාණය assign කිරීමයි. 

එහිදී සිදුකරන අනෙකුත් කාර්‍යය නම් එම කියවන ලද ඩේටා ප්‍රමාණය 0 ට වඩා වැඩිද යන්න පරීක්ෂා කර බැලීමයි. කියවන ලද ඩේටා ප්‍රමාණය -1 ලෙස ලැබේ නම් ඉන් ගම්‍ය වනුයේ stream එකෙහි අවසානයට ලඟාවී ඇති බවයි නැතහොත් end of file(EOF) බවයි මෙවිට output stream එකට ලිවීමට අවශ්‍ය නැත. කියවන ලද ඩේටා ප්‍රමාණය 0 නම්ද output stream එකට ලිවීමට අවශ්‍ය නැත.  එම නිසා (len=buffIn.read(buffer))>0 නම් condition එක true නම් පමණක් while loop එක ක්‍රියාත්මකවේ.

Line 24 : buffOut.write(buffer,0,len);   මෙහිදී සිදුකරනුයේ කියවන ලද ඩේටා (byte array එක) output stream එකට ලිවීමයි. 0 සහ len යන parameters වලින් කියවෙනුයේ එම byte array එකේ 0 සිට len යන අගය දක්වා byte ප්‍රමාණය output stream එකට ලිවිය යුතු බවයි.

Line 25 : buffOut.flush(); මෙහිදී output stream එක clear කිරීම සිදුකරයි. 

Line 27 :  while loop එක අවසන් වී මෙම line එකට පැමිණියා යනු file එක සාර්ථකව ලියා අවසන් බවට සහතික විය හැකිය මන්දයත් IO Operations සිදුකර ඇත්තේ exception handle කල හැකි පරිදි try-catch block තුලය. එම නිසා මෙහිදී isCopied නම් විචල්‍යයේ අගය true ලෙස සටහන් කරනු ලැබේ.

Line 32: catch block එක තුලදී සිදුකර ඇති දෑ පහසුවෙන් තේරුම් ගත හැකි නිසා finally block තුලදී කුමක් සිදුවන්නේද යන්න සලකා බලමු. මෙහිදී ඉහත open කරගන්නා ලද input සහ output stream 2ම close කිරීම සිදුකරයි මෙය සිදුකරන්නේ තවත් try-catch block එකක් තුලදීය. 

වැඩසටහන මගින් source file එකේ binary pattern එක ඒ ආකාරයෙන්ම destination file එකේ තිබේ දැයි බැලීමට hash calculator එකක් යොදාගත හැක.

මෙම ක්‍රියාදාමය වටහාගැනීම සඳහා ඉහත පැහැදිලි කිරීම ප්‍රමාණවත් යයි සිතමි. කෙසේ වෙතත් තවදුරටත් පැහැදිලි කල යුතු යමක් ඇත්නම් ඉදිරිපත් කරන මෙන් ඉල්ලා සිටින්න කැමතියි.

ඉහත දක්වා ඇති source code එක සහ byte code files ලබා ගැනීමට පහත දක්වා ඇති link එක භාවිතාකරන්න. 

ජාවා වැඩසටහන් තුල Buffered Stream යොදාගන්නා අයුරු

මීට පෙර පාඩම් වලදී අපි Stream පිලිබඳ කතාකලානෙ අපි මෙම පාඩමෙන් තවත් වැදගත් Stream වර්ගයක් වන Buffered Stream පිලිබඳ අධ්‍යයනය කරමු. 

අපි මීට පෙර සලකා බලන ලද FileInputStream , FileReader යන Stream වර්ග සැලකූ විට කෙලින්ම ඒවා යොදාගෙන කිසියම් resource එකක් භාවිතා කිරීමේදී ඒවායෙන් ලබාදෙන සෑම  read, write request එකක් සඳහාම අදාල resource එක access කිරීම සිදුවනවා. උදාහරණයක් ලෙසට අපි හිතමු  අපිට access කිරීමට අවශ්‍ය resource එක disk file එකක් කියල. එහිදී සෑම read, write request එකකදීම hard disk එකේ අදාල file එක access කිරීම සිදුවනවා. මෙහිදී JVM (Java Virtual Machine) එක විසින් native calls(operating system එකට අදාල low level methods) භාවිතා කිරීම සිදුකෙරෙනවා. එනම් සෑම read, write request එකකටම native calls invoke කිරීමට සිදුවනවා.  තවත් උදාහරණයක් ලෙස අපි සලකමු මෙම resource එක client Socket එකක් කියල. එවිට ඉහත ආකාරයේ buffered නොවන Stream එකක් යොදාගත්තොත් සෑම read, write request එකක් සඳහාම network resources භාවිතාවීම සිදුවනවා. කාර්‍යක්ෂමතාව අතින් සැලකීමේදී මෙය හොඳ විසඳුමක් වන්නේ නැහැ.

ජාවා Byte Streams භාවිතා කරන අයුරු

කලින් පාඩමෙන් අපි කතාකලා ජාවා stream පිළිබඳව.  දැන් අපි බලමු byte stream භාවිතා කරන්නේ කුමනාකාරයෙන්ද කියල. Byte stream එකක් input / output operations සිදු කරනුයේ 8-bit අකාරයටයි.  එනම් character streams වලදී මෙන් නොව මෙහිදී characters වෙනුවට raw bytes කියවීම සහ ලිවීම සිදුකෙරේ. එම නිසා data file copy කිරීම යනාදී වැඩ වලට යොදාගත යුත්තේ byte stream වේ. නමුත් භාවිතාවන data, character වලින් යුක්ත නම් character streams වලට යෑම වඩාත් ඵලදායීවේ.

අහත දැක්වෙන ආකාරයට ජාවා වැඩසටහනක් තුලදී byte streams යොදාගත හැකිය. මෙහිදී I/O Stream නිරූපණය කිරීම සඳහාjava.io පැකේජයේ ඇති FileInputStream සහ FileOutputStream class යොදාගැනේ.

/**      
*class  : ByteOperations
*Author : Kanishka Dilshan      
*Purpose: Showing how to use byte streams
*Blog   : http://javaxclass.blogspot.com      
*/ 


import java.io.*;

public class ByteOperations{
 public static void main(String args[]){
  FileInputStream fileInpStrm=null;
  FileOutputStream fileOutStrm=null;
  try{
   fileInpStrm=new FileInputStream("myDataFile.dat");
   fileOutStrm=new FileOutputStream("newDataFile.dat");
   int tmp;
   while((tmp=fileInpStrm.read())!=-1){
    fileOutStrm.write(tmp);
   }

  }catch(FileNotFoundException e){
   System.err.println("File NOt Found : " + e.getMessage());
  }catch(IOException e){
   System.err.println("IO Exception : " + e.getMessage());
  }finally {
   try{
    if(fileInpStrm!=null){
     fileInpStrm.close();
    }
      }catch(IOException e){}
   try{   
    if(fileOutStrm!=null){
     fileOutStrm.close();
    }
   }catch(IOException e){}
  }
 }
}

මෙහිදී සිදුවනුයේ myDataFile.dat file එකේ clone එකක් newDataFile.dat ලෙසින් සෑදීමයි. පෙර පරිදිම මෙහිදීද open කරන ලද ස්ට්‍රීම් close කර තිබේ.  

FileInputStream යනු InputStream යන abstract class එකෙහි child class එකක් වේ.  ඒම class අතර සම්බන්දය පහත පරිදි වේ.

තවත් ස්ට්‍රීම් වර්ග හා ඒවා යොදාගන්නා ආකරයන් පිලිබඳව අපි ඉදිරි පාඩම් වලදී සාකච්ඡා කරමු.

ජාවා තුල යෙදෙන I/O Streams යනු මොනවාද | Java I/O Streams

සියලුම පරිගණක භාෂාවන් හි Input සහ Output ක්‍රියාවලීන් සිදුකර ගැනීමට කිසියම් යාන්ත්‍රණයක් පවතිනවා. උදාහරණයක් වශයෙන් කිසියම් calculation එකක් සඳහා ලියන ලද පරිගණක  වැඩසටහනකට දත්ත input කිරීමට සහ එහි ප්‍රතිඵලය පිටතට ලබාදීම සඳහා යොදාගන්නා ක්‍රම සැලකිය හැකිය.

ජාවා වැඩසටහන් තුලදී Input සහ Output ක්‍රියාවලීන් සිදුකරගැනීමට විවිධ ක්‍රම පවතී ඒවා නම් Streams, Files, Channels යනාදී වශයෙනි. අපි මෙහිදී වැඩිදුරටත් සාකච්ඡා කරනුයේ ජාවා තුල යෙදෙන Streams පිලිබඳවයි.