TECHNICAL ANNEX

Code/Syntax Highlight in Blog

2015-03-16T21:16:00.003+05:30

Its always a good practice to write a well formed and well managed source code but after putting much effort to write a nice and clean piece of code we often come into a situation that when we post it on Blogs or on Web pages it doesn't look as nice as it should look.

Have a look at below java code:

public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!"); // Display the string.
}
}

I really don't like that my code looks like this and I am sure you also don't like it. but what if the same code looks like below:

public class HelloWorld {

    public static void main(String[] args) {

        System.out.println("Hello World!");  // Display the string.

    }

}

This looks very neat and clean, right?

SyntaxHighlighter by Alex Gorbatchev is the most popular and easy to use Java script API to highlight you source code.

Just to steps to add SyntaxHighlighter to your Blog on Blogger.com

Step 1: Adding SyntaxHighlighter resource files to blog

1. Go to Blogger Dashboard > Design > Edit HTML.
2. Press CTRL+F to find the code
3. Copy the below code

<!--SYNTAX HIGHLIGHTER BEGINS-->
<link href='http://alexgorbatchev.com/pub/sh/current/styles/shCore.css' rel='stylesheet' type='text/css'/>
<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeDefault.css' rel='stylesheet' type='text/css'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shCore.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCss.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJava.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJScript.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushSql.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushXml.js' type='text/javascript'/>
<script language='javascript'>
SyntaxHighlighter.config.bloggerMode = true;
SyntaxHighlighter.config.clipboardSwf = &#39;http://alexgorbatchev.com/pub/sh/current/scripts/clipboard.swf&#39;;
SyntaxHighlighter.all();
</script>
<!--SYNTAX HIGHLIGHTER ENDS-->

4. Paste it on top of </head>. (We are adding all resource files to HEAD section of the template)
5. Preview your template and save it if everything works ok.

Step 2: Posting code to Blog

Before posting your code to the blog its advisable to convert raw HTML characters to escape characters. There are some online utilities available for performing this like:
1. Encode / Decode HTML Entities
2. Postable

When writing a new post, you need to use <pre> tag in the post. The code of your post needs to go in between <pre class='brush:java'> and </pre> tags, in order to highlight your code properly.
Just like below:

<pre class='brush:java;'>

    public class HelloWorld {

        public static void main(String[] args) {

            System.out.println("Hello World!");  // Display the string.

        }

    }
</pre>

Which will look like this at end

public class HelloWorld {

    public static void main(String[] args) {

        System.out.println("Hello World!");  // Display the string.

    }

}

This is it. You are done with basic setup. In addition you can also customize SyntaxHighlighter with different themes or brushes.

Themes for SyntaxHighlighter

SyntaxHighlighter is available with some well known color themes. You can select a theme which match with your Template. You can apply a theme by selecting CSS file for it. Click name of the theme to get preview of the theme.

Name	File
Default	`<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeDefault.css' rel='stylesheet' type='text/css'/>`
Django	`<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeDjango.css' rel='stylesheet' type='text/css'/>`
Eclipse	`<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeEclipse.css' rel='stylesheet' type='text/css'/>`
Emacs	`<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeEmacs.css' rel='stylesheet' type='text/css'/>`
Fade To Grey	`<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeFadeToGrey.css' rel='stylesheet' type='text/css'/>`
Midnight	`<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeMidnight.css' rel='stylesheet' type='text/css'/>`
RDark	`<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeRDark.css' rel='stylesheet' type='text/css'/>`

You can apply new theme by replacing default theme CSS with the CSS file of your choice from above list. Replace the selected line no 3 in above SyntaxHighlighter resource code which we entered in Template by new CSS file.

Brushes for SyntaxHighlighter
You can also select support of different languages by selecting or removing various brushes. This gives you flexibility to select necessary brushes only thus you can also save loading time of your page. Selected line no 5 and 8 shows brushes for CSS and SQL respectively.

A list of all available brushes is available here.

Issues with SyntaxHighlighter
If you find any issues with SyntaxHighlighter you can post them here.

Happy Blogging. :)

Cross-Site Request Forgery (CSRF) Prevention in Liferay

2013-06-03T23:54:00.000+05:30

What is CSRF?

Cross-Site Request Forgery (CSRF)is a hidden attack that contains a malicious request. This is in top web vulnerabilities list because, the malicious request carries the identity, privileges, information and permissions of the victim to perform an proxy request on the victim's behalf. This can attack can be performed for any kind of operations like updating sensitive\confidential information, purchase something, transfer money etc.

More about CSRF

Prevention Measures

To prevent CSRF attack a general recommendation to use Synchronizer Token Pattern, which suggest to include a random token with all form actions and links associated to confidential server action/operations.

One random token should be generated for each session and must be stored in the session itself. On each incoming request, server must verify the existence and validity against the token stored in current session.

In case of token is not exist in the request or invalid, request must be aborted, token must be reset and incidence must be logged as a CSRF attack.

CSRF Prevention Mechanism in Liferay

Portal Authentication token mechanism is created to prevent CSRF attacks. This mechanism will include a parameter called p_auth containing random token in every action request.

Enable/Disable authentication token checking in portal

As this is a portal level setting, authentication token checking can be enabled or disabled by adding below property in portal properties.

auth.token.check.enabled=true

Setting Authentication Token Class

Custom authentication token class can be implemented to handle and avoid CSRF attacks. Custom authentication class must implement com.liferay.portal.security.auth.AuthToken.

com.liferay.portal.security.auth.SessionAuthToken is the default impelementation available in Liferay.

The class can be registered to portal context by adding below property in portal properties.

auth.token.impl=com.liferay.portal.security.auth.SessionAuthToken

Ignoring actions/portlets from token authentication check

A list of comma delimited struts actions or portlet ids can set to ignore authentication token check on them.

List of struts actions can be set by adding below property in portal properties.

auth.token.ignore.actions=\
    /blogs/edit_entry,\
    /blogs/edit_entry_discussion,\
    /blogs/rss

List of portlet ids can be set by adding below property in portal properties.

auth.token.ignore.portlets=82,87

Individual portlets can be ignored by adding below init parameter in portlet.xml


 check-auth-token
 false

Enjoy and Stay Protected.

Setting Auto Compelete off to Liferay AUI Forms

2013-01-31T22:44:00.000+05:30

Hi Liferay developers,

We all use AUI components extensively during our Liferay portal development, Right? While using AUI forms we may need to set autocomplete settings on our forms based on the sensitivity of the data our forms carries, like login form, credit card information forms etc.

Now AUI form don't provide scope to set autocompelete, have a look here to all AUI form attributes.

This also logged as known bug in AUI form and still in open state by the time this blog is written.

Don't get disappointed, although autocompelete attribute is not available in AUI form we can still get it by just adding autocompelete attribute to AUI form as below, and it's done.

<aui:form 
     action="SOME_FORM_ACTION" method="POST" 
     autocomplete="off">

// Form fields will go here

</aui:form>

Cheers!!!

Hidding Server Signature/Banner Information of Liferay Server

2013-01-30T16:17:00.001+05:30

Liferay Servers include server banner information with every response it send back. These information can be venerable in respect to security of your website/portal. A sample response header is shown below, look highlighted lines:

Date: Tue, 29 Jan 2013 11:02:43 GMT
Content-Encoding: gzip
Server: Apache/2.2.3 (Red Hat)
ETag: "1a467a7a"
Liferay-Portal: Liferay Portal Enterprise Edition 6.1.20 EE (Paton / Build 6120 / July 31, 2012)
Vary: Accept-Encoding
Content-Type: text/html;charset=UTF-8
Connection: Keep-Alive
Content-Length: 9105

These information can be hidden on changed with very basic configurations in servers and portal.

Hiding Liferay-Portal Signature/Header/Banner

Liferay provides a portal property to set the level of verbosity of Liferay portal header.

//Full, provide full information including version information (Liferay Portal Enterprise Edition 6.1.20 EE) 
http.header.version.verbosity=full

OR

//Partial, provide only name of the server (Liferay Portal Enterprise Edition) 
http.header.version.verbosity=partial

Still we are not able to completely hide this information. Although there is a strange solution available without any coding. Add below property in portal-ext.properties to hide Liferay-Portal header.

// For Community edition
http.header.version.verbosity=Liferay Portal Community Edition

 OR

//For Enterprise Edition
http.header.version.verbosity=Liferay Portal Enterprise Edition

Updating Server Signature/Banner in Tomcat

To update server header in tomcat go to server.xml file at CATALINA_HOME/conf/server.xml

Add/Update Server attribute in <Connector> element as below,

<Connector 
  URIEncoding="UTF-8" 
  connectionTimeout="20000" 
  port="8080" 
  protocol="HTTP/1.1" 
  redirectPort="8443" 
  server="Technical Annex"
 />

This change will hide actual server information and update the response headed as below

Date: Tue, 29 Jan 2013 11:02:43 GMT
Content-Encoding: gzip
Server: Technical Annex
ETag: "1a467a7a"
Liferay-Portal: Liferay Portal Enterprise Edition 6.1.20 EE (Paton / Build 6120 / July 31, 2012)
Vary: Accept-Encoding
Content-Type: text/html;charset=UTF-8
Connection: Keep-Alive
Content-Length: 9105

Refer this article, Securing Tomcat by OWASP if you are seriously interested to make your tomcat server secure.

Hiding Server Signature/Banner in Apache

To hide Apache server signature/banner go to Apache configuration file, usually Apache_Server_Home/apache2.conf

Set ServerSignature and ServerTokens properties for disabling server signature/banner as below:

ServerSignature Off
ServerTokens ProductOnly

Enable HTTPS in tomcat with self signed SSL Cerficates

2012-05-24T20:10:00.003+05:30

Article shows to enable and test HTTPS with Liferay Portal in four easy steps. This approach might be proper for development or testing environment.

Step 1: Create Self Signed SSL Certificate

Open command window and move to java tools directory. Typically BIN directory of JDK/JRE installation.

Execute following command and follow on screen instructions. See the image below.

keytool -genkeypair 
{-alias alias} {-keyalg keyalg} 
{-keystore keystore}  
[-storepass storepass] 
[-keypass keypass]

example:

keytool -genkeypair 
-alias techannex 
-keyalg RSA 
-keystore techannex.keystore 
-storepass changeit 
-keypass changeit

Step 2: Configure Server

Stop Tomcat if already running.
move .keystore file to tomcat conf directory. <tomcat_installation_dir>/conf
Open server.xml file of tomcat and uncomment SSL Connector with port="8443" and update it as below.

<Connector port="8443" 
 protocol="HTTP/1.1" 
 SSLEnabled="true"
 maxThreads="150" 
 scheme="https" 
 secure="true" 
 clientAuth="false"
 sslProtocol="TLS" 
 keystoreFile="conf\tech-annex.keystore" />

Step 3: Configure Web Application

Open WEB.XML file of your web application and following property to it.
```
<transport-guarantee>CONFIDENTIAL</transport-guarantee>
```

Step 4: Test the application

Start tomcat and deploy the application.
Hit the URL application url using HTTPS as https://localhost:8443/itannex
Your browser(firefox in this case) should show a warning message as below image for untrusted connection.
This is because we are using a self signed SSL certificate and your browser have no trust on it.
☺
Ignore this and say browser that I understand the risk as you trust this connection.

Hurrayyy!!! You had just configured and tested HTTPS on your tomcat server.

Essential Security Configurations in Java web.xml File

2011-12-09T16:13:00.000+05:30

Developing a safe, secure and stable Web Applications can be a painful task if you are not aware of all the capabilities your development environment provides. At the same point of time it will also make it very easy and manageable if you are aware of them.

In this article we are going to look into some common but essential configurations for Java Web Applications deployment descriptor file WEB.XML.

Authentication & Authorization Bypass
Web Applications can have many kind of informations and data hosted to it which can include public, shared and private data for different group of users. It the job of developer to take care that, confidential or private data can only be accessed by owner of the data or by specific group of users.

<security-constraint> element can make things easier as it can control web based access of secured directories or information. Following code shows a basic example of security constraints:

<security-constraint>
 <web-resource-collection>
  <web-resource-name>secure</web-resource-name>
  <url-pattern>/admin/*</url-pattern>
  <http-method>GET</http-method>
  <http-method>POST</http-method>
 </web-resource-collection>
 <auth-constraint>
  <role-name>admin</role-name>
 </auth-constraint>
</security-constraint>

Above example indicates that anything under url pattern or directory /admin/* can be accessed by user with role admin using HTTP methods GET and POST.

Above example indicates that no user without having /admin/* role can access anything under url pattern or directory /admin/* using HTTP methods GET and POST. Now question here is what about other HTTP methods like PUT, DELETE, TRACK, TRACE etc. The Configuration will allow any HTTP method which are not listed. Attackers can access your secured data using these methods. Attackers can also try sending some arbitrary string like "HEEF" as HTTP method verb. This is called verb-based authentication and access control (VBAAC) bypass vulnerabilities.

A solution to this vulnerabilities is to remove all <http-method> restrictions from access control and authorization rules, this will apply rules to all requests with any HTTP method.

Improvement to above sample can be as follows:

<security-constraint>
 <web-resource-collection>
  <web-resource-name>secure</web-resource-name>
  <url-pattern>/admin/*</url-pattern>
  <!-- No HTTP Methods should be listed here -->
 </web-resource-collection>
 <auth-constraint>
  <role-name>admin</role-name>
 </auth-constraint>
</security-constraint>

Configuring SSL
SSL must be used to access sensitive or confidential data in all applications. You can define SSL configurations in <security-constraint> element as below:

<security-constraint>
 <user-data-constraint>
  <transport-guarantee>CONFIDENTIAL</transport-guarantee>
 </user-data-constraint>
</security-constraint>

Prior to enabling SSL at web application level you should configure your server for that. you can follow this document to configure SSL at tomcat.

Using URL Parameters for Session Tracking
The <tracking-mode> element in the Servlet 3.0 specification define that the JSESSIONID(current session id) should be stored in a cookie or in a URL parameter so that client can use it with next request to the server.

If session id is passed as URL parameter it can be saved at various locations including the history of browser, logs at proxy server, referrer logs, web logs, etc. An accidental disclosure of the session id makes the application more vulnerable to session hijacking attacks. Instead, you should make sure the session id is stored in a cookie using the following configuration:

<session-config>
 <tracking-mode>COOKIE</tracking-mode>
</session-config>

Using the Secure Flag
All of us normally use SSL for authentication of the user like login action but revert back to non-SSL for rest of the operations in our application as they can be accessed via non-SSL. This makes session id vulnerable to attacks like session hijacking. As a solution to this problem we can configure session such a way that client(browser) should not transmit cookie with session id over non-SSL.

You can configure this as follows:

<session-config>
 <cookie-config>
  <secure>true</secure>
 </cookie-config>
</session-config>

This will ensure that browser will keep session id cookie secure and never expose it over non-SSL requests.

Using the HttpOnly Flag
Along with secure flag for cookie storing session id we should also HttpOnly flag with it. HttpOnly flag ensures that cookie with session id can be accessed by HTTP actions only.

Thus session cookie is secured from client side access using java scripts and this will minimize risk of attacks like XSS.

You can configure this as follows:

<session-config>
 <cookie-config>
  <http-only>true</http-only>
 </cookie-config>
</session-config>

Your server also takes care for this, in Tomcat 7 server.xml useHttpOnly attribute inside <Context> element is enabled by default. So, even if you configure web.xml to be <http-only>false</http-only> in Tomcat 7, your JSESSIONID will still be HttpOnly unless you change the default behaviour in server.xml as well.

Setting a Session Timeout
All of us like long lived sessions because its very convenient, No one from us will really like to enter user name and password to login again and again after some period of inactivity for any web application. But there are other group of users who also like long lived sessions so that they get more time for carrying out attacks like Session Hijacking and Cross Site Request Forgery. Now this is really a crucial choice security vs. comfort of use.

You have to identify a period of time when sessions gets expired because of inactivity of the user. Session timeout period may vary based on the operations the application carry out but as a best practice it has to be configured in Web.XML.

<session-config>
 <session-timeout>30</session-timeout> // Timeout in minutes
</session-config>

Above example shows session time out after 30 minutes of inactivity but you can configure this as per your requirement. If session time out is not configured in Web.XML then controller's default time out settings will be used(e.g. Tomcat has 30 minutes as default). Number less than or equal to 0 will set infinite time for session time out thus the session will never expire(So many websites use this option now a days).

In addition to session time out configuration we should also consider hard time out for highly secured web sites like banking web sites etc. Hard time out will expire session after some period of time even user is actively using application. This leads user to login again after some period of time and assigns a new session. Java don't provide this behavior through configuration in WEB.XML but this can be achieved by ServletFilter.

Configuring Custom Error Pages
Last but the most important configuration for any web application is defining your own custom error pages for handling errors. By default all java web application displays detailed error page with brief information of server, details about your server resources where error has occurred, snippet of the error stack trace and in some cases brief snippet of your server side code also. The purpose of this error page is to give a brief idea to the developer to track the error but for live and hosted applications scenario is totally different. For any attacker such information is like a treat which can be used to prepare attacks on your application.

You can configure your own custom error pages for specific errors as follows:

<error-page>
 <error-code>500</error-code>
 <location>/errors/505.jsp</location>
</error-page>

Above configuration will redirect to 505.jsp when ever server encounter 505 HTTP error.

<error-page>
 <exception-type>java.lang.Throwable</exception-type>
 <location>/errors/error.jsp</location>
</error-page>

Above configuration will redirect to error.jsp when ever server encounter java.lang.Throwable error.

Below is the list of some 404 error pages from popular sites:Google, Yahoo, GitHub

You can find a detailed list of all HTTP error here

Reference: Seven Security (Mis)Configurations in Java web.xml Files

Google Alerts: Keep yourself updated

2011-09-12T23:14:00.000+05:30

What are Google Alerts?
Google Alerts are emails sent to you when Google finds new results -- such as web pages, newspaper articles, or blogs -- that match your search term. You can use Google Alerts to monitor anything on the Web. For example, people use Google Alerts to:

find out what is being said about their company or product.
monitor a developing news story.
keep up to date on a competitor or industry.
get the latest news on a celebrity or sports team.
find out what's being said about themselves.

Here's how it works:

You enter a query that you're interested in.
Google Alerts checks regularly to see if there are new results for your query.
If there are new results, Google Alerts sends them to you in an email.

For general queries like [ "Information Technology" ], you can get a summary of the new results every day. For specific topics, like [ cardiovascular atherosclerosis ], you might not get an email every day, but you'll find out when something new and relevant is published. See more examples of how Google Alerts are used
So, Keep your self updated!!!

A quick Reference to java.lang.ref package

2011-09-07T20:20:00.000+05:30

The java.lang.ref package defines classes that allow Java programs to interact with the Java garbage collector. A Reference represents an indirect reference to an arbitrary object, known as the referent. SoftReference, WeakReference, and PhantomReference are three concrete subclasses of Reference that interact with the garbage collector in different ways, as explained in the individual class descriptions that follow. ReferenceQueue represents a linked list of Reference objects. Any Reference object may have a ReferenceQueue associated with it.

A Reference object is enqueued on its ReferenceQueue at some point after the garbage collector determines that the referent object has become appropriately unreachable. (The exact level of unreachability depends on the type of Reference being used.) An application can monitor a ReferenceQueue to determine when referent objects enter a new reachability status.

Using the mechanisms defined in this package, you can implement a cache that grows and shrinks in size according to the amount of available system memory. Or, you can implement a hashtable that associates auxiliary information with arbitrary objects, but does not prevent those objects from being garbage-collected if they are otherwise unused. The mechanisms provided by this package are low-level ones, however, and typical applications do not use java.lang.ref directly. Instead, they rely on higher-level utilities built on top of the package. See java.util.WeakHashMap for one example.

java.lang.ref.PhantomReference

This class represents a reference to an object that does not prevent the referent object from being finalized by the garbage collector. When (or at some point after) the garbage collector determines that there are no more hard (direct) references to the referent object, that there are no SoftReference or WeakReference objects that refer to the referent, and that the referent has been finalized, it enqueues the PhantomReference object on the ReferenceQueue specified when the PhantomReference was created. This serves as notification that the object has been finalized and provides one last opportunity for any required cleanup code to be run.

To prevent a PhantomReference object from resurrecting its referent object, its get() method always returns null, both before and after the PhantomReference is enqueued. Nevertheless, a PhantomReference is not automatically cleared when it is enqueued, so when you remove a PhantomReference from a ReferenceQueue, you must call its clear() method or allow the PhantomReference object itself to be garbage-collected.

This class provides a more flexible mechanism for object cleanup than the finalize() method does. Note that in order to take advantage of it, it is necessary to subclass PhantomReference and define a method to perform the desired cleanup. Furthermore, since the get() method of a PhantomReference always returns null, such a subclass must also store whatever data is required for the cleanup operation.

public class PhantomReference extends java.lang.ref.Reference {
 
 // Public Constructors
 public PhantomReference (Object referent, ReferenceQueue q);

 // Public Methods Overriding Reference
 public Object get ();

}

Hierarchy: Object-->java.lang.ref.Reference-->PhantomReference

java.lang.ref.Reference

This abstract class represents some type of indirect reference to a referent. get() returns the referent if the reference has not been explicitly cleared by the clear() method or implicitly cleared by the garbage collector. There are three concrete subclasses of Reference. The garbage collector handles these subclasses differently and clears their references under different circumstances.

Each of the subclasses of Reference defines a constructor that allows a ReferenceQueue to be associated with the Reference object. The garbage collector places Reference objects onto their associated ReferenceQueue objects to provide notification about the state of the referent object. isEnqueued() tests whether a Reference has been placed on the associated queue, and enqueue() explicitly places it on the queue. enqueue() returns false if the Reference object does not have an associated ReferenceQueue, or if it has already been enqueued.

public abstract class Reference {

    //No Constructor

    //Public Instance Methods
    public void clear ();

    public boolean enqueue ();

    public Object get ();

    public boolean isEnqueued ();

}

Subclasses: PhantomReference, SoftReference, WeakReference
Returned By: ReferenceQueue.{poll(), remove()}

java.lang.ref.ReferenceQueue

This class represents a queue (or linked list) of Reference objects that have been enqueued because the garbage collector has determined that the referent objects to which they refer are no longer adequately reachable. It serves as a notification system for object-reachability changes. Use poll() to return the first Reference object on the queue; the method returns null if the queue is empty. Use remove() to return the first element on the queue, or, if the queue is empty, to wait for a Reference object to be enqueued. You can create as many ReferenceQueue objects as needed. Specify a ReferenceQueue for a Reference object by passing it to the SoftReference(), WeakReference(), or PhantomReference() constructor.

A ReferenceQueue is required to use PhantomReference objects. It is optional with SoftReference and WeakReference objects; for these classes, the get() method returns null if the referent object is no longer adequately reachable.

public class ReferenceQueue {

 //Public Constructors
 public ReferenceQueue ();

 //Public Instance Methods
 public java.lang.ref.Reference poll ();

 public java.lang.ref.Reference remove () throws InterruptedException;

 public java.lang.ref.Reference remove (long timeout) throws IllegalArgumentExceptionInterruptedException;
 
}

Passed To:PhantomReference.PhantomReference(), SoftReference.SoftReference(), WeakReference.WeakReference()

java.lang.ref.SoftReference

This class represents a soft reference to an object. A SoftReference is not cleared while there are any remaining hard (direct) references to the referent. Once the referent is no longer in use (i.e., there are no remaining hard references to it), the garbage collector may clear the SoftReference to the referent at any time. However, the garbage collector does not clear a SoftReference until it determines that system memory is running low. In particular, the Java VM never throws an OutOfMemoryError without first clearing all soft references and reclaiming the memory of the referents. The VM may (but is not required to) clear soft references according to a least-recently-used ordering.

If a SoftReference has an associated ReferenceQueue, the garbage collector enqueues the SoftReference at some time after it clears the reference.

SoftReference is particularly useful for implementing object-caching systems that do not have a fixed size, but grow and shrink as available memory allows.

public class SoftReference extends java.lang.ref.Reference {
 //Public Constructors
 public SoftReference (Object referent);

 public SoftReference (Object referent, ReferenceQueue q);

 //Public Methods Overriding Reference
 public Object get ();

}

Hierarchy: Object-->java.lang.ref.Reference-->SoftReference

java.lang.ref.WeakReference

This class refers to an object in a way that does not prevent that referent object from being finalized and reclaimed by the garbage collector. When the garbage collector determines that there are no more hard (direct) references to the object, and that there are no SoftReference objects that refer to the object, it clears the WeakReference and marks the referent object for finalization. At some point after this, it also enqueues the WeakReference on its associated ReferenceQueue, if there is one, in order to provide notification that the referent has been reclaimed.

WeakReference is used by java.util.WeakHashMap to implement a hashtable that does not prevent the hashtable key object from being garbage-collected. WeakHashMap is useful when you want to associate auxiliary information with an object but do not want to prevent the object from being reclaimed.

public class WeakReference extends java.lang.ref.Reference {

 //Public Constructors
 public WeakReference (Object referent);

 public WeakReference (Object referent, ReferenceQueue q);

}

Hierarchy: Object-->java.lang.ref.Reference-->WeakReference

Disclaimer: Content of this blog is property of O'Reilly & Associates. Content displayed here is just for reference purpose only. You can find actual content here.

Java Platform System Properties

2011-08-29T21:34:00.000+05:30

The Java platform itself uses a Properties object to maintain its own configuration. The System class maintains a Properties object that describes the configuration of the current working environment. System properties include information about the current user, the current version of the Java runtime, and the character used to separate components of a file path name.

Important system properties

The following table describes some of the most important system properties

Key	Meaning
`"file.separator"`	Character that separates components of a file path. This is"`/`" on UNIX and "`\`" on Windows.
`"java.class.path"`	Path used to find directories and JAR archives containing class files. Elements of the class path are separated by a platform-specific character specified in the `path.separator` property.
`"java.home"`	Installation directory for Java Runtime Environment (JRE)
`"java.vendor"`	JRE vendor name
`"java.vendor.url"`	JRE vendor URL
`"java.version"`	JRE version number
`"line.separator"`	Sequence used by operating system to separate lines in text files
`"os.arch"`	Operating system architecture
`"os.name"`	Operating system name
`"os.version"`	Operating system version
`"path.separator"`	Path separator character used in `java.class.path`
`"user.dir"`	User working directory
`"user.home"`	User home directory
`"user.name"`	User account name

Reading System Propertie

The System class has two methods used to read system properties: getProperty and getProperties.
The System class has two different versions of getProperty. Both retrieve the value of the property named in the argument list. The simpler of the two getProperty methods takes a single argument, a property key For example, to get the value of path.separator, use the following statement:

System.getProperty("user.dir");

The getProperty method returns a string containing the value of the property. If the property does not exist, this version of getProperty returns null.

The other version of getProperty requires two String arguments: the first argument is the key to look up and the second argument is a default value to return if the key cannot be found or if it has no value. For example, the following invocation of getProperty looks up the System property called user.name. This is not a valid system property, so instead of returning null, this method returns the default value provided as a second argument: "Guest User"

System.getProperty("user.name", "Guest User");

The last method provided by the System class to access property values is the getProperties method, which returns a Properties object. This object contains a complete set of system property definitions.

From Java Tutorials: System Properties

Oracle - Using Sequence for Auto Increment

2011-08-29T17:43:00.000+05:30

I am working with databases from past few years and I had created or came across hundreds of Tables in database. Out of all those tables 99.99% tables had any of Numeric Primary Key column or Serial Number column or anything similar to this where value of those columns follow numeric incremental pattern.

These are very basic cases of database but there can be so many other cases in database when we need numeric incremental values. For this type of activities Sequence can be very handy.

I am giving a very basic example of How you can use sequence in Oracle? We will perform following activities:
1. Create Table with a Primary Key Field
2. Using sequence while insert into table
3. Achieving Auto Increment using Trigger

Create Table
Creating Table EMPLOYEE with a Primary Key ID

CREATE TABLE EMPLOYEE (
ID NUMBER NOT NULL,
NAME VARCHAR2(100) NOT NULL,
DESIGNATION VARCHAR2(50) NOT NULL,

CONSTRAINT EMPLOYEE_PK PRIMARY KEY(ID)

);

Now insert some rows into this table. See INSERT statements below:

INSERT INTO EMPLOYEE VALUES(1, 'Maecenas','Programmer');
INSERT INTO EMPLOYEE VALUES(2, 'Dolorem','Team Lead');
INSERT INTO EMPLOYEE VALUES(3, 'Consequat','Manager');

Inserting data like this have a problem that before inserting data into table you have to take care that what should be the next value of ID column. So you have to check last value of ID column and then continue with next possible value. Creating sequence can solve this problem.

Using Sequence while insert into table
Creating Sequence SEQ_EMPLOYEE_ID to get incremental value for Primary Key Column ID

CREATE SEQUENCE SEQ_EMPLOYEE_ID
INCREMENT BY 1
START WITH 1;

Now we insert data using the sequence we just created.

Note: Delete all data from table EMPLOYEE as we are starting our sequence from 1 and we already inserted data with value 1 in ID column or you can create your sequence accordingly to start from 4 which should be the next value of ID column. See INSERT statements below:

INSERT INTO EMPLOYEE VALUES(SEQ_EMPLOYEE_ID.nextval, 'Convallis','Programmer');
INSERT INTO EMPLOYEE VALUES(SEQ_EMPLOYEE_ID.nextval, 'Sollicitudin','Programmer');
INSERT INTO EMPLOYEE VALUES(SEQ_EMPLOYEE_ID.nextval, 'Quisque','Programmer');

Still we are doing some manual stuff by getting next value form sequence and inserting it to ID column while inserting data into EMPLOYEE table. We can make it more effective by writing a Trigger which will insert value to ID column automatically every time you insert data into EMPLOYEE table.

Achieving auto increment using Trigger
Create a Trigger for inserting value to ID column before insert into EMPLOYEE table.

CREATE TRIGGER TRIG_EMPLOYEE_ID
BEFORE INSERT ON EMPLOYEE  for each row  
WHEN (new.id is null)  

begin
select SEQ_EMPLOYEE_ID.nextval into :new.id from dual;
end;

Now all we need to care about is inserting values of NAME and DESIGNATION columns while inserting data into EMPLOYEE table because value of ID column will be added by TRIG_EMPLOYEE_ID trigger. See INSERT statements below:

INSERT INTO EMPLOYEE (NAME, DESIGNATION) VALUES('Convallis','Programmer');
INSERT INTO EMPLOYEE (NAME, DESIGNATION) VALUES('Sollicitudin','Programmer');
INSERT INTO EMPLOYEE (NAME, DESIGNATION) VALUES('Quisque','Programmer');

Oracle® database administrator's guide 11g release 1
Managing Tables
Managing Sequences
Enabling and Disabling Triggers

Apache Tika - Detect MIME Type of any file

2011-07-20T16:29:00.000+05:30

Apache Tika - a content analysis toolkit

The Apache Tika™ toolkit detects and extracts metadata and structured text content from various documents using existing parser libraries. You can find the latest release on the download page.

JAVA class to detect MIME Type of the file MIMETypeDetector.java

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.tika.Tika;
import org.apache.tika.io.TikaInputStream;
/** 
 * @author tejas.purohit
 * 
 **/
public class MIMETypeDetector {

 /*** Logger instance for logging info*/
 private final static Logger log = Logger.getLogger(MIMETypeDetector.class.getName());

 /*** Detect and return MIME Type of the given file. 
  * @param file java.io.File to detect MIME Type
  * @return MIME Type of the file as String
  */
 public static String getMimeType(File file) {
  String mimeType = null;
  try {
   Tika tika = null;
   TikaInputStream is = null;

   // Creating new Instance of org.apache.tika.Tika
   tika = new Tika();

   // Detecting MIME Type of the File
   mimeType = tika.detect(file);
  } catch (FileNotFoundException e) {
   log.log(Level.WARNING, "Specified File not found", e);
  } catch (IOException e) {
   log.log(Level.WARNING, "IO Error", e);
  }
  // returning detected MIME Type
  return mimeType;
 }

 /** 
  * Detect and return MIME Type of the given file. 
  * @param filePath full path of the file to detect MIME Type
  * @return MIME Type of the file as String
  */
 public static String getMimeType(String filePath) {

  // Creating new instance of java.io.File for given file path
  File f = new File(filePath);

  // Getting and returning MIME Type of the file
  return getMimeType(f);
 }

 public static void main(String[] args) {

  // Getting file path as command line argument
  String filePath = args[0];

  // Getting and printing MIME Type of the given file
  System.out.println("Is ZIP file:" + MIMETypeDetector.getMimeType(filePath));
 }
}

Two Servlet Filters Every Web Application Should Have

2011-04-26T23:31:00.000+05:30

Almost every single web application you will ever make will seriously benefit from using servlet filters to both cache and compress content.

A caching filter optimizes the time it takes to send back a response from your web server, and a compression filter optimizes the size of the content that you send from your web server to a user via the Internet.

Since generating content and sending content over the World Wide Web are the bread and butter of web applications, it should be no surprise that simple components that aid in these processes are incredibly useful.

This article details the process of building and using a caching filter and a compression filter that are suitable for use with just about any web application. After reading this article, you will understand caching and compressing, have code to do both, and be able to apply caching and compression to any of your future (or existing!) web applications.

Find more at Two Servlet Filters Every Web Application Should Have - O'Reilly Media.

Xalan-Java Version 2.7.1 Extensions - Redirect

2011-04-26T02:29:00.000+05:30

Xalan-Java Version 2.7.1 Extensions: Extension elements and functions provide a powerful mechanism for extending and simplifying what you can do with an XLST processor like Xalan. With input and contributions from the XML open-source developer community, we are working on placing the most useful extensions in an extensions library distributed with Xalan-Java.

Redirect Extension: A standard XSL transformation involves an XSL stylesheet, an XML source tree, and the transformation result tree. The transformation sends the entire result to a single javax.xml.transform.Result object.

The namespace for the Redirect extension is: http://xml.apache.org/xalan/redirect

It supplies three extension elements that you can use to redirect portions of your transformation output to multiple files: <open>, <write>, and <close>. If you use the <write> element alone, the extension opens a file, writes to it, and closes the file immediately. If you want explicit control over the opening and closing of files, use <write> in conjunction with the <open> and <close> elements.

The <open> and <write> elements include a file attribute and/or a select attribute to designate the output file. The file attribute takes a string, so you can use it to directly specify the output file name. The select attribute takes an XPath expression, so you can use it to dynamically generate the output file name. If you include both attributes, the Redirect extension first evaluates the select attribute, and falls back to the file attribute if the select attribute expression does not return a valid file name.

The <open> and <write> elements also support an append attribute. If the append attribute is set to true or yes, then the result is appended to the output file.

Simple Example of using Redirect extension with XSLT:
I have a XML file which contains some set of XML elements as shown in Source.XML below. My requirement is, I want to move all <REF1> elements to file REF1.XML, all <REF2> elements to REF2.XML and so on.

A simple XSLT using Redirect extension from Xalan can do the trick as shown in MultiRedirect.XSL. I am selecting all <REF1> elements and copying it to REF1.XML using Redirect extension and Similar for all <REF2>, <REF3>, <REF4> and <REF5> elements. On XSLT transformation of Source.XML by MultiRedirect.XSL will create five new XML files like REF1.XML, REF2.XML, REF3.XML, REF4.XML and REF5.XML as shown below.

Before running this example you should have Xalan-J 2.7.1 available to program. I mean you should have Xalan-J 2.7.1 downloaded and set on CLASSPATH. Refer Bibliography for downloads and other references of Xalan-J 2.7.1

Source.XML

<?xml version="1.0" encoding="ISO-8859-1"?>
<Invoice>
 <InvoiceHeader>
  
  <!-- Gruop of Ref1 Elements to go in file REF1.XML -->
  <Ref1 code="1">
   <text>Reference Text 1</text>
  </Ref1>
  <Ref1 code="1">
   <text>Reference Text 2</text>
  </Ref1>

  <!-- Gruop of Ref2 Elements to go in file REF2.XML -->
  <Ref2 code="2">
   <text>Reference Text 1</text>
  </Ref2>
  <Ref2 code="2">
   <text>Reference Text 2</text>
  </Ref2>

 </InvoiceHeader>
</Invoice>

MultiRedirect.XSL

<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:redirect="http://xml.apache.org/xalan/redirect"
 extension-element-prefixes="redirect">
 <xsl:variable name="REF1" select="'REF1.XML'" />
 <xsl:variable name="REF2" select="'REF2.XML'" />
 <xsl:template match="/">
 
  <!-- Redirecting REF1 Elementns to REF1.XML -->
  <redirect:open select="$REF1" />
  <redirect:write select="$REF1">
   <Invoice>
    <InvoiceHeader>
     <xsl:copy-of select="Invoice/InvoiceHeader/Ref1" />
    </InvoiceHeader>
   </Invoice>
  </redirect:write>
  <redirect:close select="$REF1" />
  
  <!-- Redirecting REF2 Elementns to REF2.XML -->
  <redirect:open select="$REF2" />
  <redirect:write select="$REF2">
   <Invoice>
    <InvoiceHeader>
     <xsl:copy-of select="Invoice/InvoiceHeader/Ref2" />
    </InvoiceHeader>
   </Invoice>
  </redirect:write>
  <redirect:close select="$REF2" />
  
 </xsl:template>
</xsl:stylesheet>

REF1.XML

<?xml version="1.0" encoding="UTF-8"?>
<Invoice>
 <InvoiceHeader>
  <Ref1 code="1">
   <text>Reference Text 1</text>
  </Ref1>
  <Ref1 code="1">
   <text>Reference Text 2</text>
  </Ref1>
 </InvoiceHeader>
</Invoice>

REF2.XML

<?xml version="1.0" encoding="UTF-8"?>
<Invoice>
 <InvoiceHeader>
  <Ref2 code="2">
   <text>Reference Text 1</text>
  </Ref2>
  <Ref2 code="2">
   <text>Reference Text 2</text>
  </Ref2>
 </InvoiceHeader>
</Invoice>

Bibliography:
Apache Organization, Xalan-Java Extensions, Redirect Extension, Example with the Redirect extension, Download Xalan-J 2.7.1

implementing javax.servlet.ServletContextListener

2011-04-26T01:42:00.000+05:30

Each web application has a ServletContext associated with it. The ServletContext object is created when the application is started and is destroyed when the application is shut down. A ServletContext has a global scope and is similar to a global variable in an application. ServletContextListener will gets notified when servlet context gets initialization and destroyed.

A Simple example of implementing javax.servlet.ServletContextListener in your web application is shown below. You need to write one class implementing javax.servlet.ServletContextListener and it's methods. As shown below:
ContextListenerIMPL.java

package com.test;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class ContextListenerIMPL implements ServletContextListener {

 /** Creates a new instance of ContextListenerIMPL */
 public ContextListenerIMPL() { }

 public void contextInitialized(ServletContextEvent servletContextEvent) {

  //Code which should be executed just after web application context initialized should go here.
  //This code will be executed before any filter or servlet initialized.
  System.out.println("Web Application Context Initialized...");

 }
 public void contextDestroyed(ServletContextEvent servletContextEvent) {

  //Code which should be executed just before web application context gets destroyed should go here.
  //This code will be executed after all filter or servlet in the web application destroyed.
  System.out.println("Web Application Context destroyed...");

 }

}

Once writting ServletContextListener for your application you need to register it in WEB.XML file of your web application. As shown in bold letters below:
WEB.XML

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
 . . . . . .
 <!-- Context Listener Config -->
 <listener>
  <listener-class>com.test.ContextListenerManager</listener-class>
 </listener>
 . . . . .
</web-app>

Other References:
ServletContextListener API Docs, Configuring Web Applications

Computer Software And Hardware Information using JAVA

2011-04-26T01:11:00.000+05:30

The example provides various information about computer hardware and software. As listed below:
1. OS Installation date & Time
2. OS Serial Number
3. Motherboard Serial Number
4. Processor ID
5. Computer Name

The program provides information as stream of data, It is your JOB how you will extract information from stream and utilize them?

Note:The program will work only on windows platform and on Windows XP or later OS.

ComputerInfo.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class ComputerInfo {

 public static void main(String[] args) {

  try {

   String[][] commands = new String[][]{
     {"CMD", "/C", "WMIC OS GET Installdate,SerialNumber"}, //OS Installation date & Time, OS Serial Number
     {"CMD", "/C", "WMIC BASEBOARD GET SerialNumber"}, // Motherboadrd Serial Number
     {"CMD", "/C", "WMIC CPU GET ProcessorId"}, // Processor ID
     {"CMD", "/C", "WMIC COMPUTERSYSTEM GET Name"}}; // Computer Name

   for (int i = 0; i < commands.length; i++) {

    String[] com = commands[i];

    Process process = Runtime.getRuntime().exec(com);

    process.getOutputStream().close(); //Closing output stream of the process

    System.out.println();
    String s = null;
    //Reading sucessful output of the command
    BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
    while ((s = reader.readLine()) != null) {
     System.out.print(s);
    }

    // Reading error if any
    reader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
    while ((s = reader.readLine()) != null) {
     System.out.print(s);
    }

   }

  } catch (IOException e) {
   e.printStackTrace(); //TODO: necessary exception handling
  }
 }
}

Invoke Web Service using basic java.net package

2011-04-26T01:05:00.000+05:30

Below code shows sample code to invoke Web Service Using basic java.net package.

InvokeService.java

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 *
 * @author Tejas Purohit
 */
public class InvokeService {

 public InvokeService() {

 }

 public static void main(String[] args) {

  // Setting Proxy Settings If Applicable, Consider below commented code
  // if you are working behind the proxy to access any web service.
  /*
  System.setProperty("proxySet", "true");
  System.setProperty("http.proxyHost", "192.168.1.100");
  System.setProperty("http.proxyPort", "8080");
  System.setProperty("http.proxyUser", "ProxyUser");
  System.setProperty("http.proxyPassword", "ProxyPassword");
   */

  // Web Service URL
  String url = "http://www.myapp.com/mywebservice/invoke";

  // SOAPAction
  String action = "http://www.myapp.com/mywebservice/action";

  // SOAPMessage
  String reqMessage = "<soap:Envelope xmlns:soap='http://schemas.xmlsoap.org/soap/envelope/'><soap:Body><Request><Emp><EmpNo>10</EmpNo><EmpName>Tejas Purohit</EmpName><EmpDesignation>Developer</EmpDesignation></Emp></Request></soap:Body></soap:Envelope>";

  InvokeService invokeService = new InvokeService();

  String res = invokeService.invoke(url, reqMessage, action);

  // Displaying Response
  System.out.println(res);

 }

 public String invoke(String strURL, String soapMessage, String soapAction) {

  String resMessage = null;

  try {

   // Initializing Connection with default properties
   URL url = new URL(strURL);
   HttpURLConnection urlCon = (HttpURLConnection) url.openConnection();
   urlCon.setAllowUserInteraction(true);
   urlCon.setDoOutput(true);
   urlCon.setDoInput(true);
   urlCon.setConnectTimeout(2000); // Setting Connection Timeout
   urlCon.setReadTimeout(2000); // Setting Read Timeout
   urlCon.setRequestProperty("Action", soapAction); // Setting SOAP Action
   urlCon.setRequestProperty("Content-Type", "text/xml"); // Setting Content Type
   urlCon.connect();

   // Openoutput stream and writting SOAPRequest Message
   OutputStream out = urlCon.getOutputStream();
   out.write(soapMessage.getBytes());
   out.flush();
   out.close();

   // Reading InputStream
   InputStream dataInputStream;
   if (urlCon.getResponseCode() == HttpURLConnection.HTTP_OK) {
    dataInputStream = urlCon.getInputStream();
   } else {
    dataInputStream = urlCon.getErrorStream();
   }
   resMessage = readInputStream(dataInputStream);
   dataInputStream.close();

   // Disconnecting
   urlCon.disconnect();

  } catch (Exception ex) {

   ex.printStackTrace();

  }

  return resMessage;

 }

 private String readInputStream(InputStream in) throws IOException {

  StringBuffer sb = new StringBuffer();

  int avail = in.available();

  while (avail > 0) {
   byte[] availBytes = new byte[avail];
   in.read(availBytes);
   sb.append(new String(availBytes));
   avail = in.available();
  }

  return sb.toString();

 }

}

XML to HTML Transformation

2011-04-21T18:09:00.000+05:30

Below example will take SourceXML.xml(Source XML Block) and HTMLStyleSheet.xsl(StyleSheet to process XML Block) as input. On transform action StyleSheet will process given XML block and store result at Employees.html file.
Before running the Example you need to have following files created as described.

1. HTMLStyleSheet.xsl (given below) as input XSLT.
2. SourceXML.xml (given below) as input XML.
3. Employees.html (an blank file - to avoid FileNotFoundException while transformation) as output file.

SourceXML.xml given below will be used as input XML. It will be transformed to well formed HTML Document after transforming.

SourceXML.xml

<?xml version="1.0"?>
<Employees>
 <Employee>
  <EmpId>1</EmpId>
  <Name>Kapil dev</Name>
  <Address1>Delhi</Address1>
  <Address2>India</Address2>
  <BirthDate>1954-05-13T00:00:00+05:30</BirthDate>
  <Salary>500</Salary>
 </Employee>
 <Employee>
  <EmpId>2</EmpId>
  <Name>Sunil Gavaskar</Name>
  <Address1>Mumbai</Address1>
  <Address2>India</Address2>
  <BirthDate>1945-07-10T00:00:00+05:30</BirthDate>
  <Salary>700</Salary>
 </Employee>
 <Employee>
  <EmpId>3</EmpId>
  <Name>Alen Border</Name>
  <Address1>Sydney</Address1>
  <Address2>Australia</Address2>
  <BirthDate>1950-09-25T00:00:00+05:30</BirthDate>
  <Salary>400</Salary>
 </Employee>
 <Employee>
  <EmpId>4</EmpId>
  <Name>Sachin Tendulkar</Name>
  <Address1>Mumbai</Address1>
  <Address2>India</Address2>
  <BirthDate>1970-02-06T00:00:00+05:30</BirthDate>
  <Salary>2000</Salary>
 </Employee>
 <Employee>
  <EmpId>5</EmpId>
  <Name>Ricky Ponting</Name>
  <Address1>Melbourne</Address1>
  <Address2>Australia</Address2>
  <BirthDate>1968-02-15T00:00:00+05:30</BirthDate>
  <Salary>1500</Salary>
 </Employee>
</Employees>

HTMLStyleSheet.xsl given below will be used as input XSLT. This Style Sheet will transform SourceXML.xml to well formed HTML Document.

HTMLStyleSheet.xsl

<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">
  <HTML>
   <BODY>
    <h1>
     <U>List of Employees</U>
    </h1>
    <TABLE BORDER="1">
     <TBODY>
      <TR>
       <TH>EmpId</TH>
       <TH>Name</TH>
       <TH>Address1</TH>
       <TH>Address2</TH>
       <TH>BirthDate</TH>
       <TH>Salary</TH>
      </TR>
      <xsl:for-each select="Employees">
       <xsl:for-each select="Employee">
        <TR>
         <TD>
          <xsl:value-of select="EmpId" />
         </TD>
         <TD>
          <xsl:value-of select="Name" />
         </TD>
         <TD>
          <xsl:value-of select="Address1" />
         </TD>
         <TD>
          <xsl:value-of select="Address2" />
         </TD>
         <TD>
          <xsl:value-of select="BirthDate" />
         </TD>
         <TD>
          <xsl:value-of select="Salary" />
         </TD>
        </TR>
       </xsl:for-each>
      </xsl:for-each>
     </TBODY>
    </TABLE>
   </BODY>
  </HTML>
 </xsl:template>
</xsl:stylesheet>

XmlToHtmlTransformation class contains transform method will accept source xml, source style sheet and output file. It will transform given source xml using style sheet and store result in output file. output file is Employees.html in our case.

XmlToHtmlTransformation.java

import java.io.*;
import javax.xml.transform.*;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

/**
 *
 * @author Tejas Purohit
 */
public class XmlToHtmlTransformation {

 public boolean transform(String stylesheet, String sourceXML, String result) {

  try {

   // Creating Transformer with XSLT
   Source sourceXSLT = new StreamSource(new FileInputStream(stylesheet));
   TransformerFactory tFactory = TransformerFactory.newInstance();
   Transformer transformer = tFactory.newTransformer(sourceXSLT);

   // Creating StreamSource with sourceXML
   Source streamSource = new StreamSource(new FileInputStream(sourceXML));
   
   // Creating StreamResult with result
   Result streamResult = new StreamResult(new FileOutputStream(result)); 

   transformer.transform(streamSource, streamResult); // Transforming

  } catch (Exception exception) {

   exception.printStackTrace();

   return false;

  }

  return true;
 }

 public static void main(String[] args) {

  XmlToHtmlTransformation xhTransformation = new XmlToHtmlTransformation();

  String stylesheet = "HTMLStyleSheet.xsl";
  String sourceXML = "SourceXML.xml";
  String result = "Employees.html";

  if (xhTransformation.transform(stylesheet, sourceXML, result)) {
   System.out.println("Successful.");
  } else {
   System.out.println("Error.");
  }
 }
}

Transformation process will generate result HTML and store in Employees.html. Once Transformation is done Employees.html will look like below:

Employees.html

<HTML>
 <BODY>
  <h1>
   <U>List of Employees</U>
  </h1>
  <TABLE BORDER="1">
   <TBODY>
    <TR>
     <TH>EmpId</TH>
     <TH>Name</TH>
     <TH>Address1</TH>
     <TH>Address2</TH>
     <TH>BirthDate</TH>
     <TH>Salary</TH>
    </TR>
    <TR>
     <TD>1</TD>
     <TD>Kapil dev</TD>
     <TD>Delhi</TD>
     <TD>India</TD>
     <TD>1954-05-13T00:00:00+05:30</TD>
     <TD>500</TD>
    </TR>
    <TR>
     <TD>2</TD>
     <TD>Sunil Gavaskar</TD>
     <TD>Mumbai</TD>
     <TD>India</TD>
     <TD>1945-07-10T00:00:00+05:30</TD>
     <TD>700</TD>
    </TR>
    <TR>
     <TD>3</TD>
     <TD>Alen Border</TD>
     <TD>Sydney</TD>
     <TD>Australia</TD>
     <TD>1950-09-25T00:00:00+05:30</TD>
     <TD>400</TD>
    </TR>
    <TR>
     <TD>4</TD>
     <TD>Sachin Tendulkar</TD>
     <TD>Mumbai</TD>
     <TD>India</TD>
     <TD>1970-02-06T00:00:00+05:30</TD>
     <TD>2000</TD>
    </TR>
    <TR>
     <TD>5</TD>
     <TD>Ricky Ponting</TD>
     <TD>Melbourne</TD>
     <TD>Australia</TD>
     <TD>1968-02-15T00:00:00+05:30</TD>
     <TD>1500</TD>
    </TR>
   </TBODY>
  </TABLE>
 </BODY>
</HTML>

Which generates html output as below:

List of Employees

EmpId	Name	Address1	Address2	BirthDate	Salary
1	Kapil dev	Delhi	India	1954-05-13T00:00:00+05:30	500
2	Sunil Gavaskar	Mumbai	India	1945-07-10T00:00:00+05:30	700
3	Alen Border	Sydney	Australia	1950-09-25T00:00:00+05:30	400
4	Sachin Tendulkar	Mumbai	India	1970-02-06T00:00:00+05:30	2000
5	Ricky Ponting	Melbourne	Australia	1968-02-15T00:00:00+05:30	1500

Indent,Organize or Well-form XML Using Java

2011-04-21T17:53:00.000+05:30

Below Code Well form, Organize or Indent plain or unorganized XML String using XML API in JDK 6.

IndentXML.java

import com.actl.dxchange.utilities.XMLUtil;
import java.io.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import org.w3c.dom.*;

/**
 * XMLTransformations Utilities.
 * @author Tejas Purohit
 */
public class IndentXML {

 public IndentXML() {

 }

 public static void main(String[] args) throws Exception {

  IndentXML t = new IndentXML();

  String strXML = "<Employees><Employee Name='Amitabh Bachapan' Designation='Director'>"+
    "<Address><AddressLine>Opp. Taj Square</AddressLine><City>Mumbai</City>"+
    "<Country>India</Country></Address></Employee><Employee Name='Shah RukRukKhan'"+
    " Designation='Manager'><Address><AddressLine>Behind Chandani Choak</AddressLine>"+
    "<City>Delhi</City><Country>India</Country></Address></Employee></Employees>";

  System.out.println("Plain XML:");
  System.out.println(strXML); // Print Plain XML

  strXML = t.indentXML(strXML); // Indent XML

  System.out.println("Organized XML:"); // Print Organized/Indented XML
  System.out.println(strXML);

 }

 /**
  * Indent given XML String and returns organized String.
  * @param strXML Plain XML String
  * @return Organized or indented String
  */
 public String indentXML(String strXML) {

  String result = null;

  try {

   // Creating StreamSource from given plain XML String
   ByteArrayInputStream bin = new ByteArrayInputStream(strXML.getBytes());
   StreamSource streamSource = new StreamSource(bin);
   streamSource.setSystemId("http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd");

   // Creating new Transformer
   TransformerFactory transFactory = TransformerFactory.newInstance();
   Transformer transformer = transFactory.newTransformer();

   // Setting output properties
   transformer.setOutputProperty(OutputKeys.METHOD, "xml");
   transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");
   transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "5");
   transformer.setOutputProperty(OutputKeys.INDENT, "yes");
   transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
   transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd");
   transformer.setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, "-//W3C//DTD XHTML 1.1//EN");


   // Creating StreamResult
   ByteArrayOutputStream bout = new ByteArrayOutputStream();
   StreamResult streamResult = new StreamResult(bout);
   streamResult.setSystemId("http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd");

   // Transforming StreamSource and storing result in StreamResult
   transformer.transform(streamSource, streamResult);

   // Getting String from ByteArrayOutputStream
   result = bout.toString();

  } catch (Exception ex) {

   ex.printStackTrace();

  }

  return result;

 }

}

Plain XML output will be like:

<Employees><Employee Name='Amitabh Bachapan' Designation='Director'><Address><AddressLine>Opp. Taj Square</AddressLine><City>Mumbai</City><Country>India</Country></Address></Employee><Employee Name='Shah RukRukKhan' Designation='Manager'><Address><AddressLine>Behind Chandani Choak</AddressLine><City>Delhi</City><Country>India</Country></Address></Employee></Employees>

Well formed/Organized/Indented XML output will like:

<!DOCTYPE Employees PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<Employees>
 <Employee Name="Amitabh Bachapan" Designation="Director">
  <Address>
   <AddressLine>Opp. Taj Square</AddressLine>
   <City>Mumbai</City>
   <Country>India</Country>
  </Address>
 </Employee>
 <Employee Name="Shah RukRukKhan" Designation="Manager">
  <Address>
   <AddressLine>Behind Chandani Choak</AddressLine>
   <City>Delhi</City>
   <Country>India</Country>
  </Address>
 </Employee>
</Employees>

Garbage Collection in JavaScript

2011-04-21T02:39:00.000+05:30

Rich application development now a days includes wast use of JavaScript and Ajax. Latest web browsers are developed to handle such interactive web applications. All data which Ajax imports from server is stored in web browser memory cache. Larger amount of data stored in web browser cache may slow down performance of web browser. One way to release memory from web browser cache or applying garbage collection is to close the browser. But web application can't use this practice to close browser or tell user to restart web browser while web application application is running.

You can force/implement garbage collection in JavaScript. Web developers should develop practice to force garbage collection contentiously while web application is running.

delete operator is one of the most unknown and unused operators in JavaScript. You can use delete operator to release memory occupied by any unused or unreferenced objects in JavaScript. While deleting any object be sure you don't have any reference stored in any other variables for particular object. This will lead performance breakdown when these other variable will try to access the object which was deleted. You can delete any object which has performed it's job and is not going to be used in future.

For example, You can delete window onload handler function and release any memory associated with the function, like this:

var winLoadFun = function(){
    
        // code for my function
        delete winLoadFun;
    }

    window.addEventListener('load', winLoadFun , false);

XML Transformations in Java

2011-04-21T02:32:00.000+05:30

Java provides very robust API for XML Processing. Transforming XML String to org.w3c.dom.Document and vise versa is very simple. XMLTransformations.java given below is written using JDK6. Method getDocumentAsString transforms org.w3c.dom.Document to plain String.Method getStringAsDocument transforms plain String to org.w3c.dom.Document.

XMLTransformations.java

import java.io.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.*;
import org.xml.sax.InputSource;

/**
 * XMLTransformations Utilities.
 * @author Tejas Purohit
 */
public class XMLTransformations {

 public XMLTransformations() {
 }

 /**
  * Transforms given org.w3c.dom.Document to String.
  * @param node Node to convert to String
  * @return String representation of given org.w3c.dom.Document
  */
 public String getDocumentAsString(Document doc) {

  String result = null;

  try {

   // Getting DOM Source
   DOMSource domSource = new DOMSource(doc);

   // Getting Output Stream to write result
   ByteArrayOutputStream byteOut = new ByteArrayOutputStream();

   // Getting new TransformerFactory
   TransformerFactory transformerfactory = TransformerFactory.newInstance();

   // Getting new Transformer
   Transformer transformer = transformerfactory.newTransformer();

   // Transforms DOMSource to StreamResult
   transformer.transform(domSource, new StreamResult(byteOut));

   result = byteOut.toString(); // Getting String from ByteArrayOutputStream

  } catch (Exception ex) {

   ex.printStackTrace();

  }

  return result;

 }

 /**
  * Builds org.w3c.dom.Document from given String.
  * @param strXML XML as String
  * @return org.w3c.dom.Document builded from String
  */
 public Document getStringAsDocument(String strXML) {

  Document doc = null;

  try {

   // Getting new DocumentBuilderFactory
   DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

   // Setting namespace aware to true
   factory.setNamespaceAware(true);

   // Getting new DocumentBuilder
   DocumentBuilder builder = factory.newDocumentBuilder();

   // Parsing String to Document
   doc = builder.parse(new InputSource(new StringReader(strXML)));

  } catch (Exception ex) {

   ex.printStackTrace();

  }

  return doc;

 }
}