Pure Java 4 All

Working with Data sources

2014-02-23T11:01:00.003+05:30

Here in this small example I will show how to look up an Oracle Data source

And get the connection to update the tables in a schema.

Let’s consider we have created the data sources in Weblogic application server.

Here we have created one Member Data Source with JNDI name “MemberDataSource”

This data source contains one schema say ods_membership which contains the Table called MEMBERSHIP_FUNCTIONS.

Now through java we will do JNDI LOOKUP of the data source, once we look up the data source we will create the connection and finally we will update the mentioned table.

(In similar way we can insert or query the database tables)

package com.purejava4all.datasource;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.SQLException;

import java.util.Properties;

import javax.naming.Context;

import javax.naming.InitialContext;

import javax.sql.DataSource;

public class UpdateTable {

public static String serviceUrl = null;

public static Properties props = null;

Connection con = null;

PreparedStatement stmt = null;

public static void setUp(){

// Host Port information of the Database

serviceUrl = "t3://10.20.333.70:9006";

props = new Properties();

props.put(Context.INITIAL_CONTEXT_FACTORY,

"weblogic.jndi.WLInitialContextFactory");

props.put(Context.PROVIDER_URL, serviceUrl);

System.out.println("setUp:serviceUrl::" + serviceUrl);

System.out.println("===setUp Done===");

}

public static void main(String ags[]){

setUp();

Connection con = null;

PreparedStatement stmt = null;

try {

// Creating the InitialContext

Context ctx = new InitialContext(props);

System.out.println("===got the Context===>>"+ctx);

// Doing JNDI Look Up of the Data Source

DataSource dataSource = (DataSource) ctx.lookup("jdbc/MemberDataSource");

System.out.println("===got the dataSource===>>"+dataSource);

// Creating Connection from the Data Source

con = dataSource.getConnection();

System.out.println("===got the con===>>"+con);

StringBuffer query = new StringBuffer();

// Building the query

query.append("update ods_membership. MEMBERSHIP_FUNCTIONS set ACTIVE_STATUS = ‘N’ where MEMBERSHIP_TYPE in ('ROMS','BOLS')");

stmt = con.prepareStatement(query.toString());

int count = stmt.executeUpdate();

System.out.println("===Update Done===>>"+count);

} catch (SQLException e) {

e.printStackTrace();

}catch(Exception ex){

ex.printStackTrace();

}

finally {

try{

con.close();

stmt.close();

}catch(Exception e){

e.printStackTrace();

}

Object to Xml and Xml to Object Using Java XStream

2014-02-20T04:16:00.002+05:30

This is very small but very useful code, if you run Junit test cases then it can very easily provide you java request object from XML request object. Again we write toString in object to get the object’s property information at run time, and to write toString we need to print all the properties. But if we can convert java object to String XML we can have all the object’s property values and that is very easy to read.

Xstream provides us API which converts the XML to object and object to XML again.

For this we have two dependencies jdom-1.1.jar and xstream-1.3.1.jar

Below code demonstrate the use of Xstream serialize and deserialize of an Customer object.

method getXMLToObject () converts Xml to Customer object and method getObjectToXML () converts Customer Object to Xml

package com.purejava4all;

import java.io.File;

import org.jdom.Document;

import org.jdom.input.SAXBuilder;

import org.jdom.output.XMLOutputter;

import com.thoughtworks.xstream.XStream;

import com.thoughtworks.xstream.io.xml.DomDriver;

public class XtreamUtil {

public static void main(String[] args) {

// Here we are reading Customer.xml file and converting that to Java Object

Customer customer = (Customer) getXMLToObject ("C:\\xmlfiles\\Customer.xml");

System.out.println("Xml to Customer \n" + customer);

// Once we have the java object we can use it in anywhere such as in test cases

// Here we are converting the java object again into XML String format

String customerXML = getObjectToXML (customer);

System.out.println("Customer to XML String\n" + customerXML);

}

public static T getXMLToObject(final String xmlFilePath) throws Exception {

final File file = new File(xmlFilePath);

if (!file.exists()) {

throw new Exception("File doesn't exist at " + xmlFilePath);

}

final SAXBuilder builder = new SAXBuilder();

final Document doc = builder.build(file);

final String xml = new XMLOutputter().outputString(doc);

final XStream xstream = new XStream(new DomDriver());

final Object obj = xstream.fromXML(xml);

return (T) obj;

}

public static String getObjectToXML(Object o){

XStream xstream = new XStream();

String xml = xstream.toXML(o);

return xml;

}

Web Browser Automation using Selenium

2014-02-16T21:12:00.000+05:30

Here I will discuss what is Selenium, how Selenium works and will also provide one example to demonstrate how easily we can create automated test cases using Selenium.

What is Selenium?

Selenium automates browsers. That's it! What you do with that power is entirely up to you. Primarily, it is for automating web applications for testing purposes, but is certainly not limited to just that. Boring web-based administration tasks can (and should!) also be automated as well. Selenium has the support of some of the largest browser vendors who have taken (or are taking) steps to make Selenium a native part of their browser. It is also the core technology in countless other browser automation tools, APIs and frameworks.

Selenium WebDriver

The biggest change in Selenium recently has been the inclusion of the WebDriver API. Driving a browser natively as a user would either locally or on a remote machine using the Selenium Server it marks a leap forward in terms of browser automation.

Selenium WebDriver fits in the same role as RC did, and has incorporated the original 1.x bindings. It refers to both the language bindings and the implementations of the individual browser controlling code. This is commonly referred to as just "WebDriver" or sometimes as Selenium 2.

Selenium 1.0 + WebDriver = Selenium 2.0

• WebDriver is designed in a simpler and more concise programming interface along with addressing some limitations in the Selenium-RC API.

• WebDriver is a compact Object Oriented API when compared to Selenium1.0

• It drives the browser much more effectively and over comes the limitations of Selenium 1.x which affected our functional test coverage, like the file upload or download, pop-ups and dialogs barrier

• WebDriver overcomes the limitation of Selenium Rc's Single Host origin policy

WebDriver is the name of the key interface against which tests should be written in Java, the implementing classes one should use are listed as below:

AndroidDriver, ChromeDriver, EventFiringWebDriver, FirefoxDriver, HtmlUnitDriver,InternetExplorerDriver, IPhoneDriver, PhantomJSDriver, RemoteWebDriver, SafariDriver

Let’s do some programming now…… This is small but complete example how Selenium works

First you need to download the Selenium and WebDriver libraries from www. seleniumhq.org. Here in this example I have used FirefoxDriver but you can use other Drivers for other browsers.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;

public class GoogleAutomation {

public static void googleSearch(){ System.setProperty("webdriver.firefox.bin","C:\\Users\\Roy\\AppData\\Local\\Mozilla Firefox\\Firefox.exe");

System.out.println("Opening WebDriver");
WebDriver driver = new FirefoxDriver();

System.out.println("Opening Google.com");
// And now use this to visit Google
driver.get("http://www.google.com");

// Find the text input element by its name
WebElement element = driver.findElement(By.name("q"));

// Enter something to search for
element.sendKeys("Honda Car");
System.out.println("Doing Search for Honda Car");

// Now submit the form. WebDriver will find the form for us from the element
element.submit();
// Now you can see the search results in Google
}

public static void main(String[] args) {
googleSearch();
}
}

I hope now you will be able to write some cool programs to automate Web Browsers using Selenium.

JAXB

2012-07-08T09:21:00.007+05:30

JAXB stands for Java Architecture for XML Binding

JAXB allows Java developers to access and process XML data without having to know XML or XML processing. For example, there's no need to create or use a SAX parser or write callback methods. It makes use of a given schema of an XML document and automatically generates the required Java classes, corresponding to that schema. Modern trend focuses on XML representation of Data, for ease of exchange in web-service and otherwise. If we have an xml representation of a database, we can use JAXB to create a tree of Java objects and work with them in Java idiom..This is known as XML-Data binding.

Validation is an important part of any XML document. Unlike HTML, XML tags are user-defined. This is what gives XML its power and utility. But, at the same time, to make it really useful, each such XML document should have a 'schema'....Something like Data Definition in SQL. It should be carefully noted that 'schema' is a general term. In the earlier days of XML, the only schema that was known and used was DTD (Document-type-definition). Even today, DTD is said to be the most prevalent 'schema' in use and best known, among developers.

Using JAXB annotation we do convert Java object to / from XML file. Converting a Java object into a XML file is called Marshalling and converting XML content into a java object is called Un-marshalling.

· Marshalling – Convert a Java object into a XML file.

· Un-marshalling – Convert XML content into a Java Object

Technologies used in this article

1. JDK 1.6

2. JAXB 2.0

Working with JAXB is easy, just annotate object with JAXB annotation, later use jaxbMarshaller.marshal() or jaxbMarshaller.unmarshal() to do the object / XML conversion.

JAXB Dependency

No extra JAXB libraries are required if you are using JDK1.6 or above, because JAXB is bundled in JDK 1.6. For JDK < 1.6 we need to put “jaxb-api.jar” and “jaxb-impl.jar” on our project classpath.

JAXB Annotation

For object that needs to convert to / from XML file, it have to annotate with JAXB annotation. The annotation are pretty self-explanatory, you can refer to this JAXB guide for detail explanation.

package com.myproj.core;

import javax.xml.bind.annotation.XmlAttribute;

import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement

public class Customer {

String name;

int age;

int id;

public String getName() {

return name;

}

@XmlElement

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

@XmlElement

public void setAge(int age) {

this.age = age;

}

public int getId() {

return id;

}

@XmlAttribute

public void setId(int id) {

this.id = id;

}

Convert Object to XML

JAXB marshalling example, convert customer object into a XML file. The jaxbMarshaller.marshal() contains a lot of overloaded methods, find one that suit your output.

package com.myproj.core;

import java.io.File;

import javax.xml.bind.JAXBContext;

import javax.xml.bind.JAXBException;

import javax.xml.bind.Marshaller;

public class JAXBExample {

         public static void main(String[] args) {

           Customer customer = new Customer();

           customer.setId(100);

           customer.setName("Kamesh");

           customer.setAge(29);

           try {

                 File file = new File("C:\\file.xml");

                 JAXBContext jaxbContext = JAXBContext.newInstance(Customer.class);

                 Marshaller jaxbMarshaller = jaxbContext.createMarshaller();

                 // output pretty printed

                 jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

                 jaxbMarshaller.marshal(customer, file);

                 jaxbMarshaller.marshal(customer, System.out);

               } catch (JAXBException e) {

                 e.printStackTrace();

Output

Convert XML to java Object

JAXB un-marshalling example, convert a XML file content into a customer object. The jaxbMarshaller.unmarshal()contains a lot of overloaded methods, find one that suit yours.

package com.myproj.core;

import java.io.File;

import javax.xml.bind.JAXBContext;

import javax.xml.bind.JAXBException;

import javax.xml.bind.Unmarshaller;

public class JAXBExample {

         public static void main(String[] args) {

          try {

                 File file = new File("C:\\file.xml");

                 JAXBContext jaxbContext = JAXBContext.newInstance(Customer.class);

                 Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

                 Customer customer = (Customer) jaxbUnmarshaller.unmarshal(file);

                 System.out.println(customer);

           } catch (JAXBException e) {

                 e.printStackTrace();

Output

Customer [name=Kamesh, age=29, id=100]

JAXB Architecture

A JAXB implementation consists of the following architectural components:

· Schema compiler: Binds a source schema to a set of schema-derived program elements. The binding is described by an XML-based binding language.

· Schema generator: Maps a set of existing program elements to a derived schema. The mapping is described by program annotations.

· Binding runtime framework: Provides unmarshalling (reading) and marshalling (writing) operations for accessing, manipulating, and validating XML content using either schema-derived or existing program elements.

The JAXB Binding Process

The general steps in the JAXB data binding process are:

1. Generate classes: An XML schema is used as input to the JAXB binding compiler to generate JAXB classes based on that schema.

2. Compile classes: All of the generated classes, source files, and application code must be compiled.

3. Unmarshal: XML documents written according to the constraints in the source schema are unmarshalled by the JAXB binding framework. Note that JAXB also supports unmarshalling XML data from sources other than files/documents, such as DOM nodes, string buffers, SAX Sources, and so forth.

4. Generate content tree: The unmarshalling process generates a content tree of data objects instantiated from the generated JAXB classes; this content tree represents the structure and content of the source XML documents.

5. Validate (optional): The unmarshalling process optionally involves validation of the source XML documents before generating the content tree. Note that if you modify the content tree in Step 6, below, you can also use the JAXB Validate operation to validate the changes before marshalling the content back to an XML document.

6. Process content: The client application can modify the XML data represented by the Java content tree by means of interfaces generated by the binding compiler.

7. Marshal: The processed content tree is marshalled out to one or more XML output documents. The content may be validated before marshalling.

More about Unmarshalling

Unmarshalling provides a client application the ability to convert XML data into JAXB-derived Java objects.

More about Marshalling

Marshalling provides a client application the ability to convert a JAXB-derived Java object tree back into XML data. By default, the Marshaller uses UTF-8 encoding when generating XML data.

Client applications are not required to validate the Java content tree before marshalling. There is also no requirement that the Java content tree be valid with respect to its original schema to marshal it back into XML data.

More about Validation

Validation is the process of verifying that an XML document meets all the constraints expressed in the schema. JAXB 1.0 provided validation at unmarshal time and also enabled on-demand validation on a JAXB content tree. JAXB 2.0 only allows validation at unmarshal and marshal time. A web service processing model is to be lax in reading in data and strict on writing it out. To meet that model, validation was added to marshal time so one could confirm that they did not invalidate the XML document when modifying the document in JAXB form.

Deploying EJB 2 Stateful Bean on Weblogic

2012-02-26T23:11:00.002+05:30

There are five steps involved in EJB Session bean Development and deploy process.

1. Create the Home Interface

2. Create the Remote Interface

3. Create the Session Bean

4. Define the resources in Deployment Descriptor

5. Deploy on the server

Rules for EJB Home Interface:

1. EJB Home must extend EJBHome Interface

2. Must have at least one create() Method

3. The create method should return the Component interface type (Remote interface)

4. create() method should throw “CreateException, RemoteException”.

1. Create a Home Interface

package com.test;

import java.rmi.RemoteException;

import javax.ejb.CreateException;

import javax.ejb.EJBHome;

public interface CounterHome extends EJBHome {

public Counter create(String name)throws CreateException, RemoteException;

}

Rules for Remote Interface

1. Remote must extend EJBObject Interface

2. Should contains the business methods

3. Every business method should throw RemoteException

2. Create a Remote Interface

package com.test;

import java.rmi.RemoteException;

import javax.ejb.EJBObject;

public interface Counter extends EJBObject {

public void startCounter() throws RemoteException;

public int getCounter() throws RemoteException;

}

Rules for SessionBeans

1. Every SessionBean should extend SessionBean Interface

2. In case of Stateless session bean there must be only one create method and that should must prefix with “ejbCreate”. And should be with no-arg approach.

3. Every bean should save the SessionContext copy in the “setSessionContext” method, as this bean called only once when bean gets created; saving this reference is always useful.

4. Incase of Stateful session bean, do not need to have no-arg create method. And also you can create as many as createMethod.
e.g ejbCreate(), ejbCreate(String), createCustomerPortfolio(String) etc.

3. Create Stateful session bean

package com.test;

import java.io.Serializable;

import java.rmi.RemoteException;

import javax.ejb.EJBException;

import javax.ejb.SessionBean;

import javax.ejb.SessionContext;

public class HandleCounter implements SessionBean, Serializable {

private static final long serialVersionUID = 1L;

private String userName=”";

private SessionContext ctx;

private int counter=0;

public void ejbActivate() throws EJBException, RemoteException {

System.out.println(“Inside ejbActivate”);

}

public void ejbPassivate() throws EJBException, RemoteException {

System.out.println(“Inside ejbPassivate”);

}

public void ejbRemove() throws EJBException, RemoteException {

System.out.println(“Inside ejbRemove”);

}

public void setSessionContext(SessionContext arg0) throws EJBException,

RemoteException {

this.ctx=arg0;

}

public void startCounter() throws RemoteException{

counter=counter+1;

}

public int getCounter()throws RemoteException{

return counter;

}

public void ejbCreate(String name) throws RuntimeException{

userName=name;

}

4. Deployment Descriptors of EJB Components (ejb-jar.xml)

ejb-name : Give any name for the EJB
home: EJBHome class FQDN (Fully qualified defined name)
remote: Remote class FQDN (Fully qualified defined name)
ejb-class : Session bean class FQDN (Fully qualified defined name)
session-type: Stateful or Stateless (in our case Stateful)
transaction-type: Container | Bean (let container handle this)

As we are deploying on weblogic , we need weblogic-ejb-jar.xml so that weblogic can treat this as an EJB Component and set the configuration at deploy time(JNDI name, security related etc).

ejb-name: make sure to use the same ejb-name defined in ejb-jar.xml
jndi-name: this is the name of the JNDI given the EJB component.

5. Deployment

To deploy simply extract the jar of the EJB classes and deploy in the admin console of weblogic.

Structure of the EJB Jar:
———————————————————————————–|
com.test
META-INF
– ejb-jar.xml
– weblogic-ejb-jar.xml
– manifest
————————————————————————————|

In case of stateless, keep everything same and change the bean create method to no-arg.

And change the

stateless

Client to test

public final static String JNDI_FACTORY = “weblogic.jndi.WLInitialContextFactory”;

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

InitialContext ic = getInitialContext(“t3://localhost:7001″);

CounterHome home = (CounterHome) PortableRemoteObject.narrow(ic

.lookup(“TestStateful“), CounterHome.class);

Counter adv = home.create(“ejbMarathon“);

adv.startCounter();

System.out.println(adv.getCounter());

}

private static InitialContext getInitialContext(String url)

throws NamingException {

Hashtable env = new Hashtable();

env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);

env.put(Context.PROVIDER_URL, url);

env.put(Context.SECURITY_PRINCIPAL, “ejbuser“);

env.put(Context.SECURITY_CREDENTIALS, “PASSWORD123“);

env.put(“weblogic.jndi.createIntermediateContexts”, “true”);

return new InitialContext(env);

}

----------------------------------------- END -----------------------------------------

Java Serialization

2012-01-04T00:35:00.000+05:30

Serialization involves saving the current state of an object to a stream, and restoring an equivalent object from that stream. The stream functions as a container for the object. Its contents include a partial representation of the object's internal structure, including variable types, names, and values. The container may be transient (RAM-based) or persistent (disk-based). A transient container may be used to prepare an object for transmission from one computer to another. A persistent container, such as a file on disk, allows storage of the object after the current session is finished. In both cases the information stored in the container can later be used to construct an equivalent object containing the same data as the original.

The serialized objects are JVM independent and can be re-serialized by any JVM. In this case the "in memory" java objects state are converted into a byte stream. This type of the file can not be understood by the user. It is a special types of object i.e. reused by the JVM (Java Virtual Machine). This process of serializing an object is also called deflating or marshalling an object. The example code in this article will focus on persistence.

Implementation

For an object to be serialized, it must be an instance of a class that implements either the Serializable or Externalizable interface. Both interfaces only permit the saving of data associated with an object's variables. They depend on the class definition being available to the Java Virtual Machine at reconstruction time in order to construct the object.

The Serializable interface relies on the Java runtime default mechanism to save an object's state. Writing an object is done via the writeObject() method in the ObjectOutputStream class (or the ObjectOutput interface). Writing a primitive value may be done through the appropriate write() method. Reading the serialized object is accomplished using the readObject() method of the ObjectInputStream class, and primitives may be read using the various read() methods.

The Externalizable interface specifies that the implementing class will handle the serialization on its own, instead of relying on the default runtime mechanism. This includes which fields get written (and read), and in what order. The class must define a writeExternal() method to write out the stream, and a corresponding readExternal() method to read the stream. Inside of these methods the class calls ObjectOutputStream writeObject(), ObjectInputStream readObject(), and any necessary write() and read() methods, for the desired fields.

Hiding Data

Sometimes you may wish to prevent certain fields from being stored in the serialized object. The Serializable interface allows the implementing class to specify that some of its fields do not get saved or restored. This is accomplished by placing the keyword transient before the data type in the variable declaration. For example, you may have some data which is confidential and can be re-read from a master file later (as opposed to saving it with the serialized object). Or you decide (wisely) to preserve the privacy of file references by declaring any such variables as transient. Otherwise, all fields automatically get written without any additional effort by the class.

In addition to those fields declared as transient, static fields are not serialized (written out), and so cannot be deserialized (read back in).

Another way to use Serializable, and control which fields get written, is to override the writeObject() method of the Serializable interface. Inside of this method, you are responsible for writing out the appropriate fields. If you take this approach, you will want to override readObject() as well, to control the restoration process. This is similar to using Externalizable, except that interface requires writeExternal() and readExternal().

For the Externalizable interface, since both writeExternal() and readExternal() must be declared public, this increases the risk that a rogue object could use them to determine the format of the serialized object. For this reason, you should be careful when saving object data with this interface.

Versioning

The ability to save and restore objects leads to an interesting question: what happens when an object has been stored for so long, that upon restoration it finds that its format has been superceded by a new, different version of the class?

The stream reading the serialized representation is responsible for accounting for any differences. The intent is that a newer version of a Java class should be able to interoperate with older representations of the same class, as long as there have not been certain changes in the class structure. The same does not necessarily hold true for an older version of the class, which may not be able to effectively deal with a newer representation.

So, we need some way to determine at runtime (or more appropriately, deserialization-time) whether we have the necessary backward compatibility.

In Java 1.1, changes to classes may be specified using a version number. A specific class variable, serialVersionUID (representing the Stream Unique Identifier, or SUID), may be used to specify the earliest version of the class that can be deserialized. The SUID is declared as follows:

static final long serialVersionUID = 2L;

This particular declaration and assignment specifies that version 2 is as far back as this class can go. It is not compatible with an object written by version 1 of the class, and it cannot write a version 1 object. If it encounters a version 1 object in a stream (such as when restoring from a file), an InvalidClassException will be thrown.

The SUID is a measure of backward compatibility. The same SUID can be used for multiple representations of a class, as long as newer versions can still read the older versions.

If you do not explicitly assign a SUID, a default value will be assigned when the object gets serialized. This default SUID is a hash, or unique numeric value, which is computed using the class name, interfaces, methods, and fields. The exact algorithm is defined by the S ecure Hash Algorithm (SHA).

How can you obtain the SUID for a class at runtime to determine compatibility? First, query the Virtual Machine for information about the class represented in the stream, using methods of the class ObjectStreamClass. Here is how we can get the SUID of the current version of the class named MyClass, as known to the Virtual Machine:

ObjectStreamClass myObject = ObjectStreamClass.lookup(

Class.forName( "MyClass" ) );

long theSUID = myObject.getSerialVersionUID();

Now when we restore an Externalizable object, we can compare its SUID to the class SUID just obtained. If there is a mismatch, we should take appropriate action. This may involve telling the user that we cannot handle the restoration, or we may have to assign and use some default values.

If we are restoring a Serializable object, the runtime will check the SUID for us when it attempts to read values from the stream. If you override readObject(), you will want to compare the SUIDs there.

How do you determine what changes between class versions are acceptable? For an earlier version, which may contain fewer fields, trying to read a serialized object from a later version of the same class may cause problems. There is a tendency to add fields to a class as that class evolves, which means that the earlier version does not know about the newer fields. In contrast, since a newer version of a class may look for fields that are not present in the older version, it assigns default values to those fields.

This can be seen in the example code when we add a new field to the MyVersionObject class, but don't update the SUID. The new class can still read the older stream representation, even though no values exist in that stream for the new fields. It assigns 0 to the new int, and null to the new String, but doesn't throw any exceptions. If we then increment the SUID (from 1 to 2) to indicate that we do not consider older class versions compatible with this version, we throw an InvalidClassException when attempting to read a version 1 object from the stream.

Example

The following program illustrates how to use object serialization and deserialization. It begins by instantiating an object of class MyClass. This object has three instance variables that are of types String, int, anddouble. This is the information we want to save and restore.

A FileOutputStream is created that refers to a file named "serial," and an ObjectOutputStream is created for that file stream. The writeObject() method of ObjectOutputStream is then used to serialize our object. The object output stream is flushed and closed.

A FileInputStream is then created that refers to the file named "serial," and an ObjectInputStream is created for that file stream. The readObject() method of ObjectInputStream is then used to deserialize our object. The object input stream is then closed.

Note that MyClass is defined to implement the Serializable interface. If this is not done, aNotSerializableException is thrown. Try experimenting with this program by declaring some of theMyClass instance variables to be transient. That data is then not saved during serialization.

SerializationDemo.java

import java.io.*;
public class SerializationDemo {
public static void main(String args[]) {
// Object serialization
try {
MyClass object1 = new MyClass("Hello", -7, 2.7e10);
System.out.println("object1: " + object1);
FileOutputStream fos = new FileOutputStream("serial");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(object1);
oos.flush();
oos.close();
}
catch(Exception e) {
System.out.println("Exception during serialization: " + e);
System.exit(0);
}
// Object deserialization
try {
MyClass object2;
FileInputStream fis = new FileInputStream("serial");
ObjectInputStream ois = new ObjectInputStream(fis);
object2 = (MyClass)ois.readObject();
ois.close();
System.out.println("object2: " + object2);
}
catch(Exception e) {
System.out.println("Exception during deserialization: " +
e);
System.exit(0);
}
}
}

MyClass.java

class MyClass implements Serializable {
String s;
int i;
double d;
public MyClass(String s, int i, double d) {
this.s = s;
this.i = i;
this.d = d;
}
public String toString() {
return "s=" + s + "; i=" + i + "; d=" + d;
}
}

This program demonstrates that the instance variables of object1 and object2 are
identical. The output is shown here:

object1: s=Hello; i=-7; d=2.7E10
object2: s=Hello; i=-7; d=2.7E10

Parsing XML Files in Java

2011-11-21T00:19:00.005+05:30

How to read XML file in Java – (DOM Parser)

The DOM interface is the easiest XML parser to understand, and use. It parses an entire XML document and loads it into memory, modelling it with Object for easy traversal or manipulation.

Note
DOM Parser is slow and consume a lot of memory if it load a XML document which contains a lot of data. Please consider SAX parser as solution for it, SAX is faster than DOM and use less memory.

DOM Parser Example

A DOM XML parser read below XML file and print out each elements one by one.

File : file.xml

File : ReadXMLFile.java – A Java class to read above XML file.

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.DocumentBuilder;

import org.w3c.dom.Document;

import org.w3c.dom.NodeList;

import org.w3c.dom.Node;

import org.w3c.dom.Element;

import java.io.File;

public class ReadXMLFile {

         public static void main(String argv[]) {

           try {

                 File fXmlFile = new File("c:\\file.xml");

                 DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();

                 DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();

                 Document doc = dBuilder.parse(fXmlFile);

                 doc.getDocumentElement().normalize();

                 System.out.println("Root element :" + doc.getDocumentElement().getNodeName());

                 NodeList nList = doc.getElementsByTagName("staff");

                 System.out.println("-----------------------");

                 for (int temp = 0; temp < nList.getLength(); temp++) {

                    Node nNode = nList.item(temp);

                    if (nNode.getNodeType() == Node.ELEMENT_NODE) {

                       Element eElement = (Element) nNode;

                       System.out.println("First Name : " + getTagValue("firstname", eElement));

                       System.out.println("Last Name : " + getTagValue("lastname", eElement));

                       System.out.println("Nick Name : " + getTagValue("nickname", eElement));

                       System.out.println("Salary : " + getTagValue("salary", eElement));

           } catch (Exception e) {

                 e.printStackTrace();

  private static String getTagValue(String sTag, Element eElement) {

         NodeList nlList = eElement.getElementsByTagName(sTag).item(0).getChildNodes();

        Node nValue = (Node) nlList.item(0);

         return nValue.getNodeValue();

Result:

Root element :company

-----------------------

First Name : yong

Last Name : mook kim

Nick Name : mkyong

Salary : 100000

First Name : low

Last Name : yin fong

Nick Name : fong fong

Salary : 200000

How to read XML file in Java – (SAX Parser)

SAX parser is work differently than DOM parser, it neither load any XML document into memory nor create any object representation of the XML document. Instead, the SAX parser use callback function (org.xml.sax.helpers.DefaultHandler) to informs clients of the XML document structure.

Note

SAX Parser is faster and uses less memory than DOM parser.

See following SAX callback methods :

§ startDocument() and endDocument() – Method called at the start and end of an XML document.

§ startElement() and endElement() – Method called at the start and end of a document element.

§ characters() – Method called with the text contents in between the start and end tags of an XML document element.

File : file.xml

File : ReadXMLFile.java – A Java class to read above XML file.

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

public class ReadXMLFile {

   public static void main(String argv[]) {

    try {

         SAXParserFactory factory = SAXParserFactory.newInstance();

         SAXParser saxParser = factory.newSAXParser();

         DefaultHandler handler = new DefaultHandler() {

         boolean bfname = false;

         boolean blname = false;

         boolean bnname = false;

         boolean bsalary = false;

         public void startElement(String uri, String localName,String qName,

                Attributes attributes) throws SAXException {

                 System.out.println("Start Element :" + qName);

                 if (qName.equalsIgnoreCase("FIRSTNAME")) {

                          bfname = true;

                 if (qName.equalsIgnoreCase("LASTNAME")) {

                          blname = true;

                 if (qName.equalsIgnoreCase("NICKNAME")) {

                          bnname = true;

                 if (qName.equalsIgnoreCase("SALARY")) {

                          bsalary = true;

         public void endElement(String uri, String localName,

                 String qName) throws SAXException {

                 System.out.println("End Element :" + qName);

         public void characters(char ch[], int start, int length) throws SAXException {

                 if (bfname) {

                          System.out.println("First Name : " + new String(ch, start, length));

                          bfname = false;

                 if (blname) {

                          System.out.println("Last Name : " + new String(ch, start, length));

                          blname = false;

                 if (bnname) {

                          System.out.println("Nick Name : " + new String(ch, start, length));

                          bnname = false;

                 if (bsalary) {

                          System.out.println("Salary : " + new String(ch, start, length));

                          bsalary = false;

};

       saxParser.parse("c:\\file.xml", handler);

     } catch (Exception e) {

       e.printStackTrace();

Result:

Start Element :company

Start Element :staff

Start Element :firstname

First Name : yong

End Element :firstname

Start Element :lastname

Last Name : mook kim

End Element :lastname

Start Element :nickname

Nick Name : mkyong

End Element :nickname

Start Element :salary

Salary : 100000

End Element :salary

End Element :staff

Start Element :staff

Start Element :firstname

First Name : low

End Element :firstname

Start Element :lastname

Last Name : yin fong

End Element :lastname

Start Element :nickname

Nick Name : fong fong

End Element :nickname

Start Element :salary

Salary : 200000

End Element :salary

End Element :staff

End Element :company

Warning
This example may encounter exceptions for UTF-8 XML file.

if you parse a XML file which contains some special UTF-8 characters, it will prompts “Invalid byte 1 of 1-byte UTF-8 sequence” exception.

com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceException:

Invalid byte 1 of 1-byte UTF-8 sequence.

See following xml file which contain a special UTF-8 characters “§”

To fix it, just override the SAX input source like this :

File file = new File("c:\\file-utf.xml");

InputStream inputStream= new FileInputStream(file);

Reader reader = new InputStreamReader(inputStream,"UTF-8");

InputSource is = new InputSource(reader);

is.setEncoding("UTF-8");

saxParser.parse(is, handler);

Few Important UML Diagrams

2011-08-24T11:15:00.000+05:30

The Unified Modeling Language (UML) is a standard language for specifying, visualizing, constructing, and documenting the artifacts of software systems, as well as for business modeling and other non-software systems. The UML represents a collection of best engineering practices that have proven successful in the modeling of large and complex systems. The UML is a very important part of developing objects oriented software and the software development process. The UML uses mostly graphical notations to express the design of software projects. Using the UML helps project teams communicate, explore potential designs, and validate the architectural design of the software.

The Unified Modeling Language (UML) is used to specify, visualize, modify, construct and document the artifacts of an object-oriented software-intensive system under development. UML offers a standard way to visualize a system's architectural blueprints, including elements such as:

§ activities

§ actors

§ business processes

§ database schemas

§ (logical) components

§ programming language statements

§ Reusable software components.

UML combines techniques from data modeling (entity relationship diagrams), business modeling (work flows), object modeling, and component modeling. It can be used with all processes, throughout the software development life cycle, and across different implementation technologies.

Use-Case Diagram
A use case is a set of scenarios that describing an interaction between a user and a system. A use case diagram displays the relationship among actors and use cases. The two main components of a use case diagram are use cases and actors.

An actor is represents a user or another system that will interact with the system you are modeling. A use case is an external view of the system that represents some action the user might perform in order to complete a task.

When to Use: Use Cases Diagrams
Use cases are used in almost every project. They are helpful in exposing requirements and planning the project. During the initial stage of a project most use cases should be defined, but as the project continues more might become visible.

Diagram Building Blocks

§                    Use cases
A use case describes a sequence of actions that provide something of measurable value to an actor and is drawn as a horizontal ellipse.
§                    Actors
An actor is a person, organization, or external system that plays a role in one or more interactions with the system.
§                    System boundary boxes (optional)
A rectangle is drawn around the use cases, called the system boundary box, to indicate the scope of system. Anything within the box represents functionality that is in scope and anything outside the box is not.

How to Draw: Use Cases Diagrams

Use cases are a relatively easy UML diagram to draw, but this is a very simplified example. This example is only meant as an introduction to the UML and use cases.

Start by listing a sequence of steps a user might take in order to complete an action. For example a user placing an order with a sales company might follow these steps.

1.      Browse catalog and select items.
2.      Call sales representative.
3.      Supply shipping information.
4.      Supply payment information.
5.      Receive conformation number from salesperson.

These steps would generate this simple use case diagram:

Class Diagram

In software engineering, a class diagram in the Unified Modeling Language (UML) is a type of static structure diagram that describes the structure of a system by showing the system's classes, their attributes, operations (or methods), and the relationships among the classes.
The class diagram is the main building block in object oriented modeling. It is used both for general conceptual modeling of the systematic of the application, and for detailed modeling translating the models into programming code. The classes in a class diagram represent both the main objects and or interactions in the application and the objects to be programmed. In the class diagram these classes are represented with boxes which contain three parts:

Classes are composed of three things: a name, attributes, and operations. Below is an example of a class.

Class diagrams also display relationships such as containment, inheritance, associations and others. Below is an example of an associative relationship:

The association relationship is the most common relationship in a class diagram. The association shows the relationship between instances of classes. For example, the class Order is associated with the class Customer. The multiplicity of the association denotes the number of objects that can participate in then relationship. For example, an Order object can be associated to only one customer, but a customer can be associated to many orders.
Another common relationship in class diagrams is a generalization. A generalization is used when two classes are similar, but have some differences. Look at the generalization below:

In this example the classes Corporate Customer and Personal Customer have some similarities such as name and address, but each class has some of its own attributes and operations. The class Customer is a general form of both the Corporate Customer and Personal Customer classes.This allows the designers to just use the Customer class for modules and do not require in-depth representation of each type of customer.

In this example the classes Corporate Customer and Personal Customer have some similarities such as name and address, but each class has some of its own attributes and operations. The class Customer is a general form of both the Corporate Customer and Personal Customer classes. This allows the designers to just use the Customer class for modules and do not require in-depth representation of each type of customer.

When to Use: Class Diagrams
Class diagrams are used in nearly all Object Oriented software designs. Use them to describe the Classes of the system and their relationships to each other.

How to Draw: Class Diagrams
Class diagrams are some of the most difficult UML diagrams to draw. To draw detailed and useful diagrams a person would have to study UML and Object Oriented principles for a long time. Therefore, this page will give a very high level overview of the process. To find list of where to find more information see the Resources page.

Before drawing a class diagram consider the three different perspectives of the system the diagram will present; conceptual, specification, and implementation. Try not to focus on one perspective and try see how they all work together.

When designing classes consider what attributes and operations it will have. Then try to determine how instances of the classes will interact with each other. These are the very first steps of many in developing a class diagram. However, using just these basic techniques one can develop a complete view of the software system.

Sequence diagram

A sequence diagram in Unified Modeling Language (UML) is a kind of interaction diagram that shows how processes operate with one another and in what order. It is a construct of a Message Sequence Chart. Sequence diagrams are sometimes called event diagrams, event scenarios, and timing diagrams.
A sequence diagram shows, as parallel vertical lines (lifelines), different processes or objects that live simultaneously, and, as horizontal arrows, the messages exchanged between them, in the order in which they occur. This allows the specification of simple runtime scenarios in a graphical manner.

Figure: A sequence diagram that has incoming and outgoing messages

Factory Method Design Pattern in Java

2011-06-14T02:42:00.001+05:30

Let us examine a practical scenario which is suitable for factory method pattern.
We are developing an enterprise application. You are responsible for authentication module. But you are not sure how you are going to do authentication. You can have authentication against LDAP, database or any other centralized directory. So you first define an interface for authentication with single method authorize() This method returns true if user is successfully authenticated or false if not authenticated.

public interface UserAuthentication {

         public boolean authorize();

OK, now let us create concreate implementation for this interface. Since you can have multiple ways of authenticating against users, you would like to create multiple derived classes.
Let us create a class which authenticate against users table in database using JDBC.

public class JDBCUserAuthentication implements UserAuthentication {

        @Override

        public boolean authorize() {

               boolean result=false;

               // implementation for authentication using JDBC

               //if authenticated

               //result=true

               //else

               //result=false

               return result;

Similarly another class which authenticate against LDAP.

public class LDAPUserAuthentication implements UserAuthentication {

        @Override

        public boolean authorize() {

               boolean result=false;

               // implementation for authentication using LDAP

               //if authenticated

               //result=true

               //else

               //result=false

               return result;

Well, now we have two implementations, one using JDBC and another using LDAP. Now let us create factory class.

public class UserAuthenticationFactory {

        public static UserAuthentication getUserAuthentication(String type){

               if (type.equalsIgnoreCase("jdbc")){

                       return new JDBCUserAuthentication();

               }else if(type.equalsIgnoreCase("ldap")){

                       return new LDAPUserAuthentication();

               }else{

                       return new JDBCUserAuthentication();

In the above class we define a static method getUserAuthentication() which instantiates appropriate sub class based on parameter.

When you do authentication your code snippet may be as follows.

//declare isAuthorized variable

boolean isAuthorized=false;

//get UserAuthentication object

UserAuthentication userAuthentication=

        UserAuthenticationFactory.getUserAuthentication("jdbc");

isAuthorized=userAuthentication.authorize();

if(isAuthorized){

        //redirect to home page

}else{

        //redirect to login page

Here we call static method of our factory class which in turn instantiates JDBCUserAuthentication class because we pass parameter as as “jdbc”. But the user who write client call for authentication do not require to know which derived class is instantiated and its implementation details.
I hope you got enough clarity about factory method pattern and its implementation in practical scenario.

Hibernate 3.0

2011-06-10T00:20:00.002+05:30

What is Hibernate?

Hibernate 3.0, the latest Open Source persistence technology at the heart of J2EE EJB 3.0. Hibernate maps the Java classes to the database tables. It also provides the data query and retrieval facilities that significantly reduces the development time. Hibernate is not the best solutions for data centric applications that only uses the stored-procedures to implement the business logic in database. It is most useful with object-oriented domain modes and business logic in the Java-based middle-tier. Hibernate allows transparent persistence that enables the applications to switch any database. Hibernate can be used in Java Swing applications, Java Servlet-based applications, or J2EE applications using EJB session beans.

High level architecture of hibernate:

The above diagram shows that Hibernate is using the database and configuration data to provide persistence services (and persistent objects) to the application.

To use Hibernate, it is required to create Java classes that represents the table in the database and then map the instance variable in the class with the columns in the database. Then Hibernate can be used to perform operations on the database like select, insert, update and delete the records in the table. Hibernate automatically creates the query to perform these operations.

Hibernate architecture has three main components:

· Connection Management
Hibernate Connection management service provide efficient management of the database connections. Database connection is the most expensive part of interacting with the database as it requires a lot of resources of open and close the database connection.

· Transaction management:
Transaction management service provide the ability to the user to execute more than one database statements at a time.

· Object relational mapping:
Object relational mapping is technique of mapping the data representation from an object model to a relational data model. This part of the hibernate is used to select, insert, update and delete the records form the underlying table. When we pass an object to a Session.save() method, Hibernate reads the state of the variables of that object and executes the necessary query.

Configuring Hibernate

In this application Hibernate provided connection pooling and transaction management is used for simplicity. Hibernate uses the hibernate.cfg.xml to create the connection pool and setup required environment.

Here is the code:

In the above configuration file we specified to use the "hibernatetutorial" which is running on localhost and the user of the database is root with no password. The dialect property is org.hibernate.dialect.MySQLDialect which tells the Hibernate that we are using MySQL Database. Hibernate supports many database. With the use of the Hibernate (Object/Relational Mapping and Transparent Object Persistence for Java and SQL Databases), we can use the following databases dialect type property:

DB2 - org.hibernate.dialect.DB2Dialect
HypersonicSQL - org.hibernate.dialect.HSQLDialect
Informix - org.hibernate.dialect.InformixDialect
Ingres - org.hibernate.dialect.IngresDialect
Interbase - org.hibernate.dialect.InterbaseDialect
Pointbase - org.hibernate.dialect.PointbaseDialect
PostgreSQL - org.hibernate.dialect.PostgreSQLDialect
Mckoi SQL - org.hibernate.dialect.MckoiDialect
Microsoft SQL Server - org.hibernate.dialect.SQLServerDialect
MySQL - org.hibernate.dialect.MySQLDialect
Oracle (any version) - org.hibernate.dialect.OracleDialect
Oracle 9 - org.hibernate.dialect.Oracle9Dialect
Progress - org.hibernate.dialect.ProgressDialect
FrontBase - org.hibernate.dialect.FrontbaseDialect
SAP DB - org.hibernate.dialect.SAPDBDialect
Sybase - org.hibernate.dialect.SybaseDialect
Sybase Anywhere - org.hibernate.dialect.SybaseAnywhereDialect

The property is the mapping for our contact table.

Writing First Persistence Class

Hibernate uses the Plain Old Java Objects (POJOs) classes to map to the database table. We can configure the variables to map to the database column. Here is the code for Contact.java:

package com.tutorial.hibernate;
/**
* @author Roy
*
* Java Class to map to the datbase Contact Table
*/
public class Contact {
  private String firstName;
  private String lastName;
  private String email;
  private long id;

  /**
* @return Email
*/
  public String getEmail() {
  return email;
  }

  /**
* @return First Name
*/
  public String getFirstName() {
  return firstName;
  }

  /**
* @return Last name
*/
  public String getLastName() {
  return lastName;
  }

  /**
* @param string Sets the Email
*/
  public void setEmail(String string) {
  email = string;
  }

  /**
* @param string Sets the First Name
*/
  public void setFirstName(String string) {
  firstName = string;
  }

  /**
* @param string sets the Last Name
*/
  public void setLastName(String string) {
  lastName = string;
  }

  /**
* @return ID Returns ID
*/
  public long getId() {
  return id;
  }

  /**
* @param l Sets the ID
*/
  public void setId(long l) {
  id = l;
  }

}

Mapping the Contact Object to the Database Contact table

The file contact.hbm.xml is used to map Contact Object to the Contact table in the database. Here is the code for contact.hbm.xml:

Setting Up MySQL Database
In the configuration file(hibernate.cfg.xml) we have specified to use hibernatetutorial database running on localhost. So, create the databse ("hibernatetutorial") on the MySQL server running on localhost.

Developing Code to Test Hibernate example
Now we are ready to write a program to insert the data into database. We should first understand about the Hibernate's Session. Hibernate Session is the main runtime interface between a Java application and Hibernate. First we are required to get the Hibernate Session.SessionFactory allows application to create the Hibernate Sesssion by reading the configuration from hibernate.cfg.xml file. Then the save method on session object is used to save the contact information to the database: session.save(contact)

Here is the code of FirstExample.java

package com.tutorial.hibernate;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
/**
* @author Roy
*
* Hibernate example to inset data into Contact table
*/
public class FirstExample {
  public static void main(String[] args) {
  Session session = null;

  try{
  // This step will read hibernate.cfg.xml

and prepare hibernate for use
SessionFactory sessionFactory = new

Configuration().configure().buildSessionFactory();
session =sessionFactory.openSession();
//Create new instance of Contact and set

values in it by reading them from form object
System.out.println("Inserting Record");
  Contact contact = new Contact();
  contact.setId(3);
  contact.setFirstName("Biswajit");
  contact.setLastName("Roy");
  contact.setEmail("biswajitroy04@gmail.com");
  session.save(contact);
  System.out.println("Done");
  }catch(Exception e){
  System.out.println(e.getMessage());
  }finally{
  // Actual contact insertion will happen at this step
  session.flush();
  session.close();

  }
}
  }

Understanding Hibernate O/R Mapping

Now let's understand the each component of the mapping file.

To recall here is the content of contact.hbm.xml:

Hibernate mapping documents are simple xml documents. Here are important elements of the mapping file:

element
The first or root element of hibernate mapping document is element. Between the <hibernate-mapping> tag class element(s) are present.
element
The element maps the class object with corresponding entity in the database. It also tells what table in the database has to access and what column in that table it should use. Within one element, several mappings are possible.
element
The element in unique identifier to identify and object. In fact element map with the primary key of the table. In our code :

primary key maps to the ID field of the table CONTACT. The attributes of the id element are:

name: The property name used by the persistent class.
column: The column used to store the primary key value.
type: The Java data type used.
unsaved-value: This is the value used to determine if a class has been made persistent. If the value of the id attribute is null, then it means that this object has not been persisted.

element
The method is used to generate the primary key for the new record. Here is some of the commonly used generators :

* Increment - This is used to generate primary keys of type long, short or int that are unique only. It should not be used in the clustered deployment environment.

* Sequence - Hibernate can also use the sequences to generate the primary key. It can be used with DB2, PostgreSQL, Oracle, SAP DB databases.

* Assigned - Assigned method is used when application code generates the primary key.

element
The property elements define standard Java attributes and their mapping into database schema. The property element supports the column child element to specify additional properties, such as the index name on a column or a specific column type.

Understanding Hibernate element

The element

This is the optional element under element. The element is used to specify the class name to be used to generate the primary key for new record while saving a new record. The element is used to pass the parameter (s) to the class. Here is the example of generator element from our first application:

In this case element do not generate the primary key and it is required to set the primary key value before calling save() method.

Here are the list of some commonly used generators in hibernate:

Generator	Description
increment	It generates identifiers of type long, short or int that are unique only when no other process is inserting data into the same table. It should not the used in the clustered environment.
identity	It supports identity columns in DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL. The returned identifier is of type long, short or int.
sequence	The sequence generator uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in Interbase. The returned identifier is of type long, short or int
hilo	The hilo generator uses a hi/lo algorithm to efficiently generate identifiers of type long, short or int, given a table and column (by default hibernate_unique_key and next_hi respectively) as a source of hi values. The hi/lo algorithm generates identifiers that are unique only for a particular database. Do not use this generator with connections enlisted with JTA or with a user-supplied connection.
seqhilo	The seqhilo generator uses a hi/lo algorithm to efficiently generate identifiers of type long, short or int, given a named database sequence.
uuid	The uuid generator uses a 128-bit UUID algorithm to generate identifiers of type string, unique within a network (the IP address is used). The UUID is encoded as a string of hexadecimal digits of length 32.
guid	It uses a database-generated GUID string on MS SQL Server and MySQL.
native	It picks identity, sequence or hilo depending upon the capabilities of the underlying database.
assigned	lets the application to assign an identifier to the object before save() is called. This is the default strategy if no element is specified.
select	retrieves a primary key assigned by a database trigger by selecting the row by some unique key and retrieving the primary key value.
foreign	uses the identifier of another associated object. Usually used in conjunction with a primary key association.

Using Hibernate to generate id incrementally

Create Table in the mysql database:
User the following sql statement to create a new table in the database.
CREATE TABLE `book` (
`id` int(11) NOT NULL default '0',
`bookname` varchar(50) default NULL,
PRIMARY KEY (`id`)
) TYPE=MyISAM

Developing POJO Class (Book.java)
Book.java is our POJO class which is to be persisted to the database table "book".

/**
* @author Roy
*
* Java Class to map to the database Book table
*/
package com.tutorial.hibernate;

public class Book {
  private long lngBookId;
  private String strBookName;

  /**
* @return Returns the lngBookId.
*/
  public long getLngBookId() {
  return lngBookId;
  }
  /**
* @param lngBookId The lngBookId to set.
*/
  public void setLngBookId(long lngBookId) {
  this.lngBookId = lngBookId;
  }
  /**
* @return Returns the strBookName.
*/
  public String getStrBookName() {
  return strBookName;
  }
  /**
* @param strBookName The strBookName to set.
*/
  public void setStrBookName(String strBookName) {
  this.strBookName = strBookName;
  }
}

Adding Mapping entries to contact.hbm.xml
Add the following mapping code into the contact.hbm.xml file

Write the client program and test it out
Here is the code of our client program to test the application.

/**
* @author Roy
*
* Example to show the increment
class of hibernate
generator element to
* automatically generate
the primay key
*/
package com.tutorial.hibernate;

//Hibernate Imports
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class IdIncrementExample {
  public static void main
(String[] args) {
  Session session = null;

  try{
  // This step will read
hibernate.cfg.xml and
prepare hibernate for use
  SessionFactory sessionFactory =
new Configuration().configure()
.buildSessionFactory();
  session =sessionFactory.openSession();

  org.hibernate.Transaction tx =
session.beginTransaction();

  //Create new instance
of Contact and set values in
it by reading them from form object
System.out.println("
Inserting Book object
into database..");
  Book book = new Book();
  book.setStrBookName("Hibernate
Tutorial");
  session.save(book);
  System.out.println("Book object
persisted to the database.");
  tx.commit();
  session.flush();
  session.close();
  }catch(Exception e){
  System.out.println(e.getMessage());
  }finally{
  }

  }
}

To test the program Select Run->Run As -> Java Application from the eclipse menu bar. This will create a new record into the book table.

Hibernate Update Query

Create a java class:
Here is the code of our java file (UpdateExample.java), where we will update a field name "InsuranceName" with a value="Jivan Dhara" from a row of the insurance table.

Here is the code of delete query: UpdateExample .java

package com.tutorial.hibernate;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class UpdateExample {
  /**
* @param args
*/
  public static void main(String[] args) {
  // TODO Auto-generated method stub
  Session sess = null;
  try {
  SessionFactory fact = new Configuration()
.configure().buildSessionFactory();
  sess = fact.openSession();
  Transaction tr = sess.beginTransaction();
  Insurance ins = (Insurance)sess.get
(Insurance.class, new Long(1));
  ins.setInsuranceName("Jivan Dhara");
  ins.setInvestementAmount(20000);
  ins.setInvestementDate(new Date());
  sess.update(ins);
  tr.commit();
  sess.close();
  System.out.println("Update successfully!");
  }
  catch(Exception e){
  System.out.println(e.getMessage());
  }
  }
}

Hibernate Delete Query

Create a java class:
Here is the code of our java file (DeleteHQLExample.java), which we will delete a row from the insurance table using the query "delete from Insurance insurance where id = 2"

Here is the code of delete query: DeleteHQLExample.java

package com.tutorial.hibernate;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class DeleteHQLExample {
  /**
* @author Roy
*
Criteria Query Example
*
*/
  public static void main(String[] args) {
  // TODO Auto-generated method stub
  Session sess = null;
  try {
  SessionFactory fact = new
Configuration().configure().buildSessionFactory();
  sess = fact.openSession();
  String hql = "delete from
Insurance insurance where id = 2";
  Query query = sess.createQuery(hql);
  int row = query.executeUpdate();
  if (row == 0){
  System.out.println("Doesn'
t deleted any row!");
  }
  else{
  System.out.println("Deleted
Row: " + row);
  }
  sess.close();
  }
  catch(Exception e){
  System.out.println(e.getMessage());
  }
  }
}

Hibernate Query Language

Hibernate Query Language or HQL for short is extremely powerful query language. HQL is much like SQL and are case-insensitive, except for the names of the Java Classes and properties. Hibernate Query Language is used to execute queries against database. Hibernate automatically generates the sql query and execute it against underlying database if HQL is used in the application. HQL is based on the relational object models and makes the SQL object oriented. Hibernate Query Language uses Classes and properties instead of tables and columns. Hibernate Query Language is extremely powerful and it supports Polymorphism, Associations, Much less verbose than SQL.

Why to use HQL?

Full support for relational operations: HQL allows representing SQL queries in the form of objects. Hibernate Query Language uses Classes and properties instead of tables and columns.
Return result as Object: The HQL queries return the query result(s) in the form of object(s), which is easy to use. This elemenates the need of creating the object and populate the data from result set.
Polymorphic Queries: HQL fully supports polymorphic queries. Polymorphic queries results the query results along with all the child objects if any.
Easy to Learn: Hibernate Queries are easy to learn and it can be easily implemented in the applications.
Support for Advance features: HQL contains many advance features such as pagination, fetch join with dynamic profiling, Inner/outer/full joins, Cartesian products. It also supports Projection, Aggregation (max, avg) and grouping, Ordering, Sub queries and SQL function calls.
Database independent: Queries written in HQL are database independent (If database supports the underlying feature).

Understanding HQL Syntax
Any Hibernate Query Language may consist of following elements:

Clauses
Aggregate functions
Subqueries

Clauses in the HQL are:

from
select
where
order by
group by

Aggregate functions are:

avg(...), sum(...), min(...), max(...)
count(*)
count(...), count(distinct ...), count(all...)

Subqueries
Subqueries are nothing but its a query within another query. Hibernate supports Subqueries if the underlying database supports it.

HQL from clause Example

from Insurance insurance

Here is the full code of the from clause example:

package com.tutorial.hibernate;

import org.hibernate.Session;
import org.hibernate.*;
import org.hibernate.cfg.*;

import java.util.*;

/**
* @author Roy
*
* Select HQL Example
*/
public class SelectHQLExample {

  public static void main(String[] args) {
  Session session = null;

  try{
  // This step will read hibernate.cfg.xml
and prepare hibernate for use
  SessionFactory sessionFactory = new
Configuration().configure().buildSessionFactory();
session =sessionFactory.openSession();

//Using from Clause
  String SQL_QUERY ="from Insurance insurance";
  Query query = session.createQuery(SQL_QUERY);
  for(Iterator it=query.iterate();it.hasNext();){
Insurance insurance=(Insurance)it.next();
System.out.println("ID: " +
insurance.getLngInsuranceId());
System.out.println("First
Name: " + insurance.getInsuranceName());
}

  session.close();
}catch(Exception e){
  System.out.println(e.getMessage());
}finally{
  }

  }
}

Hibernate Select Clause

Select insurance.lngInsuranceId, insurance.insuranceName, insurance.investementAmount, insurance.investementDate from Insurance insurance

Hibernate generates the necessary sql query and selects all the records from Insurance table. Here is the code of our java file which shows how select HQL can be used:

and prepare hibernate for use
SessionFactory sessionFactory = new

Configuration().configure()
.buildSessionFactory();
session =sessionFactory.openSession();

//Create Select Clause HQL
String SQL_QUERY ="Select insurance.

lngInsuranceId,insurance.insuranceName," +
"insurance.investementAmount,insurance.

investementDate from Insurance insurance";
Query query = session.createQuery(SQL_QUERY);
for(Iterator it=query.iterate();it.hasNext();){
Object[] row = (Object[]) it.next();
System.out.println("ID: " + row[0]);
System.out.println("Name: " + row[1]);
System.out.println("Amount: " + row[2]);
}

  session.close();
  }catch(Exception e){
  System.out.println(e.getMessage());
  }finally{
  }
  }
}

HQL Where Clause Example

from Insurance where lngInsuranceId='1'

Where Clause can be used with or without Select Clause. Here the example code:

package com.tutorial.hibernate;

import org.hibernate.Session;
import org.hibernate.*;
import org.hibernate.cfg.*;

import java.util.*;

/**
* @author Roy
*
* HQL Where Clause Example
* Where Clause With Select Clause Example
*/
public class WhereClauseExample {
  public static void main(String[] args) {
  Session session = null;

  try{
  // This step will read hibernate.cfg.
xml and prepare hibernate for use
  SessionFactory sessionFactory = new
Configuration().configure().
buildSessionFactory();
  session =sessionFactory.openSession();

  System.out.println("***************
****************");
  System.out.println("Query using
Hibernate Query Language");
  //Query using Hibernate Query Language
String SQL_QUERY =" from Insurance
as insurance where insurance.
lngInsuranceId='1'";
Query query = session.createQuery
(SQL_QUERY);
for(Iterator it=query.iterate()
;it.hasNext();){
Insurance insurance=(Insurance)it
.next();
System.out.println("ID: " + insurance.
getLngInsuranceId());
System.out.println("Name: "
+ insurance. getInsuranceName());

}
System.out.println("****************
***************");
System.out.println("Where Clause With
Select Clause");
  //Where Clause With Select Clause
SQL_QUERY ="Select insurance.
lngInsuranceId,insurance.insuranceName," +
"insurance.investementAmount,
insurance.investementDate from Insurance
insurance "+ " where insurance.
lngInsuranceId='1'";
query = session.createQuery(SQL_QUERY);
for(Iterator it=query.iterate();it.
hasNext();){
Object[] row = (Object[]) it.next();
System.out.println("ID: " + row[0]);
System.out.println("Name: " + row[1]);

}
System.out.println("***************
****************");

  session.close();
  }catch(Exception e){
  System.out.println(e.getMessage());
  }finally{
  }
  }
}

HQL Order By Example

Order by clause is used to retrieve the data from database in the sorted order by any property of returned class or components. HQL supports Order By Clause. In our example we will retrieve the data sorted on the insurance type. Here is the java example code:

package com.tutorial.hibernate;
import org.hibernate.Session;
import org.hibernate.*;
import org.hibernate.cfg.*;
import java.util.*;
/**
* @author Roy
*
* HQL Order by Clause Example
*
*/
public class HQLOrderByExample {
  public static void main(String[] args) {
  Session session = null;
  try {
  // This step will read hibernate.
cfg.xml and prepare hibernate for
  // use
  SessionFactory sessionFactory =
new Configuration().configure()
  .buildSessionFactory();
  session = sessionFactory.openSession();
  //Order By Example
  String SQL_QUERY = " from Insurance as
insurance order by insurance.insuranceName";
  Query query =
session.createQuery(SQL_QUERY);
  for (Iterator it
= query.iterate(); it.hasNext();) {
  Insurance insurance = (Insurance) it.next();
  System.out.println("ID: " + insurance.
getLngInsuranceId());
  System.out.println("Name: " +
insurance.getInsuranceName());
  }
  session.close();
  } catch (Exception e) {
  System.out.println(e.getMessage());
  } finally {
  }
  }
}

HQL Group By Clause Example

Group by clause is used to return the aggregate values by grouping on returned component. HQL supports Group By Clause. In our example we will calculate the sum of invested amount in each insurance type. Here is the java code for calculating the invested amount insurance wise:

package com.tutorial.hibernate;
import org.hibernate.Session;
import org.hibernate.*;
import org.hibernate.cfg.*;
import java.util.*;
/**
* @author Roy
*
HQL Group by Clause Example
*
*/
public class HQLGroupByExample {
  public static void main(String[] args) {
  Session session = null;
  try {
  // This step will read
hibernate.cfg.xml and prepare hibernate for
  // use
  SessionFactory sessionFactory =
new Configuration().configure()
  .buildSessionFactory();
  session = sessionFactory.openSession();
  //Group By Clause Example
  String SQL_QUERY = "select sum
(insurance.investementAmount),
insurance.insuranceName "
  + "from Insurance insurance
group by insurance.insuranceName";
Query query = session.createQuery(SQL_QUERY);
for (Iterator it =
query.iterate(); it.hasNext();) {
Object[] row = (Object[]) it.next();
System.out.println("
Invested Amount: " + row[0]);
System.out.println("
Insurance Name: " + row[1]);
  }
  session.close();
  } catch (Exception e) {
  System.out.println(e.getMessage());
  } finally {
  }
  }
}

EJB

2011-06-09T23:19:00.002+05:30

EJB stands for "Enterprise JavaBeans" which are server-side component that encapsulates the business logic of an application and for developing secure, scalable, transactional and multi-user components in a J2EE environment.

Benefits of Enterprise Beans

For several reasons, enterprise beans simplify the development of large, distributed applications. First, because the EJB container provides system-level services to enterprise beans, the bean developer can concentrate on solving business problems. The EJB container--not the bean developer--is responsible for system-level services such as transaction management and security authorization.
Second, because the beans--and not the clients--contain the application's business logic, the client developer can focus on the presentation of the client. The client developer does not have to code the routines that implement business rules or access databases. As a result, the clients are thinner, a benefit that is particularly important for clients that run on small devices.
Third, because enterprise beans are portable components, the application assembler can build new applications from existing beans. These applications can run on any compliant J2EE server.

When to Use Enterprise Beans

You should consider using enterprise beans if your application has any of the following requirements:

· The application must be scalable. To accommodate a growing number of users, you may need to distribute an application's components across multiple machines. Not only can the enterprise beans of an application run on different machines, but their location will remain transparent to the clients.

· Transactions are required to ensure data integrity. Enterprise beans support transactions, the mechanisms that manage the concurrent access of shared objects.

· The application will have a variety of clients. With just a few lines of code, remote clients can easily locate enterprise beans. These clients can be thin, various, and numerous.

Beans, Clients, Containers, and Servers

An EJB is essentially a managed component that is created, controlled, and destroyed by the J2EE container in which it lives. This control allows the container to control the number of EJBs currently in existence and the resources they are using, such as memory and database connections. Each container will maintain a pool of EJB instances that are ready to be assigned to a client. When a client no longer needs an EJB, the EJB instance will be returned to the pool and all of its resources will be released. At times of heavy load, even EJB instances that are still in use by clients will be returned to the pool so they can service other clients. When the original client makes another request of its EJB, the container will reconstitute the original EJB instance to service the request. This pooling and recycling of EJB instances means that a few EJB instances, and the resources they use, can be shared between many clients. This maximizes the scalability of the EJB-based application.

The client that uses the EJB instance does not need to know about all of this work by the container. As far as the client is concerned, it is talking to a remote component that supports defined business methods. How those methods are implemented and any magic performed by the container, such as just-in-time instantiation of that specific component instance, are entirely transparent to the client part of the application.

The EJB benefits from certain services provided by the container, such as automatic security, automatic transactions, lifecycle management, and so on. To do this, the EJB must conform to certain rules and implement an appropriate interface that allows the container to manage the component. The EJB is packaged with configuration information that indicates the component's requirements, such as transaction and security requirements. The container will then use this information to perform authentication and control transactions on behalf of the component—the component does not have to contain code to perform such tasks.

The primary purpose of the container is to control and provide services for the EJBs it contains. When it needs to use some underlying functionality, such as creating a transaction on behalf of a bean, it uses the facilities of the underlying EJB server. The EJB server is the base set of services on top of which the container runs. Different types of EJB will run in different containers, but many different EJB containers can run on a single EJB server. EJB servers are generally delivered as part of a J2EE-compliant application server (examples include BEA WebLogic and IBM WebSphere). You will install and run the application server, which will provide the underlying services required of an EJB server and will host EJB containers.

More on EJB Container

Enterprise beans are software components that run in a special environment called an EJB container. The container hosts and manages an enterprise bean in the same manner that the Java Web Server hosts a servlet or an HTML browser hosts a Java applet. An enterprise bean cannot function outside of an EJB container. The EJB container manages every aspect of an enterprise bean at runtimes including remote access to the bean, security, persistence, transactions, concurrency, and access to and pooling of resources.

The container isolates the enterprise bean from direct access by client applications. When a client application invokes a remote method on an enterprise bean, the container first intercepts the invocation to ensure persistence, transactions, and securities are applied properly to every operation a client performs on the bean. The container manages security, transactions, and persistence automatically for the bean, so the bean developer doesn't have to write this type of logic into the bean code itself. The enterprise bean developer can focus on encapsulating business rules, while the container takes care of everything else.

Containers will manage many beans simultaneously in the same fashion that the Java WebServer manages many servlets. To reduce memory consumption and processing, containers pool resources and manage the lifecycles of all the beans very carefully. When a bean is not being used, a container will place it in a pool to be reused by another client, or possibly evict it from memory and only bring it back when its needed. Because client applications don't have direct access to the beans--the container lies between the client and bean--the client application is completely unaware of the containers resource management activities. A bean that is not in use, for example, might be evicted from memory on the server, while its remote reference on the client remains intact. When the client invokes a method on the remote reference, the container simply re-incarnates the bean to service the request. The client application is unaware of the entire process.
An enterprise bean depends on the container for everything it needs. If an enterprise bean needs to access a JDBC connection or another enterprise bean, it does so through the container; if an enterprise bean needs to access the identity of its caller, obtain a reference to itself, or access properties it does so through the container. The enterprise bean interacts with its container through one of three mechanisms: callback methods, the EJBContext interface, or the Java Naming and Directory Interface (JNDI).

Callback Methods

Every bean implements a subtype of the EnterpriseBean interface which defines several methods, called callback methods. Each callback method alerts the bean TO a different event in its lifecycle and the container will invoke these methods to notify the bean when it's about to activate the bean, persist its state to the database, end a transaction, remove the bean from memory, etc. The callback methods give the bean a chance to do some housework immediately before or after some event.

EJBContext

Every bean obtains an EJBContext object, which is a reference directly to the container. The EJBContext interface provides methods for interacting with the container so that that bean can request information about its environment like the identity of its client, the status of a transaction, or to obtain remote references to itself.

Java Naming and Directory Interface

Java Naming and Directory Interface (JNDI) is a standard extension to the Java platform for accessing naming systems like LDAP, NetWare, file systems, etc. Every bean automatically has access to a special naming system called the Environment Naming Context (ENC). The ENC is managed by the container and accessed by beans using JNDI. The JNDI ENC allows a bean to access resources like JDBC connections, other enterprise beans, and properties specific to that bean.

So the Container Services are

· Distribution via proxies—The container will generate a client-side stub and server-side skeleton for the EJB. The stub and skeleton will use RMI over IIOP to communicate.

· Lifecycle management—Bean initialization, state management, and destruction is driven by the container, all the developer must do is implement the appropriate methods.

· Naming and registration—The EJB container and server will provide the EJB with access to naming services. These services are used by local and remote clients to look up the EJB and by the EJB itself to look up resources it may need.

· Transaction management—Declarative transactions provide a means for the developer to easily delegate the creation and control of transactions to the container.

· Security and access control—Again, declarative security provides a means for the developer to easily delegate the enforcement of security to the container.

· Persistence (if you want)—Using the Entity EJB's container-managed persistence mechanism, state can be saved and restored without having to write a single line of code.

Enterprise Beans

To create an EJB server-side component, an enterprise bean developer provides two interfaces that define a bean's business methods, plus the actual bean implementation class. The client then uses a bean's public interfaces to create, manipulate, and remove beans from the EJB server. The implementation class, to be called the bean class, is instantiated at runtime and becomes a distributed object.
Enterprise beans live in an EJB container and are accessed by client applications over the network through their remote and home interfaces. The remote and home interfaces expose the capabilities of the bean and provide all the method needed to create, update, interact with, and delete the bean. A bean is a server-side component that represents a business concept like a Customer or a HotelClerk.

Remote and Home Interfaces
The remote and home interfaces represent the bean, but the container insulates the beans from direct access from client applications. Every time a bean is requested, created, or deleted, the container manages the whole process.
The home interface represents the life-cycle methods of the component (create, destroy, find) while the remote interface represents the business method of the bean. The remote and home interfaces extend the javax.ejb.EJBObject and javax.ejb.EJBHome interfaces respectively. These EJB interface types define a standard set of utility methods and provide common base types for all remote and home interfaces.

Clients use the bean's home interface to obtain references to the bean's remote interface. The remote interface defines the business methods like accessor and mutator methods for changing a customer's name, or business methods that perform tasks like using the HotelClerk bean to reserve a room at a hotel. Below is an example of how a Customer bean might be accessed from a client application.

Types of EJB

EJB components come in three varieties, each with its own defined role and life cycle:

Session beans — These may be either stateful or stateless, and are primarily used to encapsulate business logic, carry out tasks on behalf of a client, and act as controllers or managers for other beans.
Entity beans — Entity beans represent persistent objects or business concepts that exist beyond a specific application's lifetime; they are typically stored in a relational database. Entity beans can be developed using bean-managed persistence, which is implemented by the developer, or container-managed persistence, implemented by the container.

Message-driven beans — Message-driven beans listen asynchronously for Java Message Service (JMS) messages from any client or component and are used for loosely coupled, typically batch-type, processing.

Java Class Loading

2011-05-30T22:41:00.002+05:30

Internals of Java Class Loading

Class loading is one of the most powerful mechanisms provided by the Java language specification. Even though the internals of class loading falls under the "advanced topics" heading, all Java programmers should know how the mechanism works and what can be done with it to suit their needs. This can save time that would otherwise have been spent debugging ClassNotFoundException, ClassCastException, etc.

Class and Data

A class represents the code to be executed, whereas data represents the state associated with that code. State can change; code generally does not. When we associate a particular state to a class, we have an instance of that class. So different instances of the same class can have different state, but all refer to the same code. In Java, a class will usually have its code contained in a .class file, though there are exceptions. Nevertheless, in the Java runtime, each and every class will have its code also available in the form of a first-class Java object, which is an instance of java.lang.Class. Whenever we compile any Java file, the compiler will embed a public, static, final field named class, of the type java.lang.Class, in the emitted byte code. Since this field is public, we can access it using dotted notation, like this:

java.lang.Class klass = Myclass.class;

Once a class is loaded into a JVM, the same class (I repeat, the same class) will not be loaded again. This leads to the question of what is meant by "the same class." Similar to the condition that an object has a specific state, an identity, and that an object is always associated with its code (class), a class loaded into a JVM also has a specific identity, which we'll look at now.
In Java, a class is identified by its fully qualified class name. The fully qualified class name consists of the package name and the class name. But a class is uniquely identified in a JVM using its fully qualified class name along with the instance of the ClassLoader that loaded the class. Thus, if a class named Cl in the package Pg is loaded by an instance kl1 of the class loader KlassLoader, the class instance of C1, i.e. C1.class is keyed in the JVM as (Cl, Pg, kl1). This means that the two class loader instances (Cl, Pg, kl1) and (Cl, Pg, kl2) are not one and the same, and classes loaded by them are also completely different and not type-compatible to each other.

Java Class Loader

A Delegation Model (version 1.2 onwards) is used for loading class to the JVM. Class Loaders are structured in java is in a way that at start-up time the JVM doesn’t need to know anything about the classes that will be loaded at run time. Class loaders mainly perform two functions. First, when the VM needs to load the byte code for a class, it asks a class loader to find the corresponding byte code. Each class loader will use their own method to find the requested byte code (class),then it loads it from the local disk or fetch them across the Net using any protocol including other classes and interfaces are loaded as they referenced in the byte code being executed, the main class . Then it creates an instance of the java.lang.Class of loaded byte code. This makes the class become available to the JVM for execution. Second, class loaders define the name spaces seen by different classes and how those name spaces relate to each other.

Delegation Model

In delegation model, the class loaders has hierarchical order forming a tree structure,the bootstrap class loader as the root of this tree.

Bootstrap Class Loader.

Java core API classes, which are essential at the JVM load are loaded by the bootstrap (often known as primordial) Class Loader. This class loader loads the class files from local file system using the file accessing options of current OS to open/read. It’s read the class files in the form of byte arrays, providing essential resources on the JVM start up. Sometimes this Class Loader is referred as the “internal” class loader or the “default” class loader also.

Extension class loader

The extension class loader is primary responsibility to load classes from the extension directories and provides ability to simply drop in new JVM extensions, without requiring modification to the user’s classpath.

System Class Loader

The Application-specific classes are loaded by the system (often known application) Class Loader.

If all the class loader failed to load the required class, it will generate a java.lang.ClassNotFoundException else a java.lang.NoClassDefFoundError . There is a parent -child relationship is maintained by these class loaders, except boot strap class loader these class loaders has a parent.

The delegation model follows these steps when the client request for a particular class.

1. JVM first check whether the requested class has already been loaded (JVM caches all the classes that are loaded) by the any Class Loader. If yes, the class is returned.

2. If the class is not loaded, the request is forwarded to the parent Class Loader. This delegation will go up to the bootstrap Class Loader.

3. If the delegation failed to load the class , then current Class Loader will search for the requested class. In its defined locations .

4. If the class loading failed, it will generate a java.lang.ClassNotFoundException .

The Java class loader architecture provide a large amount of flexibility for developers in the application is assembling and extension process.

Phases of class loading

There are three phases of concrete class loading: physical loading, linking, and initializing.

1. In in first phase of physical loading required class file will be searched in specified classpaths. If the file is found it is read and the byte code is loaded. This process gives a basic memory structure to the class object, such concepts like methods, fields, and other referenced classes are not known at this stage.

1. Linking can be broken down into three main stages, because it is complex phase:

Bytecode verification through class loader, which executes a number of checks on the bytecodes.
Class preparation. This stage prepares the necessary data structures that represent fields, methods and implemented interfaces that are defined within the class.
Resolving of all the other classes referenced by a particular class. The classes can be referenced in a number of ways:

Superclasses
Interfaces
Field types
Types in method signatures
Types of local variables used in methods

During the initializing phase any static initializers contained within a class are executed so that, static fields are initialized to their default values.

It is interesting, that class loading can be performed in a lazy manner and therefore some parts of the class loading process may be done on first use of the class rather than at load time.

Exceptions

The biggest challenge in dealing with class-loading problems is that problems rarely manifest themselves during the class-loading process but rather during the usage of a class later on. In following shown two class loading related exceptions, with potential causes

· ClassNotFoundException

An archive, directory, or other source for the classes was not added to the class loader asked to load the class, or to its parent.
A class loader’s parent is not set correctly.
The wrong class loader is used to load the class in question.

· NoClassDefFoundError

An archive, directory, or other source for the classes was not added to the class loader asked to load the class, or to its parent.
A class loader’s parent is not set correctly.
Symbolic links in a class are inaccessible by the containing class’s class loader, such as a child class loader.

JDK-JRE-JVM

2011-05-30T22:12:00.000+05:30

JDK (Java Development Kit)

Java Development Kit is a bundle of software that you can use to develop Java based applications. Java Development Kit is needed for developing java applications. JDK needs more Disk space as it Contains JRE along with various development tools. JDK can be downloaded/supported freely from java.sun.com It includes JRE, set of API classes, Java compiler (javac.exe), Java application launcher (java.exe), Webstart And additional files needed to write Java applets and applications.
Compiler converts java code into byte code. Java application launcher opens a JRE, loads the class, and invokes its main method.
JDK is mainly targeted for java development. I.e. you can create a Java file (with the help of Java packages), compile a Java file and run a java file.

JRE (Java Runtime Environment)

Java Runtime Environment contains JVM, class libraries, and other supporting files. It does not contain any development tools such as compiler, debugger, etc. Actually JVM runs the program, and it uses the class libraries, and other supporting files provided in JRE. If you want to run any java program, you need to have JRE installed in the system.

The Java Virtual Machine provides a platform-independent way of executing code; programmers can concentrate on writing software, without having to be concerned with how or where it will run.

JVM (Java Virtual Machine)

As we all aware when we compile a Java file, output is not an 'exe' but it's a '.class' file. '.class' file consists of Java byte codes which are understandable by JVM. Java Virtual Machine interprets the byte code into the machine code depending upon the underlying operating system and hardware combination. It is responsible for all the things like garbage collection, array bounds checking, etc… JVM is platform dependent.
The JVM is called "virtual" because it provides a machine interface that does not depend on the underlying operating system and machine hardware architecture. This independence from hardware and operating system is a cornerstone of the write-once run-anywhere value of Java programs.

There are different JVM implementations are there. These may differ in things like performance, reliability, speed, etc. These implementations will differ in those areas where Java specification doesn’t mention how to implement the features, like how the garbage collection process works is JVM dependent, Java spec doesn’t define any specific way to do this.

Java RMI

2011-05-08T16:12:00.007+05:30

Java Remote Method Invocation

This is a technical literature study which purpose is to describe the basic parts of Java Remote Method Invocation.

Remote Method Invocation, abbreviated as RMI, provides support for

distributed objects in Java, i.e. it allows objects to invoke methods on remote objects. The

calling objects can use the exact same syntax as for local invocations.

The Java RMI model has two general requirements. The first requirement is that the RMI

model shall be simple and easy to use and the second requirement it that the model shall fit into the Java language in a natural way.

Distributed Object Application

An RMI application is often composed of two separate programs, a server and a client. The server creates remote objects and makes references to those objects

accessible. Then it waits for clients to invoke methods on the objects. The client gets remote references to remote objects in the server and invokes methods on those remote objects. The RMI model provides an distributed object application to the programmer. It

is a mechanism that the server and the client use to communicate and pass information

between each other. A distributed object application has to handle the following properties:

· Locate remote objects: The system has to obtain references to remote objects. This

can be done in two ways. Either by using RMI’s naming facility, the rmiregistry, or by

passing and returning remote objects.

· Communicate with remote objects: The programmer doesn’t have to handle

communication between the remote objects since this is handled by the RMI system.

The remote communication looks like an ordinary method invocation for the

programmer.

· Load class byte codes for objects that are passed as parameters or return values:

All mechanisms for loading an object’s code and transmitting data is provided by the

RMI system.

Figure A-1, below, illustrates an RMI distributed application. In this example the RMI

registry is used to obtain references to a remote object. First the server associates a name with a remote object in the RMI registry (see note 1 in figure A-1). When a client wants access to a remote object it looks up the object, by its name, in the registry (see note 2 in figure A-1). Then the client can invoke methods on the remote object (see note 3 in figure A-1) at the server.

Figure A-1. An Illustration of a distributed object application.

Interfaces and Classes

Since Java RMI is a single-language system, the programming of distributed application in RMI is rather simple [CDK01, p194]. All interfaces and classes for the RMI system are defined in the java.rmi package [SUN02 ,p6]. Figure A-2, below, illustrates the relationship between some of the classes and interfaces. The RemoteObject class implements the Remote interface while the other classes extend RemoteObject.

Figure A-2. Interfaces and Classes in the java.rmi package.

The Remote Interface

A remote interface is defined by extending the Remote interface that is provided in the

java.rmi package. The remote interface is the interface that declares methods that clients can invoke from a remote virtual machine [SUN02 ,p6]. The remote interface must satisfy the following conditions:

· It must extend the interface Remote.

· Each remote method declaration in the remote interface must include the exception

RemoteException (or one of it’s superclasses) in it’s thrown clause.

The RemoteObject Class

RMI server functions are provided by the class RemoteObject and its subclasses

RemoteServer, UnicastRemoteObject and Activatable. Here is a short description of what the diffrent classes handle:

· RemoteObject provides implementations of the methods hashCode, equals and

toString in the class java.lang.Object.

· The classes UnicastRemoteObject and Activatable create remote objects and export

them, i.e. the classes make the remote objects available to remote clients.

The RemoteException Class

The class RemoteException is a superclass of the exceptions that the RMI system throws

during a remote method invocation. Each remote method that is declared in a

remote interface must specify RemoteException (or one of it’s superclasses) in it’s throws

clause to ensure the robustness of applications in the RMI system.

When a remote method invocation fails, the exception RemoteException is thrown.

Communication failure, protocol errors and failure during marshalling or unmarshalling of parameters or return values are some reasons for RMI failure.

RemoteException is an exception that must be handled by the caller of the remote method, i.e. it is a checked exception. The compiler ensures that the programmer have handled these exceptions.

Three-layer architecture

RMI consists of three layers:

stubs & skeletons: this layer intercepts method calls made by the client to the

interface reference and redirects them to a remote RMI service

remote reference layer: this layer understands how to interpret and manage

references made from clients to the remote service objects.

In JDK 1.1, this layer connects clients to remote service objects that are running and

exported on a server. The connection is a one-to-one (unicast) link.

In the Java 2 SDK, this layer was enhanced to support the activation of dormant

remote service objects via Remote Object Activation. When a method call is made

to the proxy for an activatable object, RMI determines if the remote service

implementation object is dormant. If it is dormant, RMI will instantiate the object

and restore its state from a disk file. Once an activatable object is in memory, it

behaves just like JDK 1.1 remote service implementation objects.

transport layer: based on TCP/IP. Provides connectivity via sockets. An internal

protocol, the Java Remote Method Protocol (JRMP) is used for communication.

The General RMI Architecture

The server must first bind its name to the registry
The client lookup the server name in the registry to establish remote references.
The Stub serializing the parameters to skeleton, the skeleton invoking the remote method and serializing the result back to the stub.

The Stub and Skeleton

A client invokes a remote method, the call is first forwarded to stub.
The stub is responsible for sending the remote call over to the server-side skeleton
The stub opening a socket to the remote server, marshaling the object parameters and forwarding the data stream to the skeleton.
A skeleton contains a method that receives the remote calls, unmarshals the parameters, and invokes the actual remote object implementation.

Steps for Developing an RMI System

1. Define the remote interface

2. Develop the remote object by implementing the remote interface.

3. Develop the client program.

4. Compile the Java source files.

5. Generate the client stubs and server skeletons.

6. Start the RMI registry.

7. Start the remote server objects.

8. Run the client

Step 1: Defining the Remote

• To create an RMI application, the first step is the defining of a remote interface between the client and server objects.

/* SampleServer.java */

import java.rmi.*;

public interface SampleServer extends Remote

{

public int sum(int a,int b) throws RemoteException;

}

Step 2: Develop the remote object

The server is a simple unicast remote server.

Create server by extending java.rmi.server.UnicastRemoteObject.

The server uses the RMISecurityManager to protect its resources while engaging in remote communication.

/* SampleServerImpl.java */

import java.rmi.*;

import java.rmi.server.*;

import java.rmi.registry.*;

public class SampleServerImpl extends UnicastRemoteObject

implements SampleServer

{

SampleServerImpl() throws RemoteException

{

super();

}

Implement the remote methods

/* SampleServerImpl.java */

public int sum(int a,int b) throws RemoteException

{

return a + b;

}

The server must bind its name to the registry, the client will look up the server name.

Use java.rmi.Naming class to bind the server name to registry. In this example the name call “SAMPLE-SERVER”.

In the main method of your server object, the RMI security manager is created and installed.

/* SampleServerImpl.java */

public static void main(String args[])

{

try

{

System.setSecurityManager(new RMISecurityManager());

//set the security manager

//create a local instance of the object

SampleServerImpl Server = new SampleServerImpl();

//put the local instance in the registry

Naming.rebind("SAMPLE-SERVER" , Server);

System.out.println("Server waiting.....");

}

catch (java.net.MalformedURLException me) {

System.out.println("Malformed URL: " + me.toString()); }

catch (RemoteException re) {

System.out.println("Remote exception: " + re.toString()); }

}

Step 3: Develop the client program

In order for the client object to invoke methods on the server, it must first look up the name of server in the registry. You use the java.rmi.Naming class to lookup the server name.

The server name is specified as URL in the from ( rmi://host:port/name )

Default RMI port is 1099.

The name specified in the URL must exactly match the name that the server has bound to the registry. In this example, the name is “SAMPLE-SERVER”

The remote method invocation is programmed using the remote interface name (remoteObject) as prefix and the remote method name (sum) as suffix.

import java.rmi.*;

import java.rmi.server.*;

public class SampleClient

{

public static void main(String[] args)

{

// set the security manager for the client

System.setSecurityManager(new RMISecurityManager());

//get the remote object from the registry

try

{

System.out.println("Security Manager loaded");

String url = "//localhost/SAMPLE-SERVER";

SampleServer remoteObject = (SampleServer)Naming.lookup(url);

System.out.println("Got remote object");

System.out.println(" 1 + 2 = " + remoteObject.sum(1,2) );

}

catch (RemoteException exc) {

System.out.println("Error in lookup: " + exc.toString()); }

catch (java.net.MalformedURLException exc) {

System.out.println("Malformed URL: " + exc.toString()); }

catch (java.rmi.NotBoundException exc) {

System.out.println("NotBound: " + exc.toString());

}

Step 4 & 5: Compile the Java source files & Generate the client stubs and server skeletons

Assume the program compile and executing at elpis on ~/rmi

Once the interface is completed, you need to generate stubs and skeleton code. The RMI system provides an RMI compiler (rmic) that takes your generated interface class and procedures stub code on its self.

elpis:~/rmi> set CLASSPATH=”~/rmi”

elpis:~/rmi> javac SampleServer.java

elpis:~/rmi> javac SampleServerImpl.java

elpis:~/rmi> rmic SampleServerImpl

elpis:~/rmi> javac SampleClient.java

Step 6: Start the RMI registry

The RMI applications need install to Registry. And the Registry must start manual by call rmiregisty.

The rmiregistry us uses port 1099 by default. You can also bind rmiregistry to a different port by indicating the new port number as : rmiregistry

elpis:~/rmi> rmiregistry

Remark: On Windows, you have to type in from the command line:

> start rmiregistry

Steps 7 & 8: Start the remote server objects & Run the client

Once the Registry is started, the server can be started and will be able to store itself in the Registry.

Because of the grained security model in Java 2.0, you must setup a security policy for RMI by set java.security.policy to the file policy.all

elpis:~/rmi> java –Djava.security.policy=policy.all SampleServerImpl

elpis:~/rmi> java –Djava.security.policy=policy.all SampleClient

Java Policy File

In Java 2, the java application must first obtain information regarding its privileges. It can obtain the security policy through a policy file. In above example, we allow Java code to have all permissions, the contains of the policy file policy.all is:

grant {

permission java.security.AllPermission;

};

Now, we given an example for assigning resource permissions:

grant {

permission java.io.filePermission “/tmp/*”, “read”, “write”;

permission java.net.SocketPermission “somehost.somedomain.com:999”,”connect”;

permission java.net.SocketPermission “*:1024-65535”,”connect,request”;

permission java.net.SocketPermission “*:80”,”connect”;

};

Sample program

• Client invokes a remote method with strings as parameter

• Server returns a string containing the reversed input string and a message

Define the remote interface (HelloInterface.java)

import java.rmi.*;

public interface HelloInterface extends Remote {

public String say(String msg) throws RemoteException;

}

We define an interface for a remote class that includes one remote method:

say accepts a String as an input parameter and returns a String as a result

Note that the interface extends Remote and that each method (there’s only one here)

throws RemoteException. These classes are defined in the java.rmi package, so we import it.

Define the remote class (Hello.java)

import java.rmi.*;

import java.rmi.server.*;

public class Hello

extends UnicastRemoteObject

implements HelloInterface {

private String message;

public Hello(String msg) throws RemoteException {

message = msg;

}

public String say(String m) throws RemoteException {

// return the input message - reversed input plus our standard message

return new StringBuffer(m).reverse().toString() + "\n" + message;

}

The remote class defines two methods:

Hello is our constructor and will be used by the server to set define the standard

message that will always be sent back to the client.

say is a method that takes a string as the input. It returns a string containing the

input with the characters reversed followed by a newline followed by our standard

message (set in the constructor).

Note that:

- the class extends UnicastRemoteObject

this will allow the methods to be invoked remotely

- the class implements the interface we defined

- each method must throw RemoteException because remote procedure calls might fail

- the say method accepts a String and returns a String. String is defined to be

Serializable. If you were to accept or return an object you defined, it would have to

be defined to implement Serializable.

The server (HelloServer.java)

import java.rmi.*;

import java.rmi.server.*;

public class HelloServer {

public static void main(String argv[]) {

if (System.getSecurityManager() == null)

System.setSecurityManager(new RMISecurityManager());

try {

// instantiate the service with the standard message & tell registry

Naming.rebind("Hello", new Hello("Hello, world!"));

System.out.println("Server is running...");

} catch(Exception e) {

System.out.println("Hello Server failed: " + e);

}

The server is a plain program that is responsible for:

1. Creating and installing a security manager. We do this with:

System.setSecurityManager(new RMISecurityManager());

The security manager makes sure that classes that get loaded do not perform

operations that they are not allowed to perform.

2. Registering at least one remote object with the object registry.

We do this with:

Naming.rebind(object_name, object);

where object_name is a String that names the remote object

and object is the remote object that we are registering.

All that our server does is:

set the security maanger

create the remote object

print a message saying “Server is running…”

The client (HelloClient.java)

import java.rmi.*;

public class HelloClient {

public static void main(String argv[]) {

try {

if (args.length < 0) {

System.err.println(“usage: java HelloClient string …\n”);

System.exit(1);

}

HelloInterface hello = (HelloInterface)Naming.lookup("//localhost/Hello");

for (int i=0; i < args.length; ++I)

System.out.println(hello.say(args[i]));

} catch (Exception e) {

System.out.println(”Helloclient exception: " + e);

}

The client invokes the remote method.

To do this, the client must have a handle (reference) to the remote object.

The object registry allows the client to get this reference to a remote object.

To get the reference to the remote object, we need to know:

1. Internet name (or address) of machine that is running the object registry for

which the remote object is registered (can omit if localhost)

2. Port on which the object registry is running (can omit if it is 1099 - default)

3. Name of the object within the object registry.

The Naming.lookup method obtains an object handle from the object registry

running on localhost on the default port (we could have just looked up “Hello” in

this case).

The result of Naming.lookup must be cast to the type of the Remote Interface

------

The remote invocation of the object is the call to hello.say(“abc”). It returns a

String which we print. Remember again, that we can get a String only because

String is a Serializable class.

The policy (policy)

grant {

permission java.security.AllPermission;

}

The policy file controls which clients have which permissions. The one in this

example grants everyone global permission (not a good one to use in a production

environment!).

The policy file is not needed when programming with JDK < 1.2

The Java security manager contains a number of check methods (e.g

checkConnect). In the default manager, these are implemented by calling a

checkPermission method. The type of permission is specified by a parameter of

type Permission that is passed to checkPermission. The method checks whether

the permission is implied by a list of granted permissions.

To specify or change the security policy, there is a class named Policy. A program

can get its policy by calling Policy.getPolicy() or set it (if it has permissions) with

Policy.setPolicy(). The security policy is typically specified by a policy

configuration file which is reaad when the program starts.

Compile

• Compile the interface and classes:

javac HelloInterface.java Hello.java

javac HelloServer.java HelloClient.java

• Create the class files for stubs:

rmic Hello

• rmic creates:

Hello_Skel.class skeleton - server-side stub

Hello_Stub.class client-site stub

We first compile the remote interface and classes using javac. Then we generate the

class files for the client and server stubs with the rmi compiler:

rmic Hello

This produces two class files:

Hello_Skel.class is the skeleton (a name for a server-stub)

Hello_Stub.class is the client stub function

Run

• Start the object registry (in the background):

rmiregistry &

• Start the server (in the background):

java -Djava.security.policy=policy

HelloServer &

• Run the client:

java HelloClient testing abcdefgh

• See the output:

gnitset

Hello, world!

hgfedcba

Hello, world!

Now we’re ready to run the program.

If the registry is not running, it must be started. Otherwise the server will not be able

to register the object and the client will not be able to look it up.

We start it in the background with:

rmiregistry &

If we wanted it to listen on a different port than 1099, we would specify the port

number on the command line. For example, to listen on port 5511:

rmiregistry 5511 &

Next we start the server (also in the background) by running:

java -Djava.security.policy=policy HelloServer &

where the -D flag sets the name of the file containing our security policy (our file is

named policy and is in the current directory).

Finally, we can run the client with:

java HelloClient testing abcdefg

NOTE: be sure to kill the registry and server processes when you’re done.

log4j PatternLayout

2011-04-17T16:46:00.001+05:30

log4j PatternLayout

If you want to generate your logging information in a particular format based on a patten then you can use org.apache.log4j.PatternLayout to format your logging information.

The PatternLayout class extends the abstract org.apache.log4j.Layout class and overrides the format() method to structure logging information according to a supplied pattern.

PatternLayout is also a simple Layout object that provides following Bean Property which can be set using configuration file:

Pattern Conversion Characters:

Below table explains characters used in the above pattern and all other characters which you can use in your custom pattern:

Format Modifiers:

By default the relevant information is output as is. However, with the aid of format modifiers it is possible to change the minimum field width, the maximum field width and justification.

Following table covers various modifiers scenarios:

PatternLayout Example:

Following is a simple configuration file for PatternLayout:

# Define the root logger with appender file
log = /usr/home/log4j
log4j.rootLogger = DEBUG, FILE
# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log}/log.out
# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern=%d{yyyy-MM-dd}-%t-%x-%-5p-%-10c:%m%n

Now consider the following Java Example which would generate logging information:

import org.apache.log4j.Logger;
import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class log4jExample{

/* Get actual class name to be printed on */
static Logger log = Logger.getLogger(
log4jExample.class.getName());
public static void main(String[] args)
throws IOException,SQLException{
log.debug("Hello this is an debug message");
log.info("Hello this is an info message");
}
}

Compile and run the above program, it would create a log.out file in /usr/home/log4j directory which would have following log information:

2010-03-23-main--DEBUG-log4jExample:Hello this is an debug message
2010-03-23-main--INFO -log4jExample:Hello this is an info message

log4j HTMLLayout

2011-04-17T16:26:00.000+05:30

log4j HTMLLayout

If you want to generate your logging information in a HTML-formatted file then you can use org.apache.log4j.HTMLLayout to format your logging information.

The HTMLLayout class extends the abstract org.apache.log4j.Layout class and overrides the format() method from its base class to provide HTML-style formatting.

This provided the following information to be displayed:

• The time elapsed from the start of the application before a particular logging event was generated.
• The name of the thread that invoked the logging request.
• The level associated with this logging request.
• The name of the logger and logging message.
• The optional location information for the program file and the line number from which this logging was invoked.

HTMLLayout is a very simple Layout object that provides following methods:

1 setContentType(String)
Sets the content type of the text/html HTML content. Default is text/html.

2 setLocationInfo(String)
Sets the location information for the logging event. Default is false.

3 setTitle(String)
Sets the title for the HTML file. Default is Log4j Log Messages.

HTMLLayout Example:

Following is a simple configuration file for HTMLLayout:

# Define the root logger with appender file
log = /usr/home/log4j
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log}/htmlLayout.html

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.HTMLLayout
log4j.appender.FILE.layout.Title=HTML Layout Example
log4j.appender.FILE.layout.LocationInfo=true

Now consider the following Java Example which would generate logging information:

import org.apache.log4j.Logger;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class log4jExample{
/* Get actual class name to be printed on */
static Logger log = Logger.getLogger(
log4jExample.class.getName());
public static void main(String[] args)
throws IOException,SQLException{
log.debug("Hello this is an debug message");
log.info("Hello this is an info message");
}
}

Compile and run the above program, it would create a htmlLayout.html file in /usr/home/log4j directory which would have following log information:

------------------------------------------------------------------------------------------------------------
Log session start time Mon Mar 22 13:30:24 AST 2010

Time  Thread    Level         Category            File:Line                          Message

0        main       DEBUG     log4jExample     log4jExample.java:15        Hello this is an debug message

6       main       INFO        log4jExample     log4jExample.java:16        Hello this is an info message

You would use a web browser to open htmlLayout.html file. It is also important to note that the footer for the and tags is completely missing.

One of the big advantages of having the log file in HTML format is that it can be published as a web page for remote viewing.

Multiple Appenders Using XML File

2011-04-17T16:10:00.000+05:30

Log4j XML Configuration

In this example we will see how to create more than one appender using xml configuration file. This example is similar to the one we saw before using the properties file (example). So I will simply compare both.

The following code shows the log4j.properties file we used in the previous example.

log4j.rootLogger=DEBUG, CA, FA

#Console Appender
log4j.appender.CA=org.apache.log4j.ConsoleAppender
log4j.appender.CA.layout=org.apache.log4j.PatternLayout
log4j.appender.CA.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
#File Appender
log4j.appender.FA=org.apache.log4j.FileAppender
log4j.appender.FA.File=sample.log
log4j.appender.FA.layout=org.apache.log4j.PatternLayout
log4j.appender.FA.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
# Set the logger level of File Appender to WARN
log4j.appender.FA.Threshold = WARN

The following code shows the corresponding log4j.xml file.

Multiple Appenders Using Properties File

2011-04-17T16:06:00.000+05:30

Log4j Multiple Appender Example

In this example you will see how to create a console and file appender and add it to the rootLogger.

The log4j.properties file is shown below.

log4j.rootLogger=DEBUG, CA, FA
#Console Appender
log4j.appender.CA=org.apache.log4j.ConsoleAppender
log4j.appender.CA.layout=org.apache.log4j.PatternLayout
log4j.appender.CA.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
#File Appender
log4j.appender.FA=org.apache.log4j.FileAppender
log4j.appender.FA.File=sample.log
log4j.appender.FA.layout=org.apache.log4j.PatternLayout
log4j.appender.FA.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
# Set the logger level of File Appender to WARN
log4j.appender.FA.Threshold = WARN
Here we create two appenders ConsoleAppender and FileAppender. You need to set the File attribute of the FileAppender to the log file name, here it is sample.log. Add the FileAppender (FA) and the ConsoleAppender (CA) to the rootLogger.

You can also set the logger level for each appender seperately. Here the FileAppender logger level is set to WARN. Only WARN, ERROR and FATAL level log messages will be logged in the sample.log file. Since we don't set any log level explicitly for the ConsoleAppender it will inherit the rootLogger level, that is DEBUG.

Here is our example code.

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
public class HelloWorld {
static final Logger logger = Logger.getLogger(HelloWorld.class);
public static void main(String[] args) {
PropertyConfigurator.configure("log4j.properties");
logger.debug("Sample debug message");
logger.info("Sample info message");
logger.warn("Sample warn message");
logger.error("Sample error message");
logger.fatal("Sample fatal message");
}
}
The output on the cosole.

[main] DEBUG com.vaannila.helloworld.HelloWorld - Sample debug message

[main] INFO com.vaannila.helloworld.HelloWorld - Sample info message
[main] WARN com.vaannila.helloworld.HelloWorld - Sample warn message
[main] ERROR com.vaannila.helloworld.HelloWorld - Sample error message
[main] FATAL com.vaannila.helloworld.HelloWorld - Sample fatal message
The contents of the sample.log file.

[main] WARN com.vaannila.helloworld.HelloWorld - Sample warn message
[main] ERROR com.vaannila.helloworld.HelloWorld - Sample error message
[main] FATAL com.vaannila.helloworld.HelloWorld - Sample fatal message

EJB 3 Persistence

2011-04-13T20:23:00.028+05:30

EJB 3 Persistence

Java Persistence API is the standard API used for the management of the persistent data and object/relational mapping. Java Persistence API is added in Java EE 5 platform. Every application server compatible with Java EE 5 supports the Java Persistent APIs.

Java Persistence API ensures the management of persistence and object/relational mapping. These are helpful while using the JPA in the development of applications using the platform for Java EE 5. It provides O-R mapping facility to manage relational data in java application.

Features of JPA:

Java Persistence API is a lightweight framework based on POJO for object-relational mapping. Java language metadata annotations and/or XML deployment descriptor is used for the mapping between Java objects and a relational database. It allows the SQL-like query language that works for both static as well as dynamic queries. It also allows the use of the pluggable persistence API. Java Persistence APIs are mainly depends on metadata annotations. API includes:

• Java Persistence API

• Metadata annotations

• Java Persistence query language

Advantages of JPA:

Java Persistence API is build upon the best ideas from the persistence technologies like TopLink, JDO and Hibernate. Java Persistence API is compatible with Java SE environment as well as Java EE and allows developers to take advantages of the standard persistence API.

Persistency of data is not so easy for most of the enterprise applications because for this they require access to the relational database like Oracle 10g. It is your responsibility to update and retrieve the database by writing the code using SQL and JDBC. While several object-relational (O-R) frameworks such as JBoss Hibernate and OracleTopLink make persistence challenges simpler and became popular. They let the java developer free from writing JDBC code and to concentrate only on the business logic. In EJB 2.x, container manage persistence (CMP) try to solve the persistence challenges but not successful completely.

Persistence tier of the application can be developed in several ways but Java platform does not follow any standard that can be used by both Java EE and Java SE environment. But the Java Persistence API (JPA) part of EJB 3.0 spec (JSR-220) makes the persistence API standard for the Java platform. O/R mapping vendors like Hibernate and TopLink as well as JDO vendors and other leading application server vendors are receiving the JSR-220.

Here we are describing EJB3 JPA by using the simple domain object model by an example.

Working process of an EJB application using JPA:

The Basics of EJB3 JPA and O-R Mapping Framework:

It defines a declarative way known as O-R mapping metadata to perform O-R mapping. Most of the framework use XML to store the O-R mapping metadata.

An API is required to manipulate like to perform CRUD (CRUD stands for create, read, update, and delete) operations. The API allows you to persist, remove, update or retrieve the object from the database. O-R framework performs operations using the API and the O-R mapping metadata on your behalf.

Use of a query language for retrieving objects from the database is the proper way since improper SQL statements may result in slow down the performance of the operation performing on the database. A query language allows retrieving the entities from the database and spares you from writing the SQL SELECT statements.

Metadata Annotation in Action: Metadata annotations are first time introduced in Java SE 5.0. To make the development easy all the components of Java EE including EJB3 uses the metadata annotations. In EJB3 JPA annotation defines the objects, O-R mappings, and the relationships among them. JPA also have another option to use XML descriptor, But use of the metadata annotations make the development simpler and more efficient.

Entities:

An entity can be considered as a light weight persistence domain object. An entity defines a table in a relational database and each instance of an entity corresponds to a row in that table. An entity refers to a logical collection of data that can be stored or retrieved as a whole. For example, in a banking application, Customer and BankAccount can be treated as entities. Customer name, customer address etc can be logically grouped together for representing a Customer entity. Similarly account number, total balance etc may be logically grouped under BankAccount entity.

Persistence fields or persistent properties define the persistent state of an entity. To map the entities and their relationship to the data in the relational database these entities use the object-relational mapping.

Requirements of Entity Classes: There are some requirements that an entity must follow:

• The class must contain either a public or a protect no argument constructor, while it can contain other constructors.

• The class as well as methods and persistence instance variables must not be declared as final.

• Use the annotation javax.persistence.Entity to annotate the class.

• Declare the persistence instance variables as protected, private or package-private so that they can directly accessed only by the entity class's methods.

• Entity class may extend the entity as well as non-entity classes or vice-versa.

• The class must implement the serializable interface if an entity instance is passed by value.

Persistence Fields and Properties in Entity Classes: There are two ways to access the persistent state of an entity either by instance variables or by using the JavaBeans-style properties. The fields or the properties must follow the Java language types:

• Java primitive types
• java.lang.String
• Other serialization types including:
• wrappers of java primitive types
• java.util.Date
• java.util.Calender
• java.math.BigDecimal
• java.math.BigInteger
• java.sql.Time
• java.sql.Date
• java.sql.TimeStamp
• User-defined serializable types
• char[]
• Character[]
• byte[]
• Byte[]
• Enumerated types
• Other entities and/or collection of entities
• Embedded classes

Entity uses the persistent fields while mapping annotations. Annotations are applied to the entity's instance variable. On the other hand entity uses the persistence properties while mapping annotations. Annotations are applied to the entity's getter methods for JavaBeans-style properties. We cannot apply mapping annotations to both fields as well as properties simultaneously in a single entity.

Persistence Fields: Persistence accesses the entity class instance variables directly at runtime, if the entity class uses persistence fields. It is necessary to apply the object/relational mapping annotation on the instance variables.

Persistent Properties: Entity must follow the method conventions of JavaBeans components while using the persistent properties. JavaBeans-style properties use getter and setter methods that are used after the entity class's instance variable names. There is a getter and a setter method for each persistence property. In case of a boolean property you may use isProperty instead of getProperty. Let’s take an example to clarify this:

Suppose an entity of type customer uses persistent property that has a private instance variable named firstName, the class defines two methods named getFirstName and setFirstName to retrieve and set the values of the instance variable. Use the following method signature for a single-valued persistent property.

• Type getProperty()
• void setProperty(Type type)

Multi-valued (Collection-valued) persistent fields and properties must use the supported Java collection interfaces without worrying whether the entity uses the persistence fields or properties. The collection interfaces may be used at the following places:

• java.util.Collection
• java.util.Set
• java.util.Map
• java.util.List

If the entity class uses persistent fields then the method signatures of the collection types must be one of these collection types. Suppose an entity of type customer includes a persistent property that uses a set of phone numbers then it should have the following methods:

Set getPhoneNumber() {}
void setPhoneNumbers(Set) {}

The O-R mapping annotations must be applied to the getter methods. Note here that mapping annotations cannot be applied to the fields or properties marked transient or annotated transient.

Primary Keys in Entities:

Each entity contains a unique identity contained in the object. E.g. A customer entity has an identity that might be identified by the customer number. A primary key allows a client to be a particular entity instance. Every unique entity must be associated with a primary key. To prove its uniqueness every entity may have either a simple or a composite primary key.

To denote the primary key property or field Simple primary key use javax.persistence.Id annotations.

Composite primary keys must be composed of either a single persistent property or field or a set of single persistent properties or fields. Composite primary keys uses javax.persistence.IdClass and javax.persistence.EmbededId.

The primary key, or the fields of the composite primary key (like property or field) must follow one of the following Java language types.

• Java primitive types
• Java primitive wrapper types
• java.lang.String
• java.util.Date (the temporal type should be DATE)
• java.sql.Date

Floating point types are not allowed to use in primary keys.

Multiplicity in Entity Relationships:

There are four types of multiplicities defined for entity relationships like one-to-one, one-to-many, many-to-one, and many-to-many.

One-to-one: When each entity instance is mapped to a single instance of another entity, then the mapping is known as one- to-one

mapping. One-to-one relationships use the javax.persistence.OneToOne annotation on the corresponding persistent field or property.

For Example: A reference variable in java contains the address of a single object so that there exists only one-to-one mapping between the object of the reference variable.

One-to-many: When an entity instance is related to many instances of other entities, then the relation is known as one-to-many. These types of relationships use the javax.persistence.OneToManyannotation on the corresponding field or property.

For Example: A sales order may contain the order of multiple items so there is a one-to-many relationship between the sales order and the items.

Many-to-many: When the multiple instances of an entity have the mapping to the multiple instances of the other entity then the mapping is said to many-to-many mapping. Many-to-many mapping relationships use the javax.persistence.ManyToMany annotation corresponding to the field or property.

For Example: A college student has the admission in several courses while each course may have many students. Therefore there is many-to-many relationship between the students and the courses.

Direction in Entity Relationships: A relationship can be either unidirectional or bi-directional.

Unidirectional Relationship: A unidirectional relationship is a relationship in which only one of the two entities have the owing side. In unidirectional relationship only one entity can have the relationship property or field that may refer to the other.

Example: In the example given above, the List_Item contains the relationship field that refers to the other entity named as Product, while the Product doesn't have any knowledge about the List_Item that refers to it.

Bi-directional Relationships: A bi-directional relationship is the relationship in which both the entities have the owing side. In bi-directional relationship each entity in the relation have the relationship fields or property.

Example: Suppose the Order in the above example have the knowledge about the List_Item instance it has and also suppose that the List_Item have the knowledge about what the Order it belongs to, then the relationship between them is said to be the bi-directional relation.

Rules: There are some rules that each bi-directional relationship must follow:

• You must use its owing side simply using the mappedBy element of the @OneToOne, @OneToMany, or @ManyToMany annotation of the inverse side of a bi-directional relationship.mappedBy element is used to designate the field or property in an entity.

• In a one-to-one bi-directional relationship, owing side is the side that contains the corresponding foreign key.

• In a many-to-one bi-directional relationships the many side is always the owing side of the relationship and must not define the mappedBy element.

• In case of many-to-many bi-directional relationships either side may be the owing side.

Let’s have an Example now

Create the Entity Class

In the Simple EJB Project, within the com.webage.ejbs package, create a new class called Customer.
In the Customer class, add the following import statement.

import javax.persistence.*;

Many of the annotations and classes for the persistence API will come from this package.

First, we must designate this class as an Entity. This is done using the @Entity annotation. Add this annotation at the class level as shown below.

@Entity

public class Customer {

Next, we will make the Customer class implement java.io.Serializable. Doing so will allow us to use this class are parameters to a remote business interface method. Add the code shown in bold face.

public class Customer implements Serializable {

Add the following two member variables. They will form the attributes (or database columns) for the entity.

private int id;
private String name;

Generate getter and setter methods for these fields (right click on the editor and select Source->Generate Getters and Setters).

The id field will act as the primary key column of the Customer. Declare that fact using the @Id annotation as shown below.

@Id
private int id;

Save changes. That's it, the Entity class is now complete.

Create the persistence.xml File

The persistence.xml file must be created within the META-INF directory of the EJB module. This file defines persistence units. Each unit is basically a reference to the data source that will be used to access the database. The unit can also contain configuration such as the type of database (Oracle, MySQL etc.) and if database tables should be automatically created by the persistence engine.

Within Simple EJB Project, create a folder called META-INF. Within this folder, create a new file called persistence.xml. In that file, add the following content.

jdbc/__default

Note the following aspects of this file:

1. The name of the unit is my_persistence_ctx. We will use this name to look it up from the code.

2. The unit will use a data source with JNDI name jdbc/__default. This data source is automatically defined when Glassfish is installed. In real life, you will probably use a database such as MySQL, Oracle or DB2. In that case, you must first define a data source using the Glassfish administration console.

3. We configure the persistence engine to automatically drop and create tables when the EJB JAR is deployed. This is a good choice during heavy development when the Entity classes are changing rapidly. If you do not wish the system to create tables, you can set the value of the toplink.ddl-generation property to none.

4. We set the SQL dialect to be specific to Derby. Examples of other platform classes are "oracle.toplink.essentials.platform.database.DB2Platform" for DB2 and "oracle.toplink.essentials.platform.database.oracle.OraclePlatform" for Oracle.

Save and close the persistence.xml file.

Use the Entity from a Session EJB

We will use the Customer Entity from the SimpleBean session bean created in the first tutorial. First, we will insert a few customers to the database.

Open the business interface SimpleBean.java. Add a new method as follows:

public void createCustomers();

Save and close the file.

Now, open the implementation class SimpleBeanImpl.java. Add a new member variable to obtain reference to the persistence unit as follows:

@PersistenceContext(name="my_persistence_ctx")

EntityManager em;

Note, how we use the name of the persistence unit here.

Add this method:

public void createCustomers() {

Customer c1 = new Customer();
c1.setId(1);
c1.setName("XYZ");
em.persist(c1);
}

The call to the EntityManager.persist() method will result in a SQL INSERT statement.

Save and close the file.

Deploy the EJB JAR

Deploy the EJB JAR file by exporting Simple EJB Project into the autodeploy folder as already mentioned in the previous tutorial.

Write the Client

In the Simple Client Project, open TestClient.java. Below this line:

SimpleBean bean = (SimpleBean) ctx.lookup("ejb/SimpleBeanJNDI");

Add:

bean.createCustomers();
Save the file.

Run the Client

Run the TestClient class as already described in the previous tutorial.

Note, you can run the client only once. Running it again will cause primary key collision and the customer cannot be added.

Inspect the Database

select * from customer;

Add More Database Access Feature

Now, we will add the ability to retrieve a Customer, update and delete it. This can be done entirely using the session EJB. We don't have to change the Entity class.

First, add the following methods to the business interface SimpleBean.java.

public Customer getCustomer(int id);
public void updateCustomer(Customer c);
public void deleteCustomer(Customer c);

Save and close the file.

Implement these new methods in SimpleBeanImpl.java as follows.

public Customer getCustomer(int id) {
Customer c = em.find(Customer.class, new Integer(id));
return c;
}

public void updateCustomer(Customer c) {
em.merge(c);
}

public void deleteCustomer(Customer c) {
c = em.merge(c); //Must do this
em.remove(c);
}

The EntityManager.merge() call will flag the Customer instance so that the data is used to update the underlying row. The updateCustomer() method relies on this behavior. The actual SQL UPDATE statement is issued at a later time, before the transaction is completed. The EntityManager.remove() call, results in a SQL DELETE statement to be executed. Note: To remove an entity, we must use a managed instance. The Customer object instance passed to the deleteCustomer() method is called detached as it is not currently managed by the EntityManager in any way. Merging will make the instance managed. A managed instance is always associated with the underlying row in the table. That means, the merge call will implicitly do a SELECT SQL call (if the instance is currently detached).

Save and close the file. Re-deploy the EJB JAR file.

Update the Client

Open TestClient.java.

Below the line:

bean.createCustomers();

Add:

Customer c = bean.getCustomer(1);
System.out.println("Retrieved customer: " + c.getName());
bean.deleteCustomer(c);

Save changes.

Make sure that you have re-deployed the EJB JAR file. Now, run the client. The Console view should show the message:

Retrieved customer: XYZ

Also, now you can run the client repeatedly as we delete the customer data.

Advanced Encryption Standard (AES)

2011-04-09T15:28:00.000+05:30

Advanced Encryption Standard

In cryptography, the Advanced Encryption Standard (AES) is a symmetric-key encryption standard adopted by the U.S. government. The standard comprises three block ciphers, AES-128, AES-192 and AES-256, adopted from a larger collection originally published as Rijndael. Each of these ciphers has a 128-bit block size, with key sizes of 128, 192 and 256 bits, respectively. The AES ciphers have been analyzed extensively and are now used worldwide, as was the case with its predecessor, the Data Encryption Standard (DES).

AES was announced by National Institute of Standards and Technology (NIST) as U.S. FIPS PUB 197 (FIPS 197) on November 26, 2001 after a 5-year standardization process in which fifteen competing designs were presented and evaluated before Rijndael was selected as the most suitable (see Advanced Encryption Standard process for more details). It became effective as a Federal government standard on May 26, 2002 after approval by the Secretary of Commerce. It is available in many different encryption packages. AES is the first publicly accessible and open cipher approved by the NSA for top secretinformation.

The Rijndael cipher was developed by two Belgian cryptographers, Joan Daemen and Vincent Rijmen, and submitted by them to the AES selection process. Rijndael is a wordplay based upon the names of the two inventors.

AES is based on a design principle known as a Substitution permutation network. It is fast in both software and hardware. Unlike its predecessor, DES, AES does not use a Feistel network.

AES has a fixed block size of 128 bits and a key size of 128, 192, or 256 bits, whereas Rijndael can be specified with block and key sizes in any multiple of 32 bits, with a minimum of 128 bits. The blocksize has a maximum of 256 bits, but the keysize has no theoretical maximum.

AES operates on a 4×4 matrix of bytes, termed the state (versions of Rijndael with a larger block size have additional columns in the state). Most AES calculations are done in a special finite field.

The AES cipher is specified as a number of repetitions of transformation rounds that convert the input plaintext into the final output of ciphertext. Each round consists of several processing steps, including one that depends on the encryption key. A set of reverse rounds are applied to transform ciphertext back into the original plaintext using the same encryption key.

Simple Data Encryption/Decryption Example with AES

For encryption we must use a secret key along with an algorithm. In the following example we use an algorithm called AES 128 and the bytes of the word "ThisIsASecretKey" as the secret key (the best secret key we found in this world).

AES algorithm can use a key of 128 bits (16 bytes * 8); so we selected that key.

package org.roy.crypto;

import java.security.*;
import java.security.spec.InvalidKeySpecException;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import sun.misc.*;

public class SimpleProtector {

private static final String ALGORITHM = "AES";

private static final byte[] keyValue =
new byte[] { 'T', 'h', 'i', 's', 'I', 's', 'A', 'S', 'e', 'c', 'r', 'e', 't', 'K', 'e', 'y' };

public static String encrypt(String valueToEnc) throws Exception {

Key key = generateKey();
Cipher c = Cipher.getInstance(ALGORITHM);
c.init(Cipher.ENCRYPT_MODE, key);
byte[] encValue = c.doFinal(valueToEnc.getBytes());
String encryptedValue = new BASE64Encoder().encode(encValue);
return encryptedValue;
}

public static String decrypt(String encryptedValue) throws Exception {

Key key = generateKey();
Cipher c = Cipher.getInstance(ALGORITHM);
c.init(Cipher.DECRYPT_MODE, key);
byte[] decordedValue = new BASE64Decoder().decodeBuffer(encryptedValue);
byte[] decValue = c.doFinal(decordedValue);
String decryptedValue = new String(decValue);
return decryptedValue;
}

private static Key generateKey() throws Exception {
Key key = new SecretKeySpec(keyValue, ALGORITHM);
// SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
// key = keyFactory.generateSecret(new DESKeySpec(keyValue));
return key;
}
}

We use "generateKey()" method to generate a secret key for AES algorithm with a given key. You can change the used algorithm by changing this Key generation; the commented out code shows the use of DES algorithm (Data Encryption Standard). Following is a simple class to test the above implementation.

package org.roy.crypto;

public class TestSimpleProtector {

public static void main(String[] args) throws Exception {
String password = "mypassword";
String passwordEnc = SimpleProtector.encrypt(password);
String passwordDec = SimpleProtector.decrypt(passwordEnc);

System.out.println("Plain Text : " + password);
System.out.println("Encrypted : " + passwordEnc);
System.out.println("Decrypted : " + passwordDec);
}
}

Following is the output we got from above test; so you clearly see that the original text is reproduced after the decryption operation.

Plain Text : mypassword
Encrypted : sBhCap4urE50a/dGuhNgrw==
Decrypted : mypassword

Another Simple Example:

import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.io.*;

public class AES {

public static String asHex (byte buf[]) {
StringBuffer strbuf = new StringBuffer(buf.length * 2);
int i;
for (i = 0; i < buf.length; i++) {
if (((int) buf[i] & 0xff) < 0x10)
strbuf.append("0");
strbuf.append(Long.toString((int) buf[i] & 0xff, 16));
}

return strbuf.toString();
}

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

String message="AES still rocks!!";
// Get the KeyGenerator
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128); // 192 and 256 bits may not be available

// Generate the secret key specs.
SecretKey skey = kgen.generateKey();
byte[] raw = skey.getEncoded();

SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");

// Instantiate the cipher
Cipher cipher = Cipher.getInstance("AES");

cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
byte[] encrypted = cipher.doFinal((args.length == 0 ? message : args[0]).getBytes());
System.out.println("encrypted string: " + asHex(encrypted));

cipher.init(Cipher.DECRYPT_MODE, skeySpec);
byte[] original = cipher.doFinal(encrypted);
String originalString = new String(original);
System.out.println("Original string: " + originalString + " " + asHex(original));
}
}

OUTPUT:

encrypted string: 91369a3b74c6feede0eff48fcf004f67d26cdd0b4907b44fd2147a4077ded0d1
Original string: AES still rocks!! 414553207374696c6c20726f636b732121

Data Encryption Standard (DES)

2011-04-09T15:17:00.003+05:30

Data Encryption Standard

The Data Encryption Standard (DES) is a block cipher that uses shared secret encryption. It was selected by the National Bureau of Standards as an official Federal Information Processing Standard (FIPS) for the United States in 1976 and which has subsequently enjoyed widespread use internationally. It is based on a symmetric-key algorithm that uses a 56-bit key. The algorithm was initially controversial because of classified design elements, a relatively short key length, and suspicions about a National Security Agency (NSA) backdoor. DES consequently came under intense academic scrutiny which motivated the modern understanding of block ciphers and their cryptanalysis.

DES is now considered to be insecure for many applications. This is chiefly due to the 56-bit key size being too small; in January, 1999, distributed.net and the Electronic Frontier Foundation collaborated to publicly break a DES key in 22 hours and 15 minutes. There are also some analytical results which demonstrate theoretical weaknesses in the cipher, although they are infeasible to mount in practice. The algorithm is believed to be practically secure in the form of Triple DES, although there are theoretical attacks. In recent years, the cipher has been superseded by the Advanced Encryption Standard (AES). Furthermore, DES has been withdrawn as a standard by the National Institute of Standards and Technology (formerly the National Bureau of Standards).

In this article, I show you how do use Java Cryptography Extension (JCE) to encrypt or decrypt a text in Data Encryption Standard (DES) mechanism.

1. DES Key

Create a DES Key.

KeyGenerator keygenerator = KeyGenerator.getInstance("DES");
SecretKey myDesKey = keygenerator.generateKey();

2. Cipher Info

Create a Cipher instance from Cipher class, specify the following information and separated by a slashes (/).

• Algorithm name
• Mode (optional)
• Padding scheme (optional)

Cipher desCipher; // Create the cipher
desCipher = Cipher.getInstance("DES/ECB/PKCS5Padding");

Note

DES = Data Encryption Standard.
ECB = Electronic Codebook mode.
PKCS5Padding = PKCS #5-style padding.

In this case, you created a DES (Data Encryption Standard) cipher in Electronic Codebook mode, with PKCS #5-style padding.

3. Convert It

Convert String into Byte[] array format.

byte[] text = "No body can see me".getBytes();

4. Encrypt It

Make Cipher in encrypt mode, and encrypt it with Cipher.doFinal() method.

desCipher.init(Cipher.ENCRYPT_MODE, myDesKey);
byte[] textEncrypted = desCipher.doFinal(text);

5. Decrypt It

Make Cipher in decrypt mode, and decrypt it with Cipher.doFinal() method as well.

desCipher.init(Cipher.DECRYPT_MODE, myDesKey);
byte[] textDecrypted = desCipher.doFinal(textEncrypted);

6. Full Example

Full Example to show how do use Java’s JCE to encrypt and decrypt text in DES mechanism.

package com.roy.util;

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;

public class JEncrytion
{
public static void main(String[] argv) {

try{
KeyGenerator keygenerator = KeyGenerator.getInstance("DES");
SecretKey myDesKey = keygenerator.generateKey();

Cipher desCipher;
// Create the cipher
desCipher = Cipher.getInstance("DES/ECB/PKCS5Padding");

// Initialize the cipher for encryption
desCipher.init(Cipher.ENCRYPT_MODE, myDesKey);

//sensitive information
byte[] text = "No body can see me".getBytes();

System.out.println("Text [Byte Format] : " + text);
System.out.println("Text : " + new String(text));

// Encrypt the text
byte[] textEncrypted = desCipher.doFinal(text);

System.out.println("Text Encryted : " + textEncrypted);

// Encode bytes to base64 to get a string
// new sun.misc.BASE64Encoder().encode(textEncrypted);

// Initialize the same cipher for decryption
desCipher.init(Cipher.DECRYPT_MODE, myDesKey);

// Decrypt the text
byte[] textDecrypted = desCipher.doFinal(textEncrypted);

System.out.println("Text Decryted : " + new String(textDecrypted));

// Decode using utf-8
// new String(textDecrypted);

}catch(NoSuchAlgorithmException e){
e.printStackTrace();
}catch(NoSuchPaddingException e){
e.printStackTrace();
}catch(InvalidKeyException e){
e.printStackTrace();
}catch(IllegalBlockSizeException e){
e.printStackTrace();
}catch(BadPaddingException e){
e.printStackTrace();
}

}
}

Output
Text [Byte Format] : [B@19b5393
Text : No body can see me
Text Encryted : [B@4e79f1
Text Decryted : No body can see me

Encrypting a File or Stream with DES

This example implements a class for encrypting and decrypting files or streams using DES. The class is created with a key and can be used repeatedly to encrypt and decrypt streams using that key.

public class DesEncrypter {
Cipher ecipher;
Cipher dcipher;

DesEncrypter(SecretKey key) {
// Create an 8-byte initialization vector
byte[] iv = new byte[]{
(byte)0x8E, 0x12, 0x39, (byte)0x9C,
0x07, 0x72, 0x6F, 0x5A
};

AlgorithmParameterSpec paramSpec = new IvParameterSpec(iv);

try {
ecipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
dcipher = Cipher.getInstance("DES/CBC/PKCS5Padding");

// CBC requires an initialization vector
ecipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);
dcipher.init(Cipher.DECRYPT_MODE, key, paramSpec);

} catch (java.security.InvalidAlgorithmParameterException e) {
} catch (javax.crypto.NoSuchPaddingException e) {
} catch (java.security.NoSuchAlgorithmException e) {
} catch (java.security.InvalidKeyException e) {

}
}

// Buffer used to transport the bytes from one stream to another
byte[] buf = new byte[1024];

public void encrypt(InputStream in, OutputStream out) {
try {

// Bytes written to out will be encrypted
out = new CipherOutputStream(out, ecipher);

// Read in the cleartext bytes and write to out to encrypt
int numRead = 0;
while ((numRead = in.read(buf)) >= 0) {
out.write(buf, 0, numRead);
}

out.close();
} catch (java.io.IOException e) {

}
}

public void decrypt(InputStream in, OutputStream out) {

try {
// Bytes read from in will be decrypted
in = new CipherInputStream(in, dcipher);
// Read in the decrypted bytes and write the cleartext to out
int numRead = 0;
while ((numRead = in.read(buf)) >= 0) {
out.write(buf, 0, numRead);
}

out.close();
} catch (java.io.IOException e) {
}
}
}

Here's an example that uses the class:

try {
// Generate a temporary key. In practice, you would save this key.
// See also Encrypting with DES Using a Pass Phrase.
SecretKey key = KeyGenerator.getInstance("DES").generateKey();

// Create encrypter/decrypter class
DesEncrypter encrypter = new DesEncrypter(key);

// Encrypt
encrypter.encrypt(new FileInputStream("cleartext1"),
new FileOutputStream("ciphertext"));

// Decrypt
encrypter.decrypt(new FileInputStream("ciphertext"),
new FileOutputStream("cleartext2"));
} catch (Exception e) {
}

Encrypting an Object with DES

This example demonstrates how to encrypt a serializable object.

try {
// Generate a temporary key. In practice, you would save this key.
// See also Encrypting with DES Using a Pass Phrase.
SecretKey key = KeyGenerator.getInstance("DES").generateKey();

// Prepare the encrypter
Cipher ecipher = Cipher.getInstance("DES");
ecipher.init(Cipher.ENCRYPT_MODE, key);

// Seal (encrypt) the object
SealedObject so = new SealedObject(new MySecretClass(), ecipher);

// Get the algorithm used to seal the object
String algoName = so.getAlgorithm(); // DES

// Prepare the decrypter
Cipher dcipher = Cipher.getInstance("DES");
dcipher.init(Cipher.DECRYPT_MODE, key);

// Unseal (decrypt) the class
MySecretClass o = (MySecretClass)so.getObject(dcipher);
} catch (java.io.IOException e) {
} catch (ClassNotFoundException e) {
} catch (javax.crypto.IllegalBlockSizeException e) {
} catch (javax.crypto.BadPaddingException e) {
} catch (javax.crypto.NoSuchPaddingException e) {
} catch (java.security.NoSuchAlgorithmException e) {
} catch (java.security.InvalidKeyException e) {
}

public class MySecretClass implements java.io.Serializable {
String s = "the secret";
}

Encryption and Decryption

2011-04-09T15:01:00.001+05:30

What is encryption?

Encryption is the conversion of data into a form, called a ciphertext. There are two basic techniques for encrypting information: symmetric encryption (also called secret key encryption) and asymmetric encryption(also called public key encryption).

How encryption works

Encryption program uses an encryption algorithm (complex mathematical processes) to encrypt and decrypt the data. Encryption algorithm creates specific strings of data used for encryption - keys that consist of long strings of bits or binary numbers. The more bits in the key, the more the number of possible combinations of binary numbers that makes the code more difficult to break. Then encryption algorithm scrambles data by combining the bits in the key with the data bits. In symmetric encryption, the same key is used to scramble (encrypt) and unscramble (decrypt) data. In asymmetric key encryption, two different keys are required - one for encryption and one for decryption.

Why you need encryption

Nowadays when more and more sensitive information is stored on computers and transmitted over the Internet, we need to ensure information security and safety.

One of the most common uses of encryption is encrypting emails. Sending sensitive messages, documents and files over the Internet is like sending a postcard as all emails are transmitted in an unsecured form. It doesn't depend on if you send emails via public and private networks. Your message is totally open to interception by anyone along the way - so anybody - your ISP, your boss, etc. can read your emails. Even if you connect to your server and send your emails via SSL, it only means that your emails can't be seen while transmitting between you and your server. When your email reaches your server, it can be seen by your email service provider. Then your server usually sends your email to the recipient in an unsecured way and your email can also be easily seen by anyone.

Private network, where email goes directly to a mail server and resides there until it is retrieved, also doesn't provide necessary security level, as you email can be seen e.g. by network administrator, your boss, etc.

Of course, you may believe that your personal email does not contain any private information, but everyone has got something to keep in secret from his family, neighbors or colleagues. It could be financial, sexual, social, political, or professional secrets. There is really only one sure way to protect your email privacy - using encryption.

Symmetric Encryption

Symmetric Encryption (also known as symmetric-key encryption, single-key encryption, one-key encryption and private key encryption) is a type of encryption where the same secret key is used to encrypt and decrypt information or there is a simple transform between the two keys.

A secret key can be a number, a word, or just a string of random letters. Secret key is applied to the information to change the content in a particular way. This might be as simple as shifting each letter by a number of places in the alphabet. Symmetric algorithms require that both the sender and the receiver know the secret key, so they can encrypt and decrypt all information.

There are two types of symmetric algorithms: Stream algorithms (Stream ciphers) and Block algorithms (Block ciphers).

Types of Symmetric algorithms (Symmetric-key algorithms)

Symmetric algorithms (Symmetric-key algorithms) use the same key for encryption and decryption. Symmetric-key algorithms can be divided into Stream algorithms (Stream ciphers) and Block algorithms (Block ciphers).

Stream Ciphers

Stream ciphers encrypt the bits of information one at a time - operate on 1 bit (or sometimes 1 byte) of data at a time (encrypt data bit-by-bit). Stream ciphers are faster and smaller to implement than block ciphers, however, they have an important security gap. If the same key stream is used, certain types of attacks may cause the information to be revealed.

Block Ciphers

Block cipher (method for encrypting data in blocks) is a symmetric cipher which encrypts information by breaking it down into blocks and encrypting data in each block. A block cipher encrypts data in fixed sized blocks (commonly of 64 bits). The most used block ciphers are Triple DES and AES.

Some examples of symmetric encryption algorithms:

AES/Rijndael

Blowfish

CAST5

DES

IDEA

RC2

RC4

RC6

Serpent

Triple DES

Twofish

AES / Rijndael encryption

AES stands for Advanced Encryption Standard. AES is a symmetric key encryption technique which replaces the commonly used Data Encryption Standard (DES).

It was the result of a worldwide call for submissions of encryption algorithms issued by the US Government'sNational Institute of Standards and Technology (NIST) in 1997 and completed in 2000.

The winning algorithm, Rijndael, was developed by two Belgian cryptologists, Vincent Rijmen and Joan Daemen. AES provides strong encryption and was selected by NIST as a Federal Information Processing Standard in November 2001 (FIPS-197).

The AES algorithm usesthree key sizes: a 128-, 192-, or 256-bit encryption key. Each encryption key size causes the algorithm to behave slightly differently, so the increasing key sizes not only offer a larger number of bits with which you can scramble the data, but also increase the complexity of the cipher algorithm.

Blowfish

Blowfish is a symmetric encryption algorithm (64-bit cipher) designed in 1993 by Bruce Schneier as an alternative to existing encryption algorithms. Blowfish has a variable key length - from 32 bits to 448 bits. Since then Blowfish has been analyzed considerably, and is gaining acceptance as a strong encryption algorithm.

CAST

CAST stands for Carlisle Adams and Stafford Tavares, the inventors of CAST. CAST is a popular 64-bit block cipher allowing key sizes up to 128 bits.

Data Encryption Standard (DES)

Data Encryption Standard (DES) is a block cipher with 64-bit block size that uses 56-bit keys. DES was invented over 20 years ago by IBM in response to a public request from the National Bureau of Standards. Due to recent advances in computer technology, some experts no longer consider DES secure against all attacks; since then Triple-DES (3DES) has emerged as a stronger method. Using standard DES encryption, Triple-DES encrypts data three times and uses a different key for at least one of the three passes giving it a cumulative key size of 112-168 bits.

IDEA

IDEA stands for International Data Encryption Algorithm. IDEA is a symmetric encryption algorithm that was developed by Dr. X. Lai and Prof. J. Massey to replace the DES standard. Unlike DES though it uses a 128 bit key. This key length makes it impossible to break by simply trying every key.

RC2

RC2 is a variable-key-length cipher. It was invented by Ron Rivest for RSA Data Security, Inc. Its details have not been published.

RC4

RC4 was developed by Ron Rivest in 1987. It is a variable-key-size stream cipher. It is a cipher with a key size of up to 2048 bits (256 bytes).

RC6

RC6 is a symmetric key block cipher derived from RC5. It was designed by Ron Rivest, Matt Robshaw, Ray Sidney, and Yiqun Lisa Yin to meet the requirements of the Advanced Encryption Standard (AES) competition. RC6 encryption algorithm was selected among the other finalists to become the new federal Advanced Encryption Standard (AES).

Serpent

Serpent is a block cipher developed by Ross Anderson, Eli Biham and Lars Knudsen. Serpent can work with different combinations of key lengths. Serpent was also selected among other five finalists to become the new federal Advanced Encryption Standard (AES).

Triple DES

Triple DES is a variation of Data Encryption Standard (DES). It uses a 64-bit key consisting of 56 effective key bits and 8 parity bits. The size of the block for Triple-DES is 8 bytes. Triple-DES encrypts the data in 8-byte chunks. The idea behind Triple DES is to improve the security of DES by applying DES encryption three times using three different keys.

Twofish

Twofish is a symmetric block cipher. Twofish has a block size of 128 bits and accepts keys of any length up to 256 bits.

Twofish encryption algorithm was designed by Bruce Schneier, John Kelsey, Chris Hall, Niels Ferguson, David Wagner and Doug Whiting. The National Institute of Standards and Technology (NIST) investigated Twofish as one of the candidates for the replacement of the DES encryption algorithm.

What are encryption vulnerabilities?

Breaking symmetric encryption

There are two methods of breaking symmetric encryption - brute force and cryptanalysis.

Brute Force Attack is a form of attack in which each possibility is tried until success is obtained. Typically, a ciphertext is deciphered under different keys until plaintext is recognized. No encryption software that is entirely safe from the brute force method, but if the number of possible keys is high enough, it can make a program astronomically difficult to crack using brute force. But the more bits in a key, the more secure it is, so choose software with as many bits as possible.

Cryptanalysis is a form of attack that attacks the characteristics of the algorithm to deduce a specific plaintext or the key used.

Weak passwords

In every kind of encryption software, there is some kind of password that must be created so that the recipients of the information can read it. Creating a strong password that cannot be easily guessed is just as important as choosing a good algorithm or strong encryption software.

Remembering passwords

If you forget your password, you will not be able to decrypt data that you have encrypted. Be sure to make a backup copy of your password and store it in a safe place.

Secret keys exchanging and storing

Symmetric key algorithms require sharing the secret key - both the sender and the receiver need the same key to encrypt or decrypt data. Anyone who knows the secret key can decrypt the message. So it is essential that the sender and receiver have a way to exchange secret keys in a secure manner. The weakness of symmetric algorithms is that if the secret key is discovered, all messages can be decrypted. So, secret key need to be changed on a regular basis and kept secure during distribution and while using.

Asymmetric Encryption (Public Key Encryption)

Asymmetric encryption uses different keys for encryption and decryption. The decryption key is very hard to derive from the encryption key. The encryption key is public so that anyone can encrypt a message. However, the decryption key is private, so that only the receiver is able to decrypt the message. It is common to set up "key-pairs" within a network so that each user has a public and private key. The public key is made available to everyone so that they can send messages, but the private key is only made available to the person it belongs to.

How Asymmetric Encryption (Public Key Encryption) works:

The sender and the recipient must have the same software. The recipient makes a pair of keys - public key and private key (both keys can be unlocked with a single password). Public key can be used by anyone with the same software to encrypt a message. Public keys can be freely distributed without worrying since it is only used to scramble (encrypt) the data.The sender does not need the recipient's password to use his or her public key to encrypt data. The recipient's other key is a private key that only he or she can use when decrypting the message. Private key should never be distributed since the private key assures that only the intended recipient can unscramble (decrypt) data intended for him or her.

To understand asymmetric encryption better please read an example:

For example, Jonny makes public key A and private key A, and jinni makes public key B and private key B. Jonny and Jinni exchange their public keys. Once they have exchanged keys, Jonny can send an encrypted message to Jinni by using Jinni's public key B to scramble the message. Jinni uses her private key B to unscramble it. If Jinni wants to send an encrypted message to Jonny, she uses Jonny's public key A to scramble her message, which Jonny can then unscramble with his private key A. Asymmetric cryptography is typically slower to execute electronically than symmetric cryptography.

Some Asymmetric Algorithms (public key algorithms) such as RSA allow the process to work in the opposite direction as well: a message can be encrypted with a private key and decrypted with the corresponding public key. If the recipient wants to decrypt a message with Bob's public key he/she must know that the message has come from Bob because no one else has sender's private key. Digital signatures work this way.

Some examples of popular asymmetric encryption algorithms:

RSA

DSA

PGP

RSA encryption

RSA is the best known public key algorithm, named after its inventors: Rivest, Shamir and Adleman. RSA uses public and private keys that are functions of a pair of large prime numbers. Its security is based on the difficulty of factoring large integers. The RSA algorithm can be used for both public key encryption and digital signatures. The keys used for encryption and decryption in RSA algorithm, are generated using random data. The key used for encryption is a public key and the key used for decryption is a private key. Public keys are stored anywhere publicly accessible. The sender of message encrypts the data using public key, and the receiver decrypts it using his/her own private key. That way, no one else can intercept the data except receiver.

DSA

The Digital Signature Algorithm (DSA) is a United States Federal Government standard or FIPS for digital signatures. It was proposed by the National Institute of Standards and Technology (NIST) in August 1991 for use in their Digital Signature Standard (DSS).

PGP

PGP (Pretty Good Privacy) is a public-private key cryptography system which allows for users to more easily integrate the use of encryption in their daily tasks, such as electronic mail protection and authentication, and protecting files stored on a computer. PGP was originally designed by Phil Zimmerman. It uses IDEA, CAST orTriple DES for actual data encryption and RSA (with up to 2048-bit key) or DH/DSS (with 1024-bit signature key and 4096-bit encryption key) for key management and digital signatures. The RSA or DH public key is used to encrypt the IDEA secret key as part of the message.

Combination of Symmetric Encryption and Asymmetric Encryption

If we want the benefits of both types of encryption algorithms, the general idea is to create a random symmetric key to encrypt the data, and then encrypt that key asymmetrically. Once the key is asymmetrically encrypted, we add it to the encrypted message. The receiver gets the key, decrypts it with their private key, and uses it to decrypt the message.

Here I will only discuss two symmetric encryption algorithms Data Encryption Standard (DES) and Advanced Encryption Standard (AES)

J2SE 5.0 (Tiger) Features

2011-03-31T23:06:00.000+05:30

These are the main features of J2SE 5.0 (Tiger)

Generics

When you take an element out of a Collection, you must cast it to the type of element that is stored in the collection. Besides being inconvenient, this is unsafe. The compiler does not check that your cast is the same as the collection's type, so the cast can fail at run time.

Generic provides a way for you to communicate the type of a collection to the compiler, so that it can be checked. Once the compiler knows the element type of the collection, the compiler can check that you have used the collection consistently and can insert the correct casts on values being taken out of the collection.

How to Use Generics

1. Find a data structure that accepts Object(s)

• ArrayList, LinkedList, HashMap, HashSet
• Not arrays: they already take explicit types!

2. Declare the data structure with the type(s) in angle brackets immediately after class name

• ArrayList myStrings = new ArrayList();
• HashMap myHashtable = new HashMap();

3. Insert objects of the appropriate type

• myStrings.add("Some String");
• myHashtable.put("Some Key", "Some Value");

4. No typecast required on removal

• String myValue = myStrings.get(0);
• String myOtherValue = myHashtable.get("Some Key");

ArrayList Example: Explicit Typecasts

ArrayList list = new ArrayList();
list.add(0, new Integer(42));
int total = ((Integer)list.get(0)).intValue();

The cast to Integer on the last line is an example of the typecasting issues that generic types aim to prevent. The issue is that the 1.4.2 Collection API uses the Object class to store the Collection objects, which means that it cannot pick up type mismatches at compile time. The first notification of a problem is a ClassCastException at runtime.

The same example with the generified Collections library is written as follows:

ArrayList list = new ArrayList();
list.add(0, new Integer(42));
int total = list.get(0).intValue();

Automatic Boxing and Unboxing of Primitive Types

As any Java programmer knows, you can’t put an int (or other primitive value) into a collection. Collections can only hold object references, so you have to box primitive values into the appropriate wrapper class (which is Integer in the case of int). When you take the object out of the collection, you get the Integer that you put in; if you need an int, you must unbox the Integer using the intValue method. All of this boxing and unboxing is a pain, and clutters up your code. The autoboxing and unboxing feature automates the process, eliminating the pain and the clutter.

Before

ArrayList list = new ArrayList();
list.add(0, new Integer(42));
int total = (list.get(0)).intValue();

After

ArrayList list = new ArrayList();
list.add(0, 42);
int total = list.get(0);

The For-Each Loop

The Iterator class is used heavily by the Collections API. It provides the mechanism to navigate sequentially through a Collection. The new enhanced for loop can replace the iterator when simply traversing through a Collection as follows. The compiler generates the looping code necessary and with generic types no additional casting is required.

The for (:) loop is designed for iteration over array and collections.

Iterating over Arrays:

for (;;) Loop
int[] ageInfo = {12, 30, 45, 55};
int sumAge = 0;
for (int i = 0; i < ageInfo.length; i++)
sumAge += ageInfo[i];

for (:) Loop

int[] ageInfo = {12, 30, 45, 55};
int sumAge = 0;
for (int element : ageInfo)
sumAge += element;

Note that an array element of a primitive value cannot be modified in the for(:) loop.

Iterating over non-generic Collections:

for(;;) Loop

Collection nameList = new ArrayList();
nameList.add("Tom");
nameList.add("Dick");
nameList.add("Harry");
for (Iterator it = nameList.iterator();
it.hasNext(); ) {
Object element = it.next();
if (element instanceof String) {
String name = (String) element;
//...
}
}

for(:) Loop

Collection nameList = new ArrayList();
nameList.add("Tom");
nameList.add("Dick");
nameList.add("Harry");
for (Object element : nameList) {
if (element instanceof String) {
String name = (String) element;
//...
}
}

Static Import

An import statement allows you to give a hint to the compiler as to which class you are
referring to in your code. It gives you the convenience of using the short name for a class
(like JButton) instead of the long, fully qualified name (like javax.swing.JButton).
Remember that import does not tell the compiler where the class resides (classpath does
that). It only tells the compiler which class you mean to use.

Syntax:

// Static-import-on-demand: imports all static members
import static FullyQualifiedTypeName.*;
// Single-static-import: imports a specific static member
import static FullyQualifiedTypeName.StaticMemberName;

Avoiding the Constant Interface Antipattern

Constant Interface

package mypackage;

public interface MachineStates {
// Fields are public,
// static and final.
int BUSY = 1;
int IDLE = 0;
int BLOCKED = -1;
}

Without Static Import

class MyFactory implements
mypackage.MachineStates {
public static void main(String[] args) {
int[] states = {IDLE, BUSY, IDLE, BLOCKED };
for (int s : states)
System.out.println(s);
}
}

With Static Import

import static mypackage.MachineStates.*; // Imports all static members.

class MyFactory2 {
public static void main(String[] args) {
int[] states = { IDLE, BUSY, IDLE, BLOCKED };
for (int s : states)
System.out.println(s);
}
}

Static-import-on-demand: Import of All Static Members

Without Static Import

class Calculate1 {
public static void main(String[] args) {
double x = 10.0, y = 20.5;
double squareroot = Math.sqrt(x);
double hypotenue = Math.hypot(x, y);
double area = Math.PI * y * y;
}
}

With Static Import

import static java.lang.Math.*;

// All static members from Math are imported.
class Calculate2 {
public static void main(String[] args) {
double x = 10.0, y = 20.5;
double squareroot = sqrt(x);
double hypotenue = hypot(x, y);
double area = PI * y * y;
}
}

Single-static-import: Import of Individual Static Members

import static java.lang.Math.sqrt; // Static method
import static java.lang.Math.PI; // Static field
// Only specified static members are imported.
class Calculate3 {
public static void main(String[] args) {
double x = 10.0, y = 20.5;
double squareroot = sqrt(x);
double hypotenue = Math.hypot(x, y); // Requires type name.
double area = PI * y * y;
}
}

Enums

Enumerated Types

• An enumerated type defines a finite set of symbolic names and their values.
• Standard approach is the int enum pattern (or the analogous String enum pattern):

public class MachineState {
public static final int BUSY = 1;
public static final int IDLE = 0;
public static final int BLOCKED = -1;
//...
}

public class Machine {
int state;
public void setState(int state) {
this.state = state;
}
//...
}

public class IntEnumPatternClient {
public static void main(String[] args) {
Machine machine = new Machine();
machine.setState(MachineState.BUSY); // (1) Constant qualified by class name
machine.setState(1); // Same as (1)
machine.setState(5); // Any int will do.
System.out.println(MachineState.BUSY); // Prints "1", not "BUSY".
}
}

Some Disadvantages of the int Enum Pattern

• Not typesafe.
– Any int value can be passed to the setState() method.

• No namespace.
– A constant must be qualified by the class (or interface) name, unless the class is extended (or the interface is implemented).

• Uninformative textual representation.
– Only the value can be printed, not the name.

• Constants compiled into clients.
– Clients need recompiling if the constant values change.

Typesafe Enum Construct

• The enum construct provides support for enum types:

enum MachineState { BUSY, IDLE, BLOCKED } // Canonical form
enum Day {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

• Keyword enum is used to declare an enum type.

• Overcomes all the disadvantages of the int enum pattern, and is more powerful

Properties of the Enum Type

• An enum declaration is a special kind of class declaration:
– It can be declared at the top-level and as static enum declaration.

// (1) Top level enum declaration
public enum SimpleMeal
{ BREAKFAST, LUNCH, DINNER }

public class EnumTypeDeclarations {
// (2) Static enum declaration is OK.
public enum SimpleMeal
{ BREAKFAST, LUNCH, DINNER };
public void foo() {
// (3) Local (inner) enum declaration is NOT OK!
enum SimpleMeal
{ BREAKFAST, LUNCH, DINNER }
}
}

Enum Constructors

• Each constant declaration can be followed by an argument list that is passed to the
constructor of the enum type having the matching parameter signature.

– An implicit standard constructor is created if no constructors are provided for the enum type.

– As an enum cannot be instantiated using the new operator, the constructors cannot be called explicitly.

public enum Meal {
BREAKFAST(7,30), LUNCH(12,15), DINNER(19,45);
Meal(int hh, int mm) {
assert (hh >= 0 && hh <= 23): "Illegal hour.";
assert (mm >= 0 && hh <= 59): "Illegal mins.";
this.hh = hh;
this.mm = mm;
}

// Time for the meal.
private int hh;
private int mm;
public int getHour() { return this.hh; }
public int getMins() { return this.mm; }
}

Methods Provided for the Enum Types

• Names of members declared in an enum type cannot conflict with automatically generated member names:

– The enum constant names cannot be redeclared.

– The following methods cannot be redeclared:

static []values()

Returns an array containing the constants of this enum class, in the order they are declared.

static valueOf(String name)

Return the enum constant with the specified name

• Enum types are based on the java.lang.Enum class which provides the default behavior.

• Enums cannot declare methods which override the final methods of the java.lang.Enum class:

– clone(), compareTo(Object), equals(Object), getDeclaringClass(), hashCode(), name(), ordinal().

– The final methods do what their names imply, but the clone() method throws an CloneNotSupportedException, as an enum constant cannot be cloned.

• Note that the enum constants must be declared before any other declarations in an enum type.

public class MealClient {
public static void main(String[] args) {
for (Meal meal : Meal.values())
System.out.println(meal + " served at " + meal.getHour() + ":" + meal.getMins() + ", has the ordinal value " + meal.ordinal());
}
}

Output from the program:

BREAKFAST served at 7:30, has the ordinal value 0
LUNCH served at 12:15, has the ordinal value 1
DINNER served at 19:45, has the ordinal value 2

Enums in a switch statement

• The switch expression can be of an enum type, and the case labels can be enum constants of this enum type.

public class EnumClient {
public static void main(String[] args) {
Machine machine = new Machine();
machine.setState(MachineState.IDLE);
// ...
MachineState state = machine.getState();
switch(state) {
//case MachineState.BUSY:// Compile error: Must be unqualified.
case BUSY: System.out.println(state + ": Try later."); break;
case IDLE: System.out.println(state + ": At your service."); break;
case BLOCKED: System.out.println(state + ": Waiting on input."); break;
//case 2: // Compile error: Not unqualified enum constant.
default: assert false: "Unknown machine state: " + state;
}
}
}

Varargs

Assume you want to invoke a method with variable number of arguments. The option we
had on hand in Java 1.4 or earlier was to pass an array. Let’s consider a simple example
as shown below:

public static int max(int[] values)
{
int max = values[0];
for(int aValue : values)
{
if (aValue > max) max = aValue;
}
return max;
}

We can invoke this method by passing an array with different number of values as illustrated below:

max(new int[] {1, 7, 2, 9, 8});
max(new int[]{8, 12, 87, 23, 1, 3, 6, 9, 37});

In order to invoke a method that takes variable number of arguments, we had to bundle
the parameters into an array. While this works, it is not elegant. The varargs introduced in
Java 5 addresses the elegance issue.

It is not only elegant, it also is very type safe. Let’s take the max method and modify it to use the varargs.

public static int max(int... values)

Notice that the only thing I changed is int[] to int… and I did not modify the
implementation of the max method. If the previous implementation of the method still
works after the change to the parameter type, then what is the new syntax and how is it
related to the array?

A type followed by … is simply a syntax sugar–it’s nothing but an array. However, the
compiler allows you to pass either an array or a discrete set of values to this method. For
example, now I can call the modified max method as follows:

max(new int[] {1, 7, 2, 9, 8});
max(new int[]{8, 12, 87, 23, 1, 3, 6, 9, 37});

max(1, 7, 2, 9, 8);
max(8, 12, 87, 23, 1, 3, 6, 9, 37);

There’s less clutter in the bottom two lines than in the top two lines. But what’s going on
when you pass discrete values? The compiler simply rolls the values into an array. So, the

code:

max(1, 7);
is compiled into:
max(new int[] {1, 7});

In the above example we passed an array of int. What if we want to pass different types
of data? Sure we can. Consider the example below:

public static void print(Object... values)
{
for(Object obj : values)
{
System.out.printf("%s is of type %s\n", obj, obj.getClass().getName());
}
}

The above code receives a varargs of type Object. You can invoke it with different types as shown below:

print(1, "test", 'a', 2.1);

The output from this call is:

1 is of type java.lang.Integer test is of type java.lang.String a is of type java.lang.Character
2.1 is of type java.lang.Double

The first line should be no surprise if you kept autoboxing in mind–that is the reason for
the type to be Integer instead of int. We’ve also used the printf statement which
directly benefits from the varargs concept.

You are not restricted to having only varargs as parameters, that is, you can have regular
parameters and varargs, if you like. However, varargs, if present, must be trailing. In
other words, place any regular parameters you like and then place the varargs as shown in

the following example:

public static void print(String msg, Object... values)

Pros and Cons:

• varargs comes in handy when you want to pass variable number of arguments.
Use it if you need that flexibility and elegance.

• You loose some compile time type safety if your varargs is of type Object.
However, if it is specific type (like int…), then you have type safety.

• If in your application you expect only three or four parameters to be passed to the
method, then don’t bother to use varargs.

• If you are not careful, you may have trouble with method overloading as the
varargs may increase the chance of parameter collision when methods are overloaded.

Annotations

Annotations is a new feature from Java 5. Annotations are a kind of comment or meta data you can insert in your Java code. These annotations can then be processed at compile time by pre-compiler tools, or at runtime via Java Reflection. Here is an example of class annotation:

@MyAnnotation(name="someName", value = "Hello World")
public class TheClass {
}

The class TheClass has the annotation @MyAnnotation written ontop. Annotations are defined like interfaces. Here is the MyAnnotation definition:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)

public @interface MyAnnotation {
public String name();
public String value();
}

The @ in front of the interface marks it as an annotation. Once you have defined the annotation you can use it in your code, as shown in the earlier examples.

The two directives in the annotation definition, @Retention(RetentionPolicy.RUNTIME) and@Target(ElementType.TYPE), specifies how the annotation is to be used.

@Retention(RetentionPolicy.RUNTIME) means that the annotation can be accessed via reflection at runtime. If you do not set this directive, the annotation will not be preserved at runtime, and thus not available via reflection.

@Target(ElementType.TYPE) means that the annotation can only be used ontop of types (classes and interfaces typically). You can also specify METHOD or FIELD, or you can leave the target out alltogether so the annotation can be used for both classes, methods and fields.

Class Annotations

You can access the annotations of a class, method or field at runtime. Here is an example that accesses the class annotations:

Class aClass = TheClass.class;
Annotation[] annotations = aClass.getAnnotations();
for(Annotation annotation : annotations){
if(annotation instanceof MyAnnotation){
MyAnnotation myAnnotation = (MyAnnotation) annotation;
System.out.println("name: " + myAnnotation.name());
System.out.println("value: " + myAnnotation.value());
}
}

You can also access a specific class annotation like this:

Class aClass = TheClass.class;
Annotation annotation = aClass.getAnnotation(MyAnnotation.class);
if(annotation instanceof MyAnnotation){
MyAnnotation myAnnotation = (MyAnnotation) annotation;
System.out.println("name: " + myAnnotation.name());
System.out.println("value: " + myAnnotation.value());
}

Method Annotations

Here is an example of a method with annotations:

public class TheClass {
@MyAnnotation(name="someName", value = "Hello World")
public void doSomething(){}
}

You can access method annotations like this:

Method method = ... //obtain method object
Annotation[] annotations = method.getDeclaredAnnotations();
for(Annotation annotation : annotations){
if(annotation instanceof MyAnnotation){
MyAnnotation myAnnotation = (MyAnnotation) annotation;
System.out.println("name: " + myAnnotation.name());
System.out.println("value: " + myAnnotation.value());
}
}

You can also access a specific method annotation like this:

Method method = ... // obtain method object
Annotation annotation = method.getAnnotation(MyAnnotation.class);
if(annotation instanceof MyAnnotation){
MyAnnotation myAnnotation = (MyAnnotation) annotation;
System.out.println("name: " + myAnnotation.name());
System.out.println("value: " + myAnnotation.value());
}

Parameter Annotations

It is possible to add annotations to method parameter declarations too. Here is how that looks:

public class TheClass {
public static void doSomethingElse(
@MyAnnotation(name="aName", value="aValue") String parameter){
}
}

You can access parameter annotations from the Method object like this:

Method method = ... //obtain method object
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
Class[] parameterTypes = method.getParameterTypes();
int i=0;
for(Annotation[] annotations : parameterAnnotations){
Class parameterType = parameterTypes[i++];
for(Annotation annotation : annotations){
if(annotation instanceof MyAnnotation){
MyAnnotation myAnnotation = (MyAnnotation) annotation;
System.out.println("param: " + parameterType.getName());
System.out.println("name : " + myAnnotation.name());
System.out.println("value: " + myAnnotation.value());
}
}
}

Notice how the Method.getParameterAnnotations() method returns a two-dimensionalAnnotation array, containing an array of annotations for each method parameter.

Field Annotations

Here is an example of a field with annotations:

public class TheClass {
@MyAnnotation(name="someName", value = "Hello World")
public String myField = null;
}

You can access field annotations like this:

Field field = ... //obtain field object
Annotation[] annotations = field.getDeclaredAnnotations();
for(Annotation annotation : annotations){
if(annotation instanceof MyAnnotation){
MyAnnotation myAnnotation = (MyAnnotation) annotation;
System.out.println("name: " + myAnnotation.name());
System.out.println("value: " + myAnnotation.value());
}
}

You can also access a specific field annotation like this:

Field field = ... // obtain method object
Annotation annotation = field.getAnnotation(MyAnnotation.class);
if(annotation instanceof MyAnnotation){
MyAnnotation myAnnotation = (MyAnnotation) annotation;
System.out.println("name: " + myAnnotation.name());
System.out.println("value: " + myAnnotation.value());
}

Other features

In this article we have focused on the language features in Java 5. Java 5 has some other

interesting features as well. Listed below are some select features:

• StringBuilder
– StringBuffer eliminates object creation overhead, but has synchronization overhead
– StringBuilder removes that overhead

• Client vs. Server side differences in garbage collection, more adaptive collection

• Improved Image I/O for performance and memory usage

• Reduced application startup time and footprint using shared archive

• Enhancement to Thread Priority

• Ability to get stack trace for a thread or all threads

• UncoughtExceptionHandler on a Thread

• Improved error reporting on fatal exceptions

• System.nanoTime() for nanoseconds granularity for time measurements

• ProcessBuilder

– Easier than Runtime.exec() to start process

• Formatter and Formattable provide ability to format output in printf like style

• Scanner for easier conversion to primitive types – based on regex

• java.lang.instrument allows byte code enhancement at runtime to instrument code

• Collections Framework has Queue, BlockingQueue, and ConcurrentMap interfaces and implementations. Some classes modified to implements new interfaces

• Reflection API supports annotation, enum. Class has been generified

• System.getenv() undeprecated

Scripting Language Support in Java SE 6 (Mustang)

2011-03-29T23:44:00.012+05:30

You can now mix in JavaScript technology source code, useful for prototyping. Also useful when you have teams with a variety of skill sets. More advanced developers can plug in their own scripting engines and mix their favourite scripting language in with Java code as they see fit.

J2SE 1.6 includes a modified version of the Rhino JavaScript engine integrated via JSR 223 and a command-line scripting shell, jrunscript, which leverages this support. The shell is of limited use in most applications, but can be a valuable tool in learning and prototyping in Java and arbitrary scripting languages. The jrunscript syntax is:

Usage: jrunscript [options] [arguments...]

Accessing the Scripting Engine

The fundamental interface for all scripting engines is javax.script.ScriptEngine. This interface defines a set of methods expected to be supported by all implementations. An implementation is obtained from the ScriptEngineManager. ScriptEngine implementations are deployed as Jar files (typically in lib/ext). Each such jar contains a text file resource META-INF/services/javax.script.ScriptEngineFactory defining one or more classes implementing ScriptEngineFactory. The ScriptEngineManager utilizes these factories to create specific implementations. The ScriptEngineManager also provides metadata defining the supported script type and version information which is used to resolve requests for a scripting implementation. Obtaining an engine is straightforward:

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine jsEngine = manager.getEngineByName("js");

The primary method of the ScriptEngine, eval(), executes a script directly passed as a String or accessed through a Reader. These two variations may be additionally parameterized with either a Bindings or ScriptContext object.

Object eval(String script)
Object eval(Reader reader)
Object eval(String script, Bindings n)
Object eval(Reader reader, Bindings n)
Object eval(String script, ScriptContext context)
Object eval(Reader reader, ScriptContext context)

A ScriptContext associates a ScriptEngine with objects in the Java application. Every engine has a default ScriptContext (which can be altered through the API). It groups objects by scope. Each scope has a related Bindings instance containing these objects. Bindings is simply a Map which associates scripting variable names with Java instances.

Two scopes are predefined, ScriptContext.GLOBAL_SCOPE and ScriptContext.ENGINE_SCOPE. The first contains attributes shared by all Engines created via a given factory, while the second is specific to the engine implementation. The default context and scope is used by the single argument eval() methods. The Scripting API includes many instances of such convenience methods. A binding or context passed to an eval effectively replaces the default bindings or context for the scope of the method call.

Additional scopes may be defined by contexts specific to an Engine. For example, the HttpScriptContext used in web-based applications defines request, session, and applications scopes corresponding to Servlet scopes.

The below example summarizes basic usage of the Scripting API:

// simple script execution
jsEngine.eval("print('Hello')");

// bind scripting variables and use in a script
jsEngine.put("a", 3);
Integer b = 2;
jsEngine.put("b", b);
Object retval = jsEngine.eval("c = a + b; print('a + b = ' + c);");

// retrieve the bindings we previously added
Bindings bindings = jsEngine.getBindings(ScriptContext.ENGINE_SCOPE);
boolean containsKey = bindings.containsKey("a");
System.out.println(containsKey);

Results in:

Hello
a + b = 5
true

The checked ScriptException is thrown by methods of the Scripting API. Depending on the Engine, the errant line and column number of the script will be included in the exception.

Compilable and Invocable

Beyond the based ScriptEngine capability, certain implementations may advertise additional capability by implementing the Compilable or Invocable interfaces.

An engine implementing Compilable supports the re-execution of intermediate (e.g. compiled) code from previous compilations. The compile() method returns a CompiledScript based on either a String or Reader. The CompiledScript may be executed repeatedly via its eval() method.

Compilable eng = (Compilable)jsEngine;
CompiledScript script = eng.compile("function test() { return 10; }; test();");
Object compiledOutput = script.eval();
System.out.println(compiledOutput); // prints 10.0

An engine implementing Invocable supports the calling of individual functions scripted in the engine via the invoke() method. Arguments and return values are converted between script and Java types based on the engine implementation. Below is a simple example:

jsEngine.eval("function test(val) { return val; }");
Invocable jsInvoke = (Invocable)jsEngine;
Object invoke = jsInvoke.invoke("test", new Object[] {111.0});
System.out.println(invoke); // prints 111.0

Scripts may be used to implement arbitrary interfaces without direct dependence on the given interface. The following example illustrates definition of a run() method which is bound as the implementation of a Runnable interface at runtime based only on method signature. Below, the invoke() and run() calls invoke the same underlying scripted method.

jsEngine.eval("function run() { print ('running..'); }");
Object invoke2 = jsInvoke.invoke("run",null); // prints running...

Runnable r = jsInvoke.getInterface(Runnable.class);
r.run(); // prints running...

Enhancements in Java SE 6 (Mustang)

2011-03-29T23:31:00.001+05:30

Web Services (Improved Web Service support)

All developers get first-class support for writing XML web service client applications. No messing with the plumbing: You can expose your APIs as .NET interoperable web services with a simple annotation. Not your style? Want to handle the XML directly? Knock yourself out: Java SE 6 adds new parsing and XML to Java object-mapping APIs, previously only available in Java EE platform implementations or the Java Web Services Pack.

Scripting (Scripting Language Support)

You can now mix in JavaScript technology source code, useful for prototyping. Also useful when you have teams with a variety of skill sets. More advanced developers can plug in their own scripting engines and mix their favourite scripting language in with Java code as they see fit.

Database (JDBC 4.0 support)

For a great out-of-the-box development experience with database applications, the Java SE 6 development kit – though not the Java Runtime Environment (JRE) – co-bundles the all-Java JDBC database, Java DB based on Apache Derby. No more need to find and configure your own JDBC database when developing a database application! Developers will also get the updated JDBC 4.0, a well-used API with many important improvements, such as special support for XML as an SQL datatype and better integration of Binary Large OBjects (BLOBs) and Character Large OBjects (CLOBs) into the APIs.

More Desktop APIs

GUI developers get a large number of new tricks to play like the ever popular yet newly incorporated SwingWorker utility to help you with threading in GUI apps, JTable sorting and filtering, and a new facility for quick splash screens to quiet impatient users.

Monitoring and Management

The really big deal here is that you don't need do anything special to the startup to be able to attach on demand with any of the monitoring and management tools in the Java SE platform. Java SE 6 adds yet more diagnostic information, and we co-bundled the infamous memory-heap analysis tool Jhat for forensic explorations of those core dumps.

Compiler Access

Really aimed at people who create tools for Java development and for frameworks like JavaServer Pages (JSP) or Personal Home Page construction kit (PHP) engines that need to generate a bunch of classes on demand, the compiler API opens up programmatic access to javac for in-process compilation of dynamically generated Java code. The compiler API is not directly intended for the everyday developer, but for those of you deafened by your screaming inner geek, roll up your sleeves and give it a try. And the rest of us will happily benefit from the tools and the improved Java frameworks that use this.

Pluggable Annotations

It is becoming a running joke in Java technology circles, at least some that contain us, that for every wished-for feature missing in Java technology, there's a budding annotation that will solve the problem. Joke no more, because Java tool and framework vendors can put a different smile on your face, defining their own annotations and have core support for plugging in and executing the processors that do the heavy lifting that can make custom annotations so cool.

Desktop Deployment

Those of you deploying applications to the desktop will soon discover that it's a tale of a large number of smaller changes that add up to a big difference to existing applications: better platform look-and-feel in Swing technology, LCD text rendering, and snappier GUI performance overall. Java applications can integrate better with the native platform with things like new access to the platform's System Tray and Start menu. At long last, Java SE 6 unifies the Java Plug-in technology and Java WebStart engines, which just makes sense. Installation of the Java WebStart application got a much needed makeover.

Security

You can have all the security features you like in the platform — and this release adds a few more, like the XML-Digital Signature (XML-DSIG) APIs for creating and manipulating digital signatures — but if you don't have well supported security administrators, your security may be at risk. So Java SE 6 has simplified the job of its security administrators by providing various new ways to access platform-native security services, such as native Public Key Infrastructure (PKI) and cryptographic services on Microsoft Windows for secure authentication and communication, Java Generic Security Services (Java GSS) and Kerberos services for authentication, and access to LDAP servers for authenticating users.

Quality, Compatibility, Stability

You probably knew that Sun has done regular feature releases of the Java SE platform over the last 10 years. So we certainly feel like we've built up some expertise in this area, such as the ever growing 80,000 test cases and several million lines of code testing conformance (being just one aspect of our testing activity). You probably noticed that, unlike the last release, people have been downloading binary snapshots for the last 20 (not just 6) months. And what's more, they've been filing bugs. So, before we even got to beta, we'd fixed a number of quality and regression issues. Doesn't that add up to a better product? Oh, and by the way, performance is looking better than J2SE 5.0.