Technology Blogs

SAX Parser

2008-07-18T17:43:00.000-07:00

Event driven XML parsing: XML parsing can be done in a variety of ways. But mainly it can be classified into two main parts -Event driven and DOM Tree Structure driven. In this blog we discuss an implementation of Event driven XML parsing.

Event driven approach is used when the XML to be parsed is a large size xml, because it will generate events every now and then and give call backs to your event handler class. Let us now see how this can be accomplished.

The main interfaces we are using here are XMLReader and ContentHandler.

XMLReader is the main interface that has methods to set the event handler and initiating the parse. If you are wondering who provides the class for this interface, it is the XML parsers SAX2 driver. XMLReaderFactory fetches the actual class and gives us a handle to it.

Besides the above mentioned tasks, XMLReader allows us to to set and query features and properties in the parser, to register event handlers for document processing, and to initiate a document parse.

All SAX interfaces are assumed to be synchronous: the parse methods must not return until parsing is complete, and readers must wait for an event-handler callback to return before reporting the next event.

ContentHandler is the main interface that most SAX applications implement: if the application needs to be informed of basic parsing events, it implements this interface and registers an instance with the SAX parser using the setContenthandler method. The parser uses the instance to report basic document-related events like the start and end of elements and character data.

Let us now see an implementation of the SAXParser.

Code Sample for the event handler class - An instance of this class would be used to set the content handler for the XMLReader interface. Note the callbacks in the methods. These would get called as events as soon as you initiate parse of XMLReader interface.In the TODO section you can embed your code.

public class XMLContentHandler implements ContentHandler
{

public void characters(char[] arg0, int arg1, int arg2) throws SAXException
{
}

public void endDocument() throws SAXException
{
}

public void endElement(String arg0, String arg1, String arg2) throws SAXException
{
}

public void endPrefixMapping(String arg0) throws SAXException
{
}

public void ignorableWhitespace(char[] arg0, int arg1, int arg2) throws SAXException
{
}

public void processingInstruction(String arg0, String arg1) throws SAXException
{
}

public void setDocumentLocator(Locator arg0)
{
}

public void skippedEntity(String arg0) throws SAXException
{
}

public void startDocument() throws SAXException
{
}

public void startElement(String arg0, String arg1, String arg2, Attributes arg3) throws SAXException
{
}

public void startPrefixMapping(String arg0, String arg1) throws SAXException
{
}

}

Finally the method that creates a XMLReader and initiates the parse of XML document. The variable xmlPath has to contain the system specific path of XML file.

public void parseXML()
{
try
{
InputSource xmlSource = new InputSource();
xmlSource.setCharacterStream(new FileReader(new File(xmlPath)));
XMLReader xmlReader = XMLReaderFactory.createXMLReader();
xmlReader.parse(xmlSource);
xmlReader.setContentHandler(new XMLContentHandler());
}
catch (FileNotFoundException e1)
{
}
catch (IOException e2)
{
}
catch (SAXException e3)
{
}
catch (Exception e4)
{
}
}

Factory Patterns

2008-07-18T15:27:00.000-07:00

Dynamic Method dispatch and Factory patterns
Factory patterns are almost always used in conjunction with function overloading feature in Java. This feature is also called Dynamic method dispatch. This is a runtime java feature wherein hierarchy of classes exist each providing an implementation of the same methods. The decision of which implementation to load and execute is taken entirely at runtime.
Let us look at an example to understand it clearly:
Consider a class called ‘Shell’ with a method called execute() which is supposed to execute shell commands. Now the commands can be meant for the local system shell or a remote shell. Thus we have two more classes providing implementation for the method ‘execute()’ – RemoteShell and LocalShell.
At runtime let us assume that the utility takes a decision of which shell to use on the basis of some input from some XML file. We can very easily write the logic that decides for us which of the two subclasses are meant to be executed in the current scenario. Now this particular piece of code would get repeated at every place we want to invoke the Shell. This might also include the initialization logic of each class.
Ex.
If remote required
Initialize the RemoteShell class.
Call the execute.
Else If local required
Initialize the LocalShell class.
Call the execute.
End If
It is this repetition of code that factory patterns can help us avoid. The implementation is simple.
Create a ShellFactory class with a method for getting Instance of the base class Shell. On the basis of what input you pass to the method, the ShellFactory initializes one of the two subclasses and returns a reference
Shell getInstance(arguments) returns base class object Shell
{
If Remote
Init and Return new RemoteShell object
If Local
Init and Return new LocalShell object
}
Usage:
ShellFactory.getInstance(args).execute()
Benefits:
1. No repetition of class instantiation logic
2. No repetition of ‘which class to invoke’ logic

Reflections

2008-07-17T09:31:00.000-07:00

Reflections – Method
Reflection is an important aspect of Java programming, with widespread usage in huge architectures.
Reflections are a set of classes and interfaces provided with the the java.lang.reflect package. It allows programmatic access to information about fields, methods and constructors of loaded classes. In this blog we discuss about Method class that provides information pertaining to the methods of the loaded class, and allows invocation of a method, using the API’s. The steps we follow here are :
1. Get handle to the correct method using getName() method.
2. Invoke the method passing the object and the arguments.
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectExample
{
private String message;
public ReflectExample()
{
}
public void setMessage(String message)
{
this.message = message;
}
public String getMessage()
{
return message;
}
public static void main(String args[])
{
ReflectExample loadedObject = new ReflectExample();
Method[] methods = loadedObject.getClass().getMethods();
for(int i = 0 ;i less methods.length;i++)
{
if(methods[i].getName().equals("setMessage"))
{
try
{
methods[i].invoke(loadedObject, new Object[]{"This message has been set via reflections"});
}
catch (IllegalArgumentException e)
{
e.printStackTrace();
}
catch (IllegalAccessException e)
{
e.printStackTrace();
}
catch (InvocationTargetException e)
{
e.printStackTrace();
}
}
}
System.out.println(loadedObject.getMessage());
}
}

Command Line Executor in Java

2008-07-17T00:39:00.000-07:00

Have you ever wanted to open a notepad through your java code when running on Windows? Or for that matter have you ever wanted to get hold of the system command prompt and execute system specific processes? This blog explains how it can be achieved.

Java exposes a class - Runtime that solves our problem. It has a method called "exec" that can be used to call any system specific commands. The method returns an instance of class Process that is the java representation of the process that gets initiated.

Sample Code - CommandLine

public class CommandLine
{

public CommandLine()
{
}

public static void runCommand(String pCommands)
{
Process objProcess = null;
try
{
objProcess = Runtime.getRuntime().exec(pCommands);
}
catch(Exception err)
{
}
}
}

To run a command the java code code would be something like this:

CommandLine.runCommand("notepad.exe ");

Anonymous Inner classes

2008-07-16T11:42:00.000-07:00

Anonymous Inner classes

I have had a bad experience in understanding anonymous inner classes and that is one of the motivations in me deciding to post this blog. Let us try to understand anonymous inner classes literally first. Anonymous means ‘having no name’. Inner specifies that the class resides inside another class. So why do we need such a class? Firstly it reduces time and effort in writing another class that we might have to write in absence of this Java feature. Secondly some classes need to be present at many places but at each place the functionality demands are different, here the true powers of inner classes are revealed.(This will become evident once we see the example) Without wasting much time let us look at a real example.

Action listeners for buttons are classes that implement ActionListener interface, and provide a method called ‘actionPerformed’, which is a callback each time a button is pressed. Now if the form you are working on contains a hell lot of buttons each performing menial tasks you don’t want to write a separate listener class for each of these. Neither do you want to add just one class for all buttons where you would be forced to write multiple if-else blocks to find out which button produced the event.

In such a scenario, first create a class implementing ActionListener interface

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ActionListenerController implements ActionListener
{

public void actionPerformed(ActionEvent event)
{
//Override this method where used as an inner class.
}

}

Now to add an instance of this class to your buttons do the following. This same approach an be applied to all your buttons.
button.addActionListener(new ActionListenerController()
{
public void actionPerformed(ActionEvent event)
{
//Write your code here
}
});

Swings File chooser

2008-07-14T09:33:00.000-07:00

File Chooser in Java Swings:

Many Core Java single system applications require the user to choose a file/ folder as part of input to the utility built. Since this can be quite an irritating task if you let the user key in the path to the file or the folder, Java comes up with a JFileChooser class that lets the user browse the file system and choose using a visual interface. This is how you use it:

Firstly add a button for the file browsing to start. Next to the listener add the following piece of code.

JFileChooser chooser = new JFileChooser("");

chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);

//Sets the selection mode to files,can be changed to Folders

int option = chooser.showOpenDialog(frame);

//Opens the dialog for choosing file

if (option == JFileChooser.APPROVE_OPTION)

{

File dir = chooser.getSelectedFile();

System.out.println(dir.getPath());

//Prints the path selected by the user

}

Thus you see it is very easy to add file browsing functionality to your Java program.

An abstract class named FileFilter can be used to restrict user selection to specific file formats. In your chooser class you can set the file filter with an overridden ‘accept’ method that tells you whether the file is in the acceptable format. The file chooser dialog opens up with that file type as default. However it is a weak restriction and allows the user to select other file types and proceed. Any validations have to be handled explicitly.

chooser.setFileFilter(new FileFilter()

{

public boolean accept(File f)

{

return f.getName().toLowerCase().endsWith(".xls");

}

public String getDescription()

{

return ".xls files";

}

});

File Transfer Protocol Utility

2008-07-13T09:28:00.000-07:00

File Transfer Protocol
FTP is a network protocol based on TCP, which facilitates movement of files over the network. In this blog I post a sample utility as an attachment that can be used for doing file transfers. This utility uses the apache commons net API’s to achieve it. I will briefly explain the methods that are part of the utility.
The main FTP class we use here is FTPClient. It contains API’s to do a hell lot of things, which you will come across when you start inspecting the code. The main helper methods are:
1. Upload – Transfer a local file to a remote Ftp server
2. Download – Transfer a remote file to local machine.
3. CreateRemoteDirectory – Create a new remote directory.
4. DeleteRemoteFile – Delete a remote file.
5. RemoteDirectoryExists – Returns true if remote directory exists
6. RemoteFileExists – Returns true if remote file exists.
Check out the util by clicking on the icon below:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPConnectionClosedException;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;
public class FTPUtil
{
FTPClient ftp = null;
private static String url;
private static String user;
private static String password;
private static String remoteFileSeparator;
private static String localFileSeparator;
static
{
url = "<<>>";
user = "<<>>";
password = "<<>>";
remoteFileSeparator = "<<>>";
localFileSeparator = "<<>>";
}
public void Upload(String remoteFilePath, String localFilePath, String fileName) throws Exception
{
FTPClient ftp = new FTPClient();
try
{
ftp.connect(url);
if (ftp.login(user, password))
{
if (!FTPReply.isPositiveCompletion(ftp.getReplyCode()))
{
ftp.disconnect();
throw new Exception("FTP Login failed");
}
ftp.setFileType(FTP.BINARY_FILE_TYPE);
InputStream input = new FileInputStream(localFilePath + localFileSeparator + fileName);
boolean status = ftp.storeFile(remoteFilePath + remoteFileSeparator + fileName, input);
if (status)
{
input.close();
ftp.logout();
}
else
{
throw new Exception("Upload failed");
}
}
else
{
throw new Exception("FTP Connection failed");
}
}
catch (FTPConnectionClosedException ftpConnectionClosedException)
{
throw ftpConnectionClosedException;
}
catch (IOException ioException)
{
throw ioException;
}
finally
{
closeFTPConnection(ftp);
}
}
public void Download(String remoteFilePath, String localFilePath, String filename) throws FTPConnectionClosedException, IOException, Exception
{
FTPClient ftp = new FTPClient();
try
{
ftp.connect(url);
if (ftp.login(user, password))
{
if (!FTPReply.isPositiveCompletion(ftp.getReplyCode()))
{
ftp.disconnect();
throw new Exception("FTP login failed");
}
FileOutputStream fileOutputStream = new FileOutputStream(localFilePath + localFileSeparator + filename);
boolean status = ftp.retrieveFile(remoteFilePath, fileOutputStream);
fileOutputStream.close();
if (!status)
{
throw new Exception("Download failed");
}
}
else
{
throw new Exception("FTP Connection failed");
}
}
catch (FTPConnectionClosedException ftpConnectionClosedException)
{
throw ftpConnectionClosedException;
}
catch (IOException ioException)
{
throw ioException;
}
finally
{
closeFTPConnection(ftp);
}
}
public static boolean RemoteFileExists(String remoteFilePath, String fileName) throws FTPConnectionClosedException, IOException, Exception
{
FTPClient ftp = new FTPClient();
try
{
ftp.connect(url);
if (ftp.login(user, password))
{
if (!FTPReply.isPositiveCompletion(ftp.getReplyCode()))
{
ftp.disconnect();
throw new Exception("FTP login failed");
}
FTPFile[] files = ftp.listFiles(remoteFilePath + remoteFileSeparator + fileName);
if (files.length == 0)
{
return false;
}
else
{
return true;
}
}
else
{
throw new Exception("Invalid login details");
}
}
catch (FTPConnectionClosedException ftpConnectionClosedException)
{
throw ftpConnectionClosedException;
}
catch (IOException ioException)
{
throw ioException;
}
finally
{
closeFTPConnection(ftp);
}
}
public static boolean RemoteDirectoryExists(String remoteDirPath) throws FTPConnectionClosedException, IOException, Exception
{
FTPClient ftp = new FTPClient();
try
{
ftp.connect(url);
if (ftp.login(user, password))
{
if (!FTPReply.isPositiveCompletion(ftp.getReplyCode()))
{
ftp.disconnect();
throw new Exception("FTP login failed");
}
return (ftp.changeWorkingDirectory(remoteDirPath));
}
else
{
throw new Exception("Invalid login details");
}
}
catch (FTPConnectionClosedException ftpConnectionClosedException)
{
throw ftpConnectionClosedException;
}
catch (IOException ioException)
{
throw ioException;
}
finally
{
closeFTPConnection(ftp);
}
}
public void DeleteRemoteFile(String path, String filename) throws FTPConnectionClosedException, Exception
{
FTPClient ftp = new FTPClient();
try
{
ftp.connect(url);
if (ftp.login(user, password))
{
if (!FTPReply.isPositiveCompletion(ftp.getReplyCode()))
{
ftp.disconnect();
throw new Exception("FTP Login failed");
}
if (!ftp.deleteFile(path + filename))
{
throw new Exception("Delete failed");
}
}
else
{
throw new Exception("Invalid login details");
}
}
catch (FTPConnectionClosedException ftpConnectionClosedException)
{
throw ftpConnectionClosedException;
}
finally
{
closeFTPConnection(ftp);
}
}
public void CreateRemoteDirectory(String path) throws FTPConnectionClosedException, Exception
{
FTPClient ftp = new FTPClient();
try
{
ftp.connect(url);
if (ftp.login(user, password))
{
if (!FTPReply.isPositiveCompletion(ftp.getReplyCode()))
{
ftp.disconnect();
throw new Exception("FTP login failed");
}
ftp.mkd(path);
}
else
{
throw new Exception("Invalid login details");
}
}
catch (FTPConnectionClosedException ftpConnectionClosedException)
{
throw ftpConnectionClosedException;
}
finally
{
closeFTPConnection(ftp);
}
}
private static void closeFTPConnection(FTPClient ftp)
{
if (ftp.isConnected())
{
try
{
ftp.disconnect();
}
catch (IOException e1)
{
}
}
}
}

XSD Validation

2008-07-13T00:46:00.000-07:00

It has only been a day since my first info blog, and I just cannot wait to write a new one. Have you ever faced difficulties in implementing a validation for you xml document? There are precisely two ways of doing XML validation.

First of these is using a DTD document. A hell lot of effort goes in writing dtd and even if you manage to write it, it is not easy to comprehend.

An easier way of achieving the same is using XSD documents. Benefits are quite evident, if you get the hang of it. Here in this info blog I share with you a snippet that demonstrates how it is done.

XML validation function:

private boolean IsXmlValid()
{
try
{
SchemaFactory factory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
File schemaLocation = new File(xsdPath);
Schema schema = factory.newSchema(schemaLocation);
Validator validator = schema.newValidator();
DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
domFactory.setNamespaceAware(true);
DocumentBuilder builder = domFactory.newDocumentBuilder();
Document doc = builder.parse(new File(xmlPath));
DOMSource source = new DOMSource(doc);
DOMResult result = new DOMResult();
validator.validate(source, result);
return true;
}
catch (SAXException ex)
{
return false;
}
catch (Exception ex)
{
return false;
}
}
}
The method returns true if the XML complies with the XSD. The xsdpath and xmlPath have to be replaced with actual files paths.

Connection using DriverManager

2008-07-09T09:25:00.000-07:00

Let us start with a little basics about database connections in Java. The first question that might intrigue someone is why does Java have Connection as an interface rather than a class. This is because different databases have different implementations of the Connection class, ie when you get a connection object for an Oracle database the implementing class is oracle.jdbc.driver.OracleConnection. Some other database would have some other class that implements the java.sql.Connection interface. Thus each database company comes up with its own database driver that will provide the implementation of Connection as a full fledged class.
DriverManager is the basic service for managing a set of JDBC drivers. When referenced the DriverManager loads the driver classes referenced in the jdbc.drivers system property. However this is hardly ever used. The application that you are developing loads a driver class explicitly before trying to obtain a Connection. This is generally done by using Class.forName() method.
When the method getConnection is called, the DriverManager will attempt to locate a suitable driver from amongst those loaded at initialization and those loaded explicitly using the same classloader as the current applet or application.
The following code snippet explains the procedure to obtain a database connection using Drivermanager class:

public static Connection getConnection() throws ClassNotFoundException, SQLException
{
Connection conn = null;
String ip = "enter the ip address of database server";
String port = "enter the port at which db server is listening";
String sid = "enter the datasource name as in tnsnames.ora dsn";
String uname = "enter db user";
String pwd = "enter the db password";
try
{
Class.forName("oracle.jdbc.driver.OracleDriver");
//Loads the Oracle driver.
//The DriverManager will now start using this Driver to fetch implementation of Connection
String url = "jdbc:oracle:thin:@" + ip + ":" + port + ":" + sid;
//Create the URL for an Oracle database
conn = DriverManager.getConnection(url, uname, pwd);
//DriverManager uses oracle.jdbc.driver.OracleDriver to return oracle.jdbc.driver.OracleConnection
return conn;
}
catch (ClassNotFoundException e1)
{
throw e1;
}
catch (SQLException e2)
{
throw e2;
}
}

Reading Excel POI

2008-07-08T16:34:00.000-07:00

Reading Microsoft Excel 97 files through a Java program using Apache POI HSSF project:

Apache POI project is centered on providing API’s for easy read and write capabilities over Microsoft format files. For reading excel files, there is a HSSF project which currently supports only Excel’97. That is it does not support the .xlsx files. In this blog I will explain the methodology to be used for reading .xls files through this Java API.

The first step is to initialize an object named POIFSFileSystem. This can be done as follows:

String excelFilePath = “C:\\Temp\a.xls”;

FileInputStream file = new FileInputStream(excelFilePath);

POIFSFileSystem poifsFileSystem = new POIFSFileSystem(file);

Secondly you initialize two more objects: HSSFWorkbook and HSSFSheet

HSSFWorkbook hssfWorkBook = new HSSFWorkbook(poifsFileSystem);

HSSFSheet hssfSheet = hssfWorkBook.getSheetAt(0);

The getSheetAt(index) method specifies which sheet index you want to be read. The index for the first sheet in an Excel sheet is 0. Now suppose you want to iterate over the rows of the Excel sheet. This requires another object named HSSFRow. Iteration can be achieved using the following code:

HSSFRow hssfRow = hssfSheet.getRow(1);

int count = 1;

while (hssfRow != null)

{

hssfRow = hssfSheet.getRow(count++);

if (hssfRow != null)

{

System.out.println(hssfRow.getCell((short) 0).getStringCellValue());

//first column String printed

System.out.println(hssfRow.getCell((short) 1). getNumericCellValue());

//Numeric second column printed

}

}

Thus you can see POI gives you an extremely structured way of accessing Excel files. More about POI can be found at http://poi.apache.org/index.html.

Timers in Java

2008-07-07T10:18:00.000-07:00

Timer and TimerTask Classes
A task that needs to be scheduled to happen after a certain time interval, or an action that needs to be performed periodically, can be achieved using java.util.Timer and java.util.TimerTask classes in Java.
Timer and TimerTask have been provided as helpers to Threads.
TimerTask is essentially an abstract class that has a method called run(). To initialize this class all one has to do is provide an implementation of this method either inside a class extending TimerTask or inside an anonymous inner class block. The method run() should contain all the logic that is expected to run periodically.
No comes the Timer which contains methods to schedule the timer task.The most often used method is
A. Fixed Delay
schedule(TimerTask task, long delay, long period)
Schedules the specified task for repeated fixed-delay execution, beginning after the specified delay.
The delay argument takes as input time in milliseconds after which the first call to the task’s run method would be made.
The period argument takes as input the time lapse, in milliseconds, after the execution of the previous execution, for which the task should wait before making another call. That is the timer task would get called after fixed delays.
B. Fixed Rate
scheduleAtFixedRate(TimerTask task, long delay, long period)
This method schedules the execution of the timer task such that irrespective of how much time it takes to execute a previous call; fresh calls to the task must be made at a fixed rate. That is the timer task would get called at a fixed rate.
Code Fragment:
try
{
int delay = 1000; // delay for 1 sec.
int period = 5000; // repeat every 5 sec.
Timer timer = new Timer();
timer.scheduleAtFixedRate(new TimerTask()
{
public void run()
{
// Add the action code here
}
}, delay, period);
}
catch (Exception e)
{
e.printStackTrace();
}

Unzip a file using Java API's

2008-07-05T14:16:00.000-07:00

UnZipping a Zip file using Java APIS.
Java provides support for WinZip. To achieve this Java comes up with two utility classes called ZipEntry and ZipFile. Achieving unzip functionality is simple and does not require more than 5-6 lines of code. Though copying files using Streams can take up time.
First thing that needs to be done here is instantiation of ZipFile. To the contructor all you need to pass is the system path to the zip file you wish to unzip.
eg. new ZipFile(strFilePath + "\\" + strFileName);
Now this class exposes a method called "entries()" that returns an enumeration of ZipEntry classes. Simple iteration logic over this enumeration type gets us handles to each and every file there is inside the zip file.
The next step is initializing input and output streams. The logic to get the output stream is simple. Just create a directory using mkdirs() method of File class and initialize an FileOutputStream for that location.
The step for getting the input stream is a bit complicated:
objInputStream = objZipFile.getInputStream(objZipEntry);
Here onbjZipEntry is the current Zip entry that is getting processed out of the enumeration.
Now simply copy the file from the input to the output stream
Given below is the source file telling you how to achieve this. Check and modify the main as you wish.

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
public class ZipUtil
{
public static void doProcessZip(String strFilePath, String strFileName)
{
FileOutputStream objFileOutputStream = null;
InputStream objInputStream = null;
ZipEntry objZipEntry = null;
Enumeration objEnumeration = null;
ZipFile objZipFile = null;
try
{
objZipFile = new ZipFile(strFilePath + "\\" + strFileName);
for (objEnumeration = objZipFile.entries(); objEnumeration.hasMoreElements();)
{
objZipEntry = (ZipEntry) objEnumeration.nextElement();
if (objZipEntry.getName().indexOf("/") > 0)
{
new File(strFilePath + "\\" + strFileName.substring(0, strFileName.indexOf('.')) + "\\" + objZipEntry.getName().substring(0, objZipEntry.getName().indexOf("/"))).mkdirs();
}
else
{
(new File(strFilePath + "\\" + strFileName.substring(0, strFileName.indexOf('.')))).mkdir();
}
objFileOutputStream = new FileOutputStream(strFilePath + "\\" + strFileName.substring(0, strFileName.indexOf('.')) + "\\" + objZipEntry.getName());
objInputStream = objZipFile.getInputStream(objZipEntry);
copyInputStream(objInputStream, objFileOutputStream);
}
}
catch (FileNotFoundException e)
{
e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
}
}
public static final void copyInputStream(InputStream in, FileOutputStream fout) throws IOException
{
byte buffer[] = new byte[1024];
int len;
while ((len = in.read(buffer)) >= 0)
{
fout.write(buffer, 0, len);
}
in.close();
fout.close();
}
public static void main(String args[])
{
doProcessZip("c:\\", "abc.zip");
}
}

XSL Transforms

2008-07-04T11:40:00.000-07:00

This blog explains java implementation of XSL transformations. Let us try and understand a few basic things about XSL transforms. XSL is the standard used to add rendering information to xml documents. XML contains raw data that has to be rendered to the user in various formats. XSL files contain the logic required to read the xml file and transform it to the required format. This transformation is generally to html, so that data can be presented to the user in a format that makes more sense to him. Thus we would need two files an xml document, and a corresponding XSL document. The XSL would read the XML and transform it to html which would be streamed out to a result.html file.

import java.io.File;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
public class XSLTransformer
{
public static void main(String[] args)
{
Source xmlSource = new StreamSource(new File("transform.xml"));
Source xslSource = new StreamSource(new File("transform.xsl"));
Result htmlResult = new StreamResult(new File("result.html"));
try
{
Transformer transformer = TransformerFactory.newInstance().newTransformer(xslSource);
try
{
transformer.transform(xmlSource, htmlResult);
}
catch (TransformerException e)
{
e.printStackTrace();
}
}
catch (TransformerConfigurationException e)
{
e.printStackTrace();
}
catch (TransformerFactoryConfigurationError e)
{
e.printStackTrace();
}
}
}

Java - Exception Handling

2008-07-02T20:10:00.000-07:00

Exception handling
Exceptions are unexpected occurrences/execution time errors in a program that denotes a situation where the Java runtime needs assistance from the programmer about what to be doing next. When you program for an Exception, in other words, when you write Exception handling code, you are doing just that. Whenever your program causes an error, Java throws an exception. Exception has been treated just like another object in Java, and this object carries information about the exception that occurred.
JRE looks for a program block that is waiting to catch an Exception.
It follows the following sequence while doing the same:
1. If the statement that caused the error is lying inside a try – catch block, the control gets passed to that part of the code. After catch, the execution continues outside of the try-catch block.
2. If the statement is without a try - catch block, the JRE looks upwards of the call stack trace to find out a try block that surrounds the call and the control gets passed to the catch block of that try. The execution then continues after that try-catch block. If suppose there are no try blocks surrounding the call, the exception is caught by the main thread exception handler that prints the exception and terminates the program.
When to write exception handlers
1. Checked Exceptions: These are usually errors in the input data. The programmer has no control over the input the user gives you, for example FileNotFoundException when the file path is not a valid path. Such exceptions are to be handled, java compiler forces you to write exception handlers for these types of exceptions and the programmer is supposed to decide the future course of the program in the catch block.
When not to write exception handlers
1. Programmatic errors: Unchecked Exceptions like NullPointerException, ArrayIndexOutofBoundsException can generally be avoided by performing null checks or size of array checks before making calls to methods that can give rise to these errors. Handling these exceptions is not desirable because if these exceptions do occur it means there is a problem with the code and the code needs fixing rather than exception handling.
When to eat Exceptions
1. Eating exceptions refers to ignoring of an exception in a catch block and allowing the program to execute further. These are occurrences where you do not want the execution to stop. i.e. though there has been an error, it is not big enough to stall the program execution.
When to throw Exceptions
1. Exception handling generally is cascaded across various Java classes, ie an exception that occurs at a class would impact a whole hierarchy of calls. This is generally the case when handling transactions. In such cases the exception must be caught at the very start of the call trace. Thus all exception handling (for exceptions that must stall the transaction) in all intermediate classes does only one thing, and that is to throw the exception to the previous calling block.

Singleton Patterns

2008-07-02T16:45:00.000-07:00

Since this is the first blog ever on this domain, let us start with something simple about Design patterns in Java. People having some acquaintance with design patterns would understand why I say this? So let's dive in to the simplest design patterns of all - Singletons

When are they used? Singletons are classes that are usually meant to act as system level variables. What do I mean? Since there is no concept of System variables in Java, it happens quite often that there are unwanted variables across Java classes that store the same content. Singletons are classes that will get instantiated only once, that is only one instance would be created for the entire program life cycle. And that single instance will have all the content you need every now and then. Such content is most of the times read from a .properties file. Thus the example used here would be based on that.

import java.io.*;
import java.util.*;
public class PropertiesUtil
{
private static HashMap mapEntries = new HashMap();
private static PropertiesUtil propertiesUtil;
protected PropertiesUtil()
{
initialize();
}
public static PropertiesUtil getInstance()
{
if (propertiesUtil != null)
{
return propertiesUtil;
}
else
{
propertiesUtil = new PropertiesUtil();
return propertiesUtil;
}
}
private void initialize()
{
InputStream propertiesFile = null;
Properties properties = new Properties();
Iterator keysIterator = null;
String key = null;
try
{
propertiesFile = new FileInputStream(".//application.properties");
properties.load(propertiesFile);
propertiesFile.close();
}
catch (IOException ioe)
{
}
keysIterator = properties.keySet().iterator();
while (keysIterator.hasNext())
{
key = keysIterator.next().toString();
mapEntries.put(key, properties.get(key));
}
}
public String getProperty(String key, String defaultValue)
{
if (mapEntries.get(key) != null)
{
return mapEntries.get(key).toString().trim();
}
else
{
return defaultValue;
}
}
}
Should anyone need, would explain the working of the code in future posts.

BFN!

Copying a file in Java without using Streams

2008-07-02T11:31:00.000-07:00

Copying a file from one location to another is a hectic while loop if you are using Streams. The guys from Java have come up with a solution using FileChannel class. This article explains how to use the FileChannel class to copy a file. First of all we need two FileChannel objects one for the original file and another for the destination file. The class has a transferTo() method that can be used to accomplish what we desire. It takes three arguements, the first one specifying the start position of copy in long , the second one giving the size of input file and the third specifying the output channel. click on the link below to see the actual code fragment:

public static void copyFile(File in, File out) throws IOException
{
FileChannel inChannel = new FileInputStream(in).getChannel();
FileChannel outChannel = new FileOutputStream(out).getChannel();
try
{
inChannel.transferTo(0, inChannel.size(), outChannel);
}
catch (IOException e)
{
throw e;
}
finally
{
if (inChannel != null)
inChannel.close();
if (outChannel != null)
outChannel.close();
}
}

Secure Shell - Unix Java

2008-07-02T09:36:00.000-07:00

Secure Shell – Linux/Unix

Secure Shell or SSH is a network protocol that allows data to be exchanged using a secure channel between two computers. Encryption provides confidentiality and integrity of data over an insecure network, such as the Internet. SSH uses public-key cryptography to authenticate the remote computer and allow the remote computer to authenticate the user, if necessary.

SSH is typically used to log into a remote machine and execute commands, but it also supports tunneling, forwarding arbitrary TCP ports and X11 connections; it can transfer files using the associated SFTP or SCP protocols.SSH uses the client-server protocol.

An SSH server, by default, listens on the standard TCP port 22.

An SSH client program is typically used for establishing connections to an SSH daemon accepting remote connections. Both are commonly present on most modern operating systems, including Mac OS X, Linux, FreeBSD, Solaris and OpenVMS. Proprietary, freeware and open source versions of various levels of complexity and completeness exist.

Here in this blog I want to share the Java methodology of connecting to a UNIX/LINUX box and executing remote commands on the remote machine. The third party jar we use in this example is jsch-0.1.38.jar.

The following method takes in the directory on the remote machine from where you want the command to execute. It takes in the command and the argument you wish to pass with the command.

public static void rexec(String dir, String command, String arg) throws Exception

{

JSch jsch = new JSch();

String output = null;

Session session = null;

Channel channel = null;

InputStream in = null;

int port = 22;

byte tmp[] = new byte[1024];

try

{

session = jsch.getSession(user, server, port);

session.setPassword(password);

java.util.Properties config = new java.util.Properties();

config.put("StrictHostKeyChecking", "no");

session.setConfig(config);

session.connect();

channel = session.openChannel("exec");

((ChannelExec) channel).setCommand("cd " + dir + ";" + command + " " + arg);

channel.setInputStream(null);

((ChannelExec) channel).setErrStream(System.err);

in = channel.getInputStream();

channel.connect();

}

catch (Exception e)

{

throw e;

}

}

Abstract Factory Patterns

2008-07-01T16:38:00.000-07:00

Factory patterns

Anyone having little acquaintance with Java would have at some point in time used factories to obtain objects that would provide them with utility methods. The use of Factory patterns is quite simple. It helps the developer delegate the responsibility of creation of the right object at runtime to a separate class. Thus the main factory class always has a method that returns objects of type Base class. To give an idea, let there be a class named ‘Feature’ and several subclasses of class ‘Feature’. Now it may be required to get handles to subclass objects, without having to know the actual class that should be initialized at runtime. A Factory can come as a help, where in a method that takes an argument would create the desired class and return the object to the calling method.

Rather than creating a working example for this pattern, we will see an existing Factory pattern in Java.

The example that we use here is DocumentBuilderFactory.

It has a static method to get an instance of the class. It does an ordered lookup to determine the implementation of the Factory class to load.

->Use the javax.xml.parsers.DocumentBuilderFactory system property.

->Use the properties file "lib/jaxp.properties" in the JRE directory. This configuration file is in standard java.util.Properties format and contains the fully qualified name of the implementation class with the key being the system property defined above. The jaxp.properties file is read only once by the JAXP implementation and it's values are then cached for future use. If the file does not exist when the first attempt is made to read from it, no further attempts are made to check for its existence. It is not possible to change the value of any property in jaxp.properties after it has been read for the first time.

->Use the Services API (as detailed in the JAR specification), if available, to determine the classname. The Services API will look for a classname in the file META-INF/services/javax.xml.parsers.DocumentBuilderFactory in jars available to the runtime.

->Platform default DocumentBuilderFactory instance.

Now we call the newDocumentBuilder method to obtain a class that will have APIs to convert XML documents to DOM document instances. The DocumentBuilder has a method called newDocument() that returns an object of type Document.

If you wish to see which classes provide the implementation for the above interfaces you can do it using the following snippet.

System.out.println(" Factory implementation class : " + DocumentBuilderFactory.newInstance().getClass());
System.out.println(" Builder implementation class : " + DocumentBuilderFactory.newInstance().newDocumentBuilder().getClass());
System.out.println(" Document implementation class : " + DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument().getClass());
The output could vary from system to system but most probably would be this:

Factory implementation class : class com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl

Builder implementation class : class com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderImpl

Document implementation class : class com.sun.org.apache.xerces.internal.dom.DocumentImpl

Thus we see that the factory pattern here helps us manufacture the correct implementation of another factory, which in turn leads us to correct objects.