Interview Questions On Java,Java EE

Core Java Interview Questions

2015-04-03T08:38:00.000-07:00

Every year many thousand technocrats choose Java careers across the globe,after formally taking Java training classes,courses and/or Java certifications like SCJP etc.While appearing for technical interviews,these budding Java programmers face variety of technical questions, are asked to write code snippets to prove their mettle in relevant topics of Java.They are not only assessed on language basics but also on their familiarity with Java development tools, coding standards and guidelines,optimization of Java code,load tests,securing code through Java obfuscation and many more. It is their performance in these interviews which decides their career fate and is highly dependent on to-the-point and not too verbose answers.

Apart from technical questions, an interviewee faces a spate of personal questions as well.In post, Personal Interview Questions you will find variety of questions asked on personal front.In wired world, it is very important to know where your resources are lying and how credible are they.

This blog intends to provide a consolidated knowledge base for all netizens,budding Java Engineers or experienced ones, interested in Java technology.This blog will primarily focus on 'Core Java' related questions and later on advanced topics in Java EE space,Open source technologies and frameworks and more.At this point this is a nice idea to put a roadmap right away to put all these questions in an organized fashion. In order to access questions list on a particular topic,please click the links associated with it.It will open the questions list in the same browser window and in order to comeback to this page, while going through various posts, you have to click back button in your bowser window.Each answer for a question on various topics will open in a fresh window,while you are through with reading an answer,close the open window in order to comeback to the questions list.If you want to access Master List of Core Java Interview Questions then click here.In order to jump to recent posts straightaway, you can view a list of these in a widget box as shown below:

Java Language Fundamentals (Click Link To Access Questions' List)

Packages and their classes (Click Link To Access Questions' List)

Java and Database Access
JFC Swing
Collection APIs

Check more miscellaneous short questions on Core Java with short answers,here.

If you starve for more knowledge on Core Java,you may like to check out online e-books and other resources on Core Java or access all Online Java and Java EE resources. All suggestions,comments are welcome in order to make this space more productive and useful for all its audiences.

Read more on Core Java:
- Short Questions On Core Java
- Interview Questions on Java 5
- Enhancements in Java 7

Java EE,Open Source,Advanced Technologies Interview Questions

2015-04-02T03:00:00.000-07:00

In continuation of earlier post on Java Interview Questions this post is focussed on interview questions in several Java EE technologies(erstwhile J2EE).Apart from Java EE, interview questions on most widely used open source technologies like Struts,Hibernate,Spring and Velocity and more will also be covered.

On constant requests by readers to put something on personal interview questions, consequently, you may like to read post on personal interview questions , prior talking about Java Enterprise Edition.

Sun Microsystems introduced Java EE 5 specification under JSR 244 and the final release was made public on May ,2006.Java EE has become a cornerstone technology for enterprise level web based solution development.It has more than three million downloads and more than twenty six vendors' application servers support this specification.It is significant to go through an introduction of Java EE 5 before jumping to questions list straightaway.You can capture essence of Java EE 5 here in detail.

If you directly want to access Master List of Java EE Interview Questions then click here.

The list of questions on various topics covered under Java EE hood is as follows(on the basis of different technologies covered under Java EE umbrella) :

Java EE 5(Click To Access Questions' List)
Java Servlets
Java Server Pages and JSP Standard Tag Libraries
Enterprise Java Beans
Java Message Services
Java APIs for XML Parsing
Java Connector Architecture
Java Mail
Java Transaction APIs

Open Source Technologies/Emerging Frameworks:
Struts
Hibernate Framework
Spring Framework
Velocity
Apache AXIS
Annotations or attributes based programming (xdoclet etc).
Aspect Oriented Programming (AOP).
EJB 3.0.
Inversion of Control (IOC) (Also known as Dependency Injection).
JavaServer Faces (JSF) framework.
Test Driven Development (TDD).

Architectures:
Service Oriented Architecture

Others
Java Design Patterns

If anyone of you has come across a very unique experience in terms of technical and personal questions asked, feel free to share your experience.

Keep sharing your resources for ongoing learning...

Learn more about Java EE, here.

Master List Of Core Java Questions

2015-03-02T00:54:00.000-08:00

OOPS

What is an Object?

What is a Class?

What is OOAD?

What is Data Abstraction ?

What is Data Encapsulation?

What is the difference between Data Abstraction and Information Hiding?

What is Inheritance and what are different types of it?

Why Java uses Singly rooted hierarchy?

Why does Java not support Multiple Inheritance?

Why is Java not 100% pure OOP language?

What is Early Binding?

What is Polymorphism/Late Binding?

What is method overloading?

What is method overriding?

How is Java different from C++?

What is UML and how is it useful in designing large systems?

Is UML useful for procedural programming ?

What are different notations used in UML ?

What is a Use case and an Actor?

How to identify an Actor?

What is Generalization?

What is Association and how it maps into a Java class?

What is Aggregation and how it maps into a Java class?

What is Composition and how it maps into a Java class?

What is Dependency and how it maps into a Java class?

What is the purpose of State machine diagrams?

What are different kinds of Structure diagrams?

What are different kinds of Interaction diagrams?

What are different kinds of Behavior diagrams?

Java Fundamentals

What is a Java Virtual Machine (JVM)?

What is a JVM consisted of?

What is a class loader and what is its responsibilities?

What is heap and stack?

How is your Java program executed inside JVM?

What is Java class file's magic number?

How JVM performs Thread Synchronization?

How JVM performs Garbage Collection?

How to profile heap usage?

What will you do if VM exits while printing "OutOfMemoryError" and increasing max heap size doesn't help?

Should one pool objects to help Garbage Collector?Should one call System.gc() periodically?

An application has a lot of threads and is running out of memory, why?

If your program is I/O bound or running in native methods, do these activities engage JVM?

What is the difference between interpreted code and compiled code?

Why Java based GUI intensive program has performance issues?

What is 64 bit Java ?

What is the difference between JVM and JRE?

What are different primitive datatypes in Java?

What are expressions,statements and blocks in Java?

What is a transient variable?

What is the difference between the '&' operator and the '&&' operator?

Why main method of Java has public static void?

If you have static block, constructor and main method in Java file then what will be the sequence of method calls?

What are the command line arguments?

Does Java support multi dimensional arrays?

What are the restrictions for static method?

Why a abstract method cannot be static?

Is 'sizeof' a keyword?

What is the precedence of operators in Java?

How is an argument passed in Java methods?

What is the difference between class variable, member variable and automatic(local) variable?

When are static and non static variables of a class initialized?

Can shift operators be applied to float types?

What are different Java declarations and their associated rules?

What are Java Modifiers?

Explain final modifier.

Can you change the reference of the final object?

Can abstract class be instantiated?

When does the compiler insist that the class must be abstract?

Where can static modifiers be used?

What is static initializer code?

Can an anonymous class implement an interface and extend a class at the same time?

What are volatile variables?

Can protected or friendly features be accessed from different packages?

How many ways can one write an infinite loop?

When do you use 'continue' and 'break' statements?

What is the difference between 'while' and 'do while' loop?

What is an Assertion and why using assertion in your program is a good idea ?

Explain Assertions with a code exmaple.

How many forms of assertions we have?

When assertions should be avoided?

What situations are best suitable for implementing assertions?

What is Exception ?

What is a user-defined exception?

What do you know about the garbage collector?

Why Java does not support pointers?

Does garbage collection guarantee that a program will not run out of memory?

What is finally in Exception handling?

What can prevent the execution of the code in finally block?

Explain 'try','catch' and 'finally' blocks?

Define Checked and Unchecked exception.

What is the difference between an abstract class and an interface?

What is the use of interface?

What is serializable interface?

Does a class inherit constructors from its superclass?

What's the difference between constructors and other methods?

If the method to be overridden has access type 'protected', can subclass have the access type as 'private'?

If you use super() or this() in a constructor where should it appear in the constructor?

What modifiers may be used with an inner class that is a member of an outer class?

Can an inner class be defined inside a method?

What is an anonymous class?

What is a thread?

What is the difference between process and threads?

What are two types of multitasking?

What are two ways of creating threads in Java and why so?

How does multithreading take place on a computer with a single CPU?

How a Java object be locked for exclusive use by a given thread?

What is Synchronization?

Explain wait(),notify(), and notifyAll() methods?

What is a Daemon thread?

How a dead thread can be started?

What is the difference between String and StringBuffer?

How is '==' different from .equals() method in case of String objects?

Explain StreamTokenizer?

What is Collection?

Explain List,Set and Map.

What is the serialization?

What is the difference between Serializable and Externalizable interface?

What is memory leak?

Difference between ArrayList and Vector class?

What is the difference between Hashtable and HashMap?

What is JFC?

What is the difference between JFC Swing and AWT?

What is the base class for all swing components?

What are lightweight and heavyweight components ?

How can a GUI component handle its own events?

What is a Layout Manager and what are its different types and their advantages?

How are the elements of a GridBagLayout organized?

What are the problems faced by Java programmers in absence of layout managers?

Where the CardLayout is used?

What is the difference between GridLayout and GridBagLayout?

How will you add a panel to a frame?

What is the difference between Application and Applet?

Explain Lifecycle of the Applet and what is the order of method invocation in an applet?

What is the difference between Java class and bean?

What is difference between trusted and untrusted applet?

How do you set Java Library path programmatically?

Explain the usage of java.util.Date and more classes and APIs for date handling in Java?

JDBC

What is JDBC ?

What are four drivers available in JDBC?

How do you establish database connection using JDBC?

How do you connect to a MySql Database using JDBC?

What are the different types of Statements?

What is PreparedStatement and how is different from Statement?

What is the difference between executeQuery () and execute() ?

What is the difference between executeQuery () and executeUpdate()?

How do you call a stored procedure in Java?

What are new features from JDBC2.0 onwards?

How can a cursor move in scrollable result sets?

Differentiate TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE?

How will you differentiate the following two ways of loading a database driver?

How can you display a particular web page from an applet?

How can you get the hostname on the basis of IP addres ?

How can you get an IP address of a machine from its hostname?

How do you know who is accessing your server?

What are different socket options?

What should I use a ServerSocket or DatagramSocket in my applications?

Master List Of Java EE,Open Source,Advanced Technologies Questions(Release I )

2015-03-01T08:32:00.000-08:00

Servlets

What is a servlet? Explain its lifecycle.

What is the difference between CGI and servlets?

What is a middleware and what is the functionality of Webserver?

Can there be more than one instance of a servlet at one time ?

Why there are no constructors in servlets?

What is a Servlet Context?

What is meant by Session tell me something about HttpSession?

What is the difference between GenericServlet and HTTPServlet?

What is the difference between doGet and doPost methods of HttpServlet class?

Why do GenericServlet and HttpServlet class implement Serializable interface?

How will you pass values from HTML to the servlet?

Can you use System.exit in your servlet end code?

If my browser does not support Cookie and my server sends a Cookie instance what will happen?

Can you use System.exit in your servlet end code?

What is the difference in between encodeRedirectURL and encodeURL?

How do you make servlet thread-safe?

How do you communicate between applet and servlet?

JSP

What is the difference between Java Servlets and Java ServerPages (JSP)?

What is the difference between page directive 'include' and 'jsp include' action command?

What is the difference between 'jsp:forward' and HttpResponse.sendRedirect()?

What is the difference between 'include file=".."' and 'jsp:include page = ... '?

What are implicit objects in JSP?

Explain the life-cycle methods of JSP

Explain different constituents of JSP like comments,expressions,declarations,scriptlets.

Does JSP support XML pages creation?

How can I show various kind of documents to a web client from JSP's and/or servlets?

How will you handle runtime exceptions in your JSPs?

How can you prevent caching in JSP?

EJB

How EJB evolved over the years?

What are Entity Bean and Session Bean?

How is container managed entity bean created?

What is the difference between Container managed persistent and Bean managed persistent

What is the difference between ejbCreate() and ejbPostCreate() in EntityBean?

What are the services provided by the EJB container ?

What are new features of EJB3?

What is Connection Pooling? Is it advantageous?

What's difference between Servlet/JSP session and EJB session?

How is JDO(Java Data Object) different from VO(Value Object) ?

What is session facade?

EJB Transactions

What are Bean-Managed Transactions?

What are some tips for using bean-managed transaction demarcation?

What is JTS ?

What are transaction properties?

What are transaction attributes ? Which transaction attributes should I use in which situations?

How can you handle transaction isolation?

Struts Framework

What is Struts and how it helps in web development?

Explain Struts1.x in a nutshell?

What are the methods in Action class?

How you will handle errors and exceptions in Struts?

How does Validator framework work in Struts?

What is DispatchAction?

How to handle duplicate submits in Struts?(new)

Spring Framework

What is Spring framework

Why is Spring Framework needed anyway?

What do you understand by Inversion of Control/Dependency Injection?

What is BeanFactory?

Explain ApplicationContext in Spring framework.

What is Aspect Oriented Programming and how is it related with Spring?

What are the problems you have with JDBC and how does Spring framework help to resolve them?

Explain typical Bean life cycle in Spring Bean Factory Container

What are ORMs supported by Spring and how it integrates with Hibernate?

Java Message Service APIs

What is messaging and how is it different from RMI?

When is JMS needed?

How Does the JMS API Work with the Java EE Platform?

Explain JMS API Architecture.

Explain Point-to-Point Messaging Domain.

Explain Publish/Subscribe Messaging Domain.

Java Design Patterns

What are Design Patterns and why one needs them?

What are different types of design patterns?

What is Singleton Design Pattern?

What is difference between Abstract Factory and Factory Method design patterns?

Explain Adapter Design Pattern in Java

Explain Decorator Design Pattern in Java

Explain Facade Design Pattern in Java

Miscellaneous Core Java Questions With Short Answers

2015-02-01T08:43:00.000-08:00

In a Java program, how can you divert program messages to the system console, but error messages, say to a file?

A. The class 'System has a variable out that represents the standard output, and the variable err that represents the standard error device. By default, they both point at the system console. This how the standard output could be re-directed:
```
Stream stream = new Stream(new FileOutputStream("error.txt"));
System.setErr(stream);
System.setOut(stream);
```
How do you know if an explicit object casting is needed?

A. In order to assign a superclass object to a variable of a subclass,one needs to do explicit casting. For example:
```
Person person;
Man man;
man = (Man)person;
```
While automatic casting happens when you typecast a subclass object as parent class object.

What's the difference between the methods sleep() and wait()

A. The code sleep(1000); puts thread aside for exactly one second. The code wait(1000), causes a wait of up to one second. A thread could stop waiting earlier if it receives the notify() or notifyAll() call. The method wait() is defined in the class Object and the method sleep() is defined in the class Thread.

Why would you use a synchronized block vs. synchronized method?

A. A synchronized blocks place locks for shorter periods than synchronized methods.

Can you write a Java class that could be used both as an applet as well as an application?

A. Yes. Add a main() method to the applet.

Can you call one constructor from another if a class has multiple constructors

A. Yes. Use this() syntax.

How will you convert a String array to an ArrayList object?

A.


String[] stringArray = new String[] {"x", "y", "Z"};
List list = Arrays.asList(stringArray);

Does it matter in what order catch statements for FileNotFoundException and IOExceptipon are written?

A. Yes, it does. The FileNoFoundException is inherited from the IOException. Exception's subclasses have to be caught first.

Can an inner class declared inside of a method access local variables of this method?

A. It's possible if these variables are final.

What can go wrong if you replace && with & in the following code:


String a=null;
if (a!=null && a.length()>10) {...}

A. A single ampersand here would lead to a NullPointerException.

When should the method invokeLater()be used?

A. To ensure that Swing components are updated through the event-dispatching thread.

What's the difference between a queue and a stack?

A. Stacks works by last-in-first-out rule (LIFO), while queues use the FIFO rule

You can create an abstract class that contains only abstract methods. On the other hand, you can create an interface that declares the same methods. So can you use abstract classes instead of interfaces?

A. Sometimes. But your class may be a descendant of another class and in this case the interface is your only option.

If you're overriding the method equals() of an object, which other method you might also consider?

A.hashCode()

You are planning to do an indexed search in a list of objects. Which of the two Java collections should you use: ArrayList or LinkedList?

A. ArrayList

How would you make a copy of an entire Java object with its state?

A. Have this class implement Cloneable interface and call its method clone().

How can you minimize the need of garbage collection and make the memory use more effective?

A. Use object pooling and weak object references.

There are two classes: A and B. The class B need to inform a class A when some important event has happened. What Java technique would you use to implement it?

A. If these classes are threads then consider notify() or notifyAll(). For regular classes one can use the Observer interface.

How will you sort a collection object?

A.

  
// Sort
Collections.sort(list);

// Case-insensitive sort
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

// Reverse-order sort
Collections.sort(list, Collections.reverseOrder  ());

// Case-insensitive reverse-order sort
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
Collections.reverse(list);

In a Java class, one has 10 variables. One wants to serialize only 3 variables,how can this be achieved?

A.Make variables as 'transient' which are not to be serialized.

Master List Of Code Snippets

2015-01-26T06:18:00.000-08:00

XML Parsing Using SAX

File Operations

Experimenting with java.util.Date.

Using java.lang.reflect.* APIs

Using java.lang.Comparable.* interface

Thread Interruption

Get Locale Specific Date

Write Into An Excel File Using Java

Sending EMail To GMail SMTP Server Using Java Mail APIs

Some commonly used validations like EMail,Phone Number,SSN,Numeric values through Regular Expressions

Simplifying Service Oriented Architecture

2015-01-11T21:35:00.000-08:00

What is SOA?

Why SOA?

What are the constituents of SOA?

Who suits best for SOA?

When to avoid implementation of SOA?

How to avoid risks in SOA implementation?

How SOA makes things better or even worse?

How to develop,test and maintain SOA based solutions?

How to register Web Services with UDDI4j?

Webservices, Apache Axis Way

Webserivces With Apache Axis Continued...

Apache AXIS with IBM's WSAD/RAD

What are the enhancements in Java SE 7?

2012-01-15T01:19:00.000-08:00

Binary Literals - Integral types (byte, short, int, and long) can also be expressed using the binary number system. To specify a binary literal, add the prefix 0b or 0B to the number.
Underscores in Numeric Literals - Any number of underscore characters (_) can appear anywhere between digits in a numerical literal.
Strings in switch Statements - The String class in the expression of a switch statement.
Type Inference for Generic Instance Creation - One can replace the type arguments required to invoke the constructor of a generic class with an empty set of type parameters (<>) as long as the compiler can infer the type arguments from the context. This pair of angle brackets is informally called the diamond.
Improved Compiler Warnings and Errors When Using Non-Reifiable Formal Parameters with Varargs Methods - The Java SE 7 complier generates a warning at the declaration site of a varargs method or constructor with a non-reifiable varargs formal parameter. Java SE 7 introduces the compiler option -Xlint:varargs and the annotations @SafeVarargs and @SuppressWarnings({"unchecked", "varargs"}) to supress these warnings.
The try-with-resources Statement - The try-with-resources statement is a try statement that declares one or more resources. A resource is an object that must be closed after the program is finished with it. The try-with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements the new java.lang.AutoCloseable interface or the java.io.Closeable interface can be used as a resource. The classes java.io.InputStream, OutputStream, Reader, Writer, java.sql.Connection, Statement, and ResultSet have been retrofitted to implement the AutoCloseable interface and can all be used as resources in a try-with-resources statement.
Catching Multiple Exception Types and Rethrowing Exceptions with Improved Type Checking - A single catch block can handle more than one type of exception. In addition, the compiler performs more precise analysis of rethrown exceptions than earlier releases of Java SE. This enables you to specify more specific exception types in the throws clause of a method declaration

How to use Annotations with Hibernate?

2010-01-03T02:32:00.000-08:00

Before getting into details of using annotations with Hibernate, I would suggest you to go through the previous example . The example posted here is similar to the old one except it uses annotations.Here .hbm.xml will not be required.

In addition to existing jar files, following jar files are also required in class path:

-hibernate-commons-annotations.jar
-ejb3-persistence.jar
-hibernate-annotations.jar

Download these binaries from here

The annotations are supported Java 5 environment(both by Java SE 5.0 and Java EE 5.0) onwards and having strong coupling with under lying database.In order to support multiple databases, annotations are not meant for that and better to use hibernate mapping files.

Let us start writing with Department.java class:

package com.iqjava.department;


import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;


@Entity
@Table(name="DEPTT")
public class Department {

    private long departmentId;
    private String departmentName;

    public Department() {
    }

    public Department(String departmentName) {
        this.departmentName = departmentName;
    }

    @Id
    @GeneratedValue
    @Column(name="DEPTT_ID")
    public long getDepartmentId() {
        return this.departmentId;
    }

    public void setDepartmentId(long departmentId) {
        this.departmentId = departmentId;
    }

    @Column(name="DEPTT_NAME", nullable=false)
    public String getDepartmentName() {
        return this.departmentName;
    }

    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }

}

Some highlights of the above code:

- Hibernate supports EJB 3 Annotations persistence which are contained inside javax.persistence package.
The following annotations are used in the above code:

-@Entity: represents the Entity bean class.
-@Table: underlying RDBMS table is mapped with this tag where data is persisted.If this annotation is not mentioned then Hibernate takes class name as default table name
-@Id: represents identifier property of Entity bean class.It determines default access strategy used by Hibernate.So if @Id is put over field then field access will be used and if it is placed over getter method then property access will be used.
-@GenertaedValue: specify Primary Key generation strategy
-@Column: represents the column of the table to which a property is mapped to

hibernate.cfg.xml looks like as given below:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">org.hsqldb.jdbcDriver</property>
        <property name="hibernate.connection.url">jdbc:hsqldb:hsql://localhost</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.dialect">org.hibernate.dialect.HSQLDialect</property>
        <property name="connection.password"></property>
        <property name="connection.pool_size">1</property>
        <property name="hibernate.dialect"> org.hibernate.dialect.HSQLDialect</property>
        <property name="show_sql">true</property>
        <property name="hbm2ddl.auto">create</property>
        <mapping class="com.iqjava.department.Department" />
    </session-factory>
</hibernate-configuration>

In HibernateUtil.java file, AnnotationConfiguration object is used instead of Configuration object.

package com.iqjava.util;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;


public class HibernateUtil {
    private static final SessionFactory sessionFactory;
    static {
        try {
            sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

How to persist the java objects using Hibernate ORM framework?

2009-11-04T05:59:00.000-08:00

The answer to this question takes the form of a tutorial, where I will go in details, step by step. Hibernate reduces number of lines of coding/writing SQLs for persisting object into the database considerably. This takes focus from doing repetitive work to focus on implementing business logic to address a business problem.

Hibernate uses a object relation mapping file in form of an XML or properties file. In this file there exists a mapping between a Java object and corresponding database table.First thing first, let us create the needed environment to achieve our objective.

We need following tools and binaries:

1.The IDE used is Eclipse Galileo(latest one while writing this post).
2.Hibernate binaries(Hibernate Core 3.3.2 GA and Hibernate Tools 3.2.4 GA)can be downloaded from here
3.Database HSQLDB 1.9

The next step is unzip Hibernate Tools 3.2.4 GA and put features and plugins contents to features and plugins directory of Eclipse Galileo. Ensure you have closed Eclipse IDE prior to this step and once you are done with copying part then restart the Eclipse Galileo.

You have to ensure following JARs have been included in the project:

-hibernate3.jar(contains all core Hibernate files)

-antlr-2.7.6.jar

-commons-collections-3.1.jar

-dom4j-1.6.1.jar

-javassist-3.9.0.GA.jar

-jta-1.1.jar

-slf4j-api-1.5.8.jar(used for logging purposes)
-slf4j-simple-1.5.8.jar(download it from here)

-hsqldb.jar(used for connecting to HSQL Database)

Once all above steps are over then choose Hibernate perspective in Eclipse IDE.Go to Window-Open Perspective-Other and select Hibernate perspective as show in the image given below:

Next step is to define object relation mapping XML file which has .hbm.xml extension. First create a package named com.iqjava.employee and inside this package we will create a new OR mapping XML named 'employee.hbm.xml'.(Right click on package com.iqjava.employee, select New -Hibernate XML Mapping File)

having contents as given below:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.iqjava.employee.Employee" table="EMP">
<meta attribute="class-description">
This class contains the employee details.
</meta>
<id name="employeeId" type="long" column="EMP_ID">
<generator class="native"/>
</id>
<property name="employeeName" type="string" column="EMP_NAME" not-null="true" />
</class>
</hibernate-mapping>

In this OR Mapping file, class element depicts the class which will be mapped with an underlying table of RDBMS, in this case EMP table.The id element represents primary key of the table wherein attribute name represents a variable(employeeId) in Java class which is mapped with the column (attribute of id element) of the table(EMP_ID).

The type attribute represents the hibernate mapping type which will convert data from Java String type to underlying database String datatype .The generator element is used for automatically generate the primary key values.The native value of class attributes ascertain that hibernate picks either identity, sequence or hilo algorithm depending upon the capabilities of the underlying database. The property element is used to link a property in the Java class to a column in the database table.

The next step is to create Hibernate configuration file.Select 'src' folder, right click and choose New--Hibernate Configuration File menu option.

The following wizard window will appear and you will have to enter the data as shown in the picture given below:

The content of the Hibernate configuration file is shown as below:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">org.hsqldb.jdbcDriver</property>
        <property name="hibernate.connection.url">jdbc:hsqldb:hsql://localhost</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.dialect">org.hibernate.dialect.HSQLDialect</property>
        <property name="connection.password"></property>
        <property name="connection.pool_size">1</property>
        <property name="hibernate.dialect"> org.hibernate.dialect.HSQLDialect</property>
        <property name="show_sql">true</property>
        <property name="hbm2ddl.auto">create</property>
        <mapping resource="com/iqjava/employee/employee.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

Once you are done with this step then next step is to create a new a Hibernate console configuration. To do this right click the project folder, select New --- Hibernate Console Configuration.The following Wizard appears:

By default the wizard will load the Hibernate configuration file information. Just click the Finish button to create the Hibernate console configuration.
Once above step is done, you can generate code by selecting the Hibernate Code Generation Configurations option form Run option on toolbar as depicted below:

Once the Wizard shows up, please ensure following tabs have details according to images shown as below:

Once all these settings are ensured then hit Run button and you get Employee.java file being generated from .hbm.xml file and its contents are as shown below:

package com.iqjava.employee;

// Generated Nov 3, 2009 6:02:21 PM by Hibernate Tools 3.2.4.GA

/**
 * This class contains the employee details.
 */
public class Employee implements java.io.Serializable {

    private long employeeId;
    private String employeeName;

    public Employee() {
    }

    public Employee(String employeeName) {
        this.employeeName = employeeName;
    }

    public long getEmployeeId() {
        return this.employeeId;
    }

    public void setEmployeeId(long employeeId) {
        this.employeeId = employeeId;
    }

    public String getEmployeeName() {
        return this.employeeName;
    }

    public void setEmployeeName(String employeeName) {
        this.employeeName = employeeName;
    }

}

Now we create HibernateUtil.java file which creates a SessionFactory from the Hibernate configuration file. The implementation of HibernateUtil.java is given as below:

package com.iqjava.util;

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

public class HibernateUtil {
    private static final SessionFactory sessionFactory;
    static {
        try {
            sessionFactory = new Configuration().configure()
                    .buildSessionFactory();
        } catch (Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

The next step is to create an ExecutionClass.java. The implementation of this class is given as below:

package com.iqjava.employee;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import java.util.List;
import java.util.Iterator;
import com.iqjava.util.HibernateUtil;

public class ExecutionClass {

    public static void main(String[] args) {
        
        ExecutionClass obj = new ExecutionClass();
        Long empId1 = obj.saveEmployee("John");
        Long empId2 = obj.saveEmployee("Paul");
        Long empId3 = obj.saveEmployee("Bill");
        obj.listEmployee();
        System.out.println("Updating emp3....");
        obj.updateEmployee(empId3, "Michael");
        System.out.println("Deleting emp2....");
        obj.deleteEmployee(empId2);
        System.out.println("List employees....");
        obj.listEmployee();
    }
    
    public Long saveEmployee(String employeeName)
    {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction transaction = null;
        Long empId = null;
        try {
            transaction = session.beginTransaction();
            Employee emp = new Employee();
            emp.setEmployeeName(employeeName);
            empId = (Long) session.save(emp);
            transaction.commit();
        } catch (HibernateException e) {
            transaction.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
        return empId;
    }
    
    public void listEmployee()
    {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction transaction = null;
        try {
            transaction = session.beginTransaction();
            List emps = session.createQuery("from Employee").list();
            for (Iterator iterator = emps.iterator(); iterator.hasNext();)
            {
                Employee emp = (Employee) iterator.next();
                System.out.println(emp.getEmployeeName());
            }
            transaction.commit();
        } catch (HibernateException e) {
            transaction.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }
    
    public void updateEmployee(Long empId, String employeeName)
    {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction transaction = null;
        try {
            transaction = session.beginTransaction();
            Employee emp = (Employee) session.get(Employee.class, empId);
            emp.setEmployeeName(employeeName);
            transaction.commit();
        } catch (HibernateException e) {
            transaction.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }
    
    public void deleteEmployee(Long empId)
    {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction transaction = null;
        try {
            transaction = session.beginTransaction();
            Employee emp = (Employee) session.get(Employee.class, empId);
            session.delete(emp);
            transaction.commit();
        } catch (HibernateException e) {
            transaction.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

}

The code details of the above are self explanatory.The project structure in Eclipse is depicted as shown below:

Before executing the ExecutionClass.java., please ensure you have started the HSQLDB server as depicted in image shown below

Once the code in ExecutionClass.java is executed then console of Eclipse IDE shows following output:


31 [main] INFO org.hibernate.cfg.Environment - Hibernate 3.3.2.GA
31 [main] INFO org.hibernate.cfg.Environment - hibernate.properties not found
47 [main] INFO org.hibernate.cfg.Environment - Bytecode provider name : javassist
47 [main] INFO org.hibernate.cfg.Environment - using JDK 1.4 java.sql.Timestamp handling
219 [main] INFO org.hibernate.cfg.Configuration - configuring from resource: /hibernate.cfg.xml
219 [main] INFO org.hibernate.cfg.Configuration - Configuration resource: /hibernate.cfg.xml
437 [main] INFO org.hibernate.cfg.Configuration - Reading mappings from resource : com/iqjava/employee/employee.hbm.xml
594 [main] INFO org.hibernate.cfg.HbmBinder - Mapping class: com.iqjava.employee.Employee -> EMP
625 [main] INFO org.hibernate.cfg.Configuration - Configured SessionFactory: null
750 [main] INFO org.hibernate.connection.DriverManagerConnectionProvider - Using Hibernate built-in connection pool (not for production use!)
750 [main] INFO org.hibernate.connection.DriverManagerConnectionProvider - Hibernate connection pool size: 1
750 [main] INFO org.hibernate.connection.DriverManagerConnectionProvider - autocommit mode: false
781 [main] INFO org.hibernate.connection.DriverManagerConnectionProvider - using driver: org.hsqldb.jdbcDriver at URL: jdbc:hsqldb:hsql://localhost
781 [main] INFO org.hibernate.connection.DriverManagerConnectionProvider - connection properties: {user=sa, password=****}
1140 [main] INFO org.hibernate.cfg.SettingsFactory - RDBMS: HSQL Database Engine, version: 1.9.0
1140 [main] INFO org.hibernate.cfg.SettingsFactory - JDBC driver: HSQL Database Engine Driver, version: 1.9.0
1203 [main] INFO org.hibernate.dialect.Dialect - Using dialect: org.hibernate.dialect.HSQLDialect
1219 [main] INFO org.hibernate.transaction.TransactionFactoryFactory - Using default transaction strategy (direct JDBC transactions)
1219 [main] INFO org.hibernate.transaction.TransactionManagerLookupFactory - No TransactionManagerLookup configured (in JTA environment, use of read-write or transactional second-level cache is not recommended)
1219 [main] INFO org.hibernate.cfg.SettingsFactory - Automatic flush during beforeCompletion(): disabled
1219 [main] INFO org.hibernate.cfg.SettingsFactory - Automatic session close at end of transaction: disabled
1219 [main] INFO org.hibernate.cfg.SettingsFactory - JDBC batch size: 15
1219 [main] INFO org.hibernate.cfg.SettingsFactory - JDBC batch updates for versioned data: disabled
1219 [main] INFO org.hibernate.cfg.SettingsFactory - Scrollable result sets: enabled
1219 [main] INFO org.hibernate.cfg.SettingsFactory - JDBC3 getGeneratedKeys(): enabled
1219 [main] INFO org.hibernate.cfg.SettingsFactory - Connection release mode: auto
1219 [main] INFO org.hibernate.cfg.SettingsFactory - Default batch fetch size: 1
1219 [main] INFO org.hibernate.cfg.SettingsFactory - Generate SQL with comments: disabled
1219 [main] INFO org.hibernate.cfg.SettingsFactory - Order SQL updates by primary key: disabled
1219 [main] INFO org.hibernate.cfg.SettingsFactory - Order SQL inserts for batching: disabled
1219 [main] INFO org.hibernate.cfg.SettingsFactory - Query translator: org.hibernate.hql.ast.ASTQueryTranslatorFactory
1234 [main] INFO org.hibernate.hql.ast.ASTQueryTranslatorFactory - Using ASTQueryTranslatorFactory
1234 [main] INFO org.hibernate.cfg.SettingsFactory - Query language substitutions: {}
1234 [main] INFO org.hibernate.cfg.SettingsFactory - JPA-QL strict compliance: disabled
1234 [main] INFO org.hibernate.cfg.SettingsFactory - Second-level cache: enabled
1234 [main] INFO org.hibernate.cfg.SettingsFactory - Query cache: disabled
1234 [main] INFO org.hibernate.cfg.SettingsFactory - Cache region factory : org.hibernate.cache.impl.NoCachingRegionFactory
1234 [main] INFO org.hibernate.cfg.SettingsFactory - Optimize cache for minimal puts: disabled
1234 [main] INFO org.hibernate.cfg.SettingsFactory - Structured second-level cache entries: disabled
1250 [main] INFO org.hibernate.cfg.SettingsFactory - Echoing all SQL to stdout
1250 [main] INFO org.hibernate.cfg.SettingsFactory - Statistics: disabled
1250 [main] INFO org.hibernate.cfg.SettingsFactory - Deleted entity synthetic identifier rollback: disabled
1250 [main] INFO org.hibernate.cfg.SettingsFactory - Default entity-mode: pojo
1250 [main] INFO org.hibernate.cfg.SettingsFactory - Named query checking : enabled
1359 [main] INFO org.hibernate.impl.SessionFactoryImpl - building session factory
1797 [main] INFO org.hibernate.impl.SessionFactoryObjectFactory - Not binding factory to JNDI, no JNDI name configured
1812 [main] INFO org.hibernate.tool.hbm2ddl.SchemaExport - Running hbm2ddl schema export
1812 [main] INFO org.hibernate.tool.hbm2ddl.SchemaExport - exporting generated schema to database
1812 [main] INFO org.hibernate.tool.hbm2ddl.SchemaExport - schema export complete
Hibernate: insert into EMP (EMP_ID, EMP_NAME) values (null, ?)
Hibernate: insert into EMP (EMP_ID, EMP_NAME) values (null, ?)
Hibernate: insert into EMP (EMP_ID, EMP_NAME) values (null, ?)
Hibernate: select employee0_.EMP_ID as EMP1_0_, employee0_.EMP_NAME as EMP2_0_ from EMP employee0_
John
Paul
Bill
Updating emp3....
Hibernate: select employee0_.EMP_ID as EMP1_0_0_, employee0_.EMP_NAME as EMP2_0_0_ from EMP employee0_ where employee0_.EMP_ID=?
Hibernate: update EMP set EMP_NAME=? where EMP_ID=?
Deleting emp2....
Hibernate: select employee0_.EMP_ID as EMP1_0_0_, employee0_.EMP_NAME as EMP2_0_0_ from EMP employee0_ where employee0_.EMP_ID=?
Hibernate: delete from EMP where EMP_ID=?
List employees....
Hibernate: select employee0_.EMP_ID as EMP1_0_, employee0_.EMP_NAME as EMP2_0_ from EMP employee0_
John
Michael

Check if the database schema is created and the data is inserted into the EMP table or not. Simply open a new command prompt, go to the hsqldb installed directory and type the following command.
java -cp ./lib/hsqldb.jar org.hsqldb.util.DatabaseManager
The dialog box as shown below pops up

and here select Type as "HSQL Database Engine Server" and click Ok.You see the HSQL Database Manager window as shown below, type the SQL as shown and press execute button. The result shown depicts data existing in the database.

One can exit from the database by typing 'shutdown' and hitting Execute button.

How is ANT Property Task used?

2009-10-08T04:41:00.000-07:00

In order to to set the Ant properties, the <property> task is used. Once property value is set, it cannot be changed. It means they are immutable.In order to set a property to a specific value, the name and value pair is used.

Example

<property name="project.name" value="IQJava"/>

If you want to set a property to a location then name/location assignment is used.
To use the properties surround them with ${}.

Example

<property location="destination" name="dest.dir"/>
<property name="war.dir" location="${dest.dir}/${project.name}"/>

A build.xml as shown in following code box displays how effectively property tasks can be used within a build.xml:

<project basedir="." default="all">
    <property name="gensrc.dir" value="gen_src"/>
    <property name="release.dir" value="release"/>
    <property name="src.dir" value="../src"/>
    <property name="lib.dir" value="../externals/lib"/>
     <property name="class.dir" value="classes"/>
    <property name="class.dir.lib" value="${class.dir}/lib"/>
    <property name="class.dir.src" value="${class.dir}/src"/>
    
    <import file="one-jar-ant-task.xml"/> 
    <!-- Deletes the directories and files....-->
    <target name="clean">
        <delete dir="${gensrc.dir}"/>
        <delete dir="${class.dir}"/>
        <delete>
            <fileset dir="${lib.dir}" >
                <include name="**/xyz.jar"/>
            </fileset>
            <fileset dir="${release.dir}" >
                <include name="**/abc.jar"/>
            </fileset>
        </delete>    

    </target>
    <!-- Prepare the Directories needed for code generation -->
    <target name="prepare">
        <mkdir dir="${class.dir}"/>
        <mkdir dir="${gensrc.dir}"/>
        <mkdir dir="${class.dir.lib}"/>
        <mkdir dir="${class.dir.src}"/>
    </target>
    
    <!-- Compile the source code available in src folder -->
    <target name="compilesrc">
        <javac srcdir="${src.dir}" destdir="${class.dir.src}" target="1.4" source="1.4"
            debug="off" deprecation="on" optimize="off" encoding="iso-8859-1">
            <classpath >
                 <fileset dir="${lib.dir}" includes="**/*.jar"/>
            </classpath>
        </javac>
        <copy todir="${class.dir.src}">
            <fileset dir="${src.dir}" includes="*.properties"/>
        </copy>
    </target>

    <!-- Generate the lib jar file -->
    <target name="lib">
        <jar manifest="manifest.mf" destfile="${lib.dir}/xyz.jar" includes="**/*.class" basedir="${class.dir.lib}" />
    </target>
</project>

How to integrate ANT tool with Eclipse IDE?

2009-10-08T03:21:00.000-07:00

ANT Eclipse IDE(latest edition of Eclipse IDE is Galileo) integration is a very simple process as summarized in following steps:

1. As a first step, create a Java Project in Eclipse IDE.

2. Associate a build.xml with this project and ensure you put this XML at the same location as shown in package structure in Eclipse IDE :
(Click images to enlarge)

The code of build.xml is as given below:

<?xml version="1.0" ?> 
<project name="IQJava" default="execute">

    <target name="init" depends="clean">
        <mkdir dir="build/classes" />
    </target>

    <target name="compile" depends="init">
        <javac srcdir="src" destdir="build/classes" />
    </target>
    
    <target name="execute" depends="compile">
        <java classname="com.iqjava.ant.AntExample" classpath="build/classes" />
    </target>

    <target name="clean">
        <delete dir="build" />
    </target>
    
</project>

3. Run this build XML

4. The output of this execution will look like as given below:

What is ANT and how can one configure it?

2009-10-07T09:38:00.000-07:00

ANT is a Java based build tool and helps in automating whole of build process of a Java project.
ANT uses an XML build file and by default it looks for a build file named build.xml from the directory it has been executed.

A build.xml contains several targets e.g. creating or deleting directory structure, post compilation creation of jar or ear files, extracting/unzipping jar/ear files etc.One target can depend upon one or more targets and it can contain one or more tasks.

One can download Apace Ant 1.7.1 from here.Once that is done, extract it any of your local drive. Set the system variables as follows:

ANT_HOME =D:\apache-ant-1.7.1 (Here I have extracted the ANT ZIP at D drive)
PATH = %ANT_HOME%\bin

To ensure proper installation of ANT, go to command prompt and execute the command "ant - version", you will see the installed ant version.

The execution of ANT file is done from the directory where build.xml resides and simply typing ant command on console and hit enter will start the execution of build file.

The build.xml looks like as given below:
<?xml version="1.0" ?>

<project name="IQJava" default="compress">

    <target name="compile">
        <javac srcdir="com/iqjava/log4j"/>
        <echo> Compilation Complete! </echo>
    </target>
    
    <target name="compress" depends="compile">
            <jar destfile="IQJava.jar" basedir="." includes="*.class" />
            <echo> Building .jar file Complete! </echo>
    </target>

</project>

In the build.xml,<project> element is the root element, name attribute of this represents the name of the project.

<target> element can exist multiple times within project element and each one of them represents a single stage. In the above build.xml, we have compile target element which contains two tasks, one - <echo> and the other <javac> which builds java files.

The other target element 'compress' is dependent upon compile target element. It creates a jar file which includes all the .class files in current directory.

The echo tasks just display messages on console.

How do you configure log4j with XML?

2009-10-05T08:29:00.001-07:00

This configuration of log4j with XML consists of following files:

a.XMLLog4jExample.java
b.log4j.xml

XMLLog4jExample.java

package com.iqjava.log4j;

import org.apache.log4j.Logger;
import org.apache.log4j.xml.DOMConfigurator;

public class XMLLog4jExample {
    static final Logger logger = Logger.getLogger(XMLLog4jExample.class);
    

    public static void main(String[] args) {
        DOMConfigurator.configure("log4j.xml");
        logger.debug("This is a debug message");
        logger.info("This is an info message");
        logger.warn("This is a warn message");
        logger.error("This is an error message");
        logger.fatal("This is a fatal message");

    }
}

log4j.xml looks like:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j='http://jakarta.apache.org/log4j/'>
    <appender name="CA" class="org.apache.log4j.ConsoleAppender">
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-4r [%t] %-5p %c %x - %m%n" />
        </layout>
    </appender>
    <root>
        <level value="debug" />
        <appender-ref ref="CA" />
    </root>
</log4j:configuration>

Here goes the output of the program:

0    [main] DEBUG com.iqjava.log4j.XMLLog4jExample  - This is a debug message
2    [main] INFO  com.iqjava.log4j.XMLLog4jExample  - This is an info message
2    [main] WARN  com.iqjava.log4j.XMLLog4jExample  - This is a warn message
2    [main] ERROR com.iqjava.log4j.XMLLog4jExample  - This is an error message
2    [main] FATAL com.iqjava.log4j.XMLLog4jExample  - This is a fatal message

Eclipse project structure is depicted as in diagram given below:

How to log different modules in different log files?

2009-10-02T09:35:00.000-07:00

Logging messages from different modules in different log files are commonly expected in a project.One can create as many loggers specific to different modules/packages inside the log4j properties file.

As for instance, we want to log workflow related log messages into a file named workflow.log while services related logs into a file named services.log.

The log4j.properties file will describe two seperate FileAppenders and each of them is associated with individual package.The log4j.properties file as shown below depicts two FileAppenders:

log4j.rootLogger=DEBUG

# WorkflowFileAppender - logs messages in the workflow.log file.
log4j.appender.WorkflowFileAppender=org.apache.log4j.FileAppender
log4j.appender.WorkflowFileAppender.File=workflow.log
log4j.appender.WorkflowFileAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.WorkflowFileAppender.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

# ServicesFileAppender - logs messages in the services.log file.
log4j.appender.ServicesFileAppender=org.apache.log4j.FileAppender
log4j.appender.ServicesFileAppender.File=services.log
log4j.appender.ServicesFileAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.ServicesFileAppender.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

log4j.logger.com.iqjava.workflow=,WorkflowFileAppender 
log4j.logger.com.iqjava.services=,ServicesFileAppender

Here the root logger is set as 'DEBUG' which is just for information purpose, and not necessary.We have not set any logger level with individual file appenders. They both have been left blank so that rootLogger level would be inherited.We can surely change that if we want.

The code snippet contains two java files:

1. WorkflowExample.java

package com.iqjava.workflow;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

public class WorkflowExample {

    static Logger logger = Logger.getLogger(WorkflowExample.class);

    public static void main(String[] args) {

        PropertyConfigurator.configure("log4j.properties");
        logger.debug("Here goes the debug message");
        logger.error("Here goes the error message");
        logger.fatal("Here goes the fatal message");
        logger.info("Here goes the info message");
        logger.warn("Here goes the warn message");

    }

}

2.ServicesExample.java

package com.iqjava.services;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

public class ServicesExample {
    
    static Logger logger = Logger.getLogger(ServicesExample.class);

    public static void main(String[] args) {

        PropertyConfigurator.configure("log4j.properties");
        logger.debug("Here goes the debug message");
        logger.error("Here goes the error message");
        logger.fatal("Here goes the fatal message");
        logger.info("Here goes the info message");
        logger.warn("Here goes the warn message");

    }

}

If the individual java appenders are executed then output of workflow.log and services.log will look like as given below:

3.workflow.log

0    [main] DEBUG com.iqjava.workflow.WorkflowExample  - Here goes the debug message
33   [main] ERROR com.iqjava.workflow.WorkflowExample  - Here goes the error message
33   [main] FATAL com.iqjava.workflow.WorkflowExample  - Here goes the fatal message
33   [main] INFO  com.iqjava.workflow.WorkflowExample  - Here goes the info message
34   [main] WARN  com.iqjava.workflow.WorkflowExample  - Here goes the warn message

4.services.log

0    [main] DEBUG com.iqjava.services.ServicesExample  - Here goes the debug message
1    [main] ERROR com.iqjava.services.ServicesExample  - Here goes the error message
1    [main] FATAL com.iqjava.services.ServicesExample  - Here goes the fatal message
2    [main] INFO  com.iqjava.services.ServicesExample  - Here goes the info message
2    [main] WARN  com.iqjava.services.ServicesExample  - Here goes the warn message

If you want to change the logger level for these file appenders, you can always do that in log4j.properties file.

Log4j Configuration With properties file

2009-09-27T05:37:00.000-07:00

Log4j configuration can be done either using an XML or a properties file externally. This makes your code independent of logging related steps to be followed in your code, so no ongoing source code modifications.

All you require to achieve that are logger, appender and layout. The logger object is used to do logging, appender decides where you want to append logging messages, to a console or to a file and finally layout decides on format, the way you want logging messages to be logged.

In the previous post, where BasicConfigurator.configure() is used, the default appender ConsoleAppender and layout PatternLayout are in use.

First of all the contents of log4j.properties file looks like:

log4j.rootLogger=ERROR, CA

log4j.appender.CA=org.apache.log4j.ConsoleAppender

log4j.appender.CA.layout=org.apache.log4j.PatternLayout
log4j.appender.CA.layout.ConversionPattern=%-1r [%t] %-5p %c %x - %m%n

And now the ExampleLog4j.java file:

package com.iqjava.log4j;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

public class ExampleLog4j {


    static final Logger logger = Logger.getLogger(ExampleLog4j.class);
    
    public static void main(String[] args) {
        
        PropertyConfigurator.configure("log4j.properties");
        logger.debug("Here goes the debug message");
        logger.error("Here goes the error message");
        logger.fatal("Here goes the fatal message");
        logger.info("Here goes the info message");
        logger.warn("Here goes the warn message");
    }
}

To make things simpler for you, here is a snapshot from my Eclipse Galileo project:

The log4j levels follow the following order.
DEBUG
INFO
WARN
ERROR
FATAL

As the code level mentioned in .properties file is ERROR, it displays ERROR and FATAL messages only in result displayed of the code. If the code level would have been DEBUG then, all the messages would have been displayed on the console.

The result of the code looks like as given below:

0 [main] ERROR com.iqjava.log4j.ExampleLog4j  - Here goes the error message
2 [main] FATAL com.iqjava.log4j.ExampleLog4j  - Here goes the fatal message

What is Log4j and how can it be configured?

2009-09-27T02:34:00.000-07:00

Log4j is a Java based open source logging service by Apache which is available with no cost to the public.The latest edition at the time of writing this post is log4j 2.0 for logging services designed for Java 5 and later.

The insertion of logging comments help in better management of debugging of code specially if the application is distributed and enterprise in nature. The proper usage of logger levels namely DEBUG, INFO, WARN, ERROR and FATAL can help developers analyzing proper functioning of the code.

A simple log4j configuration is explained with a code sample given below, here important is that log4j runtime jar(log4j-1.2.15.jar) is included in the classpath of your application in order to execute the following code:

package com.iqjava.log4j;

import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Logger;

public class ExampleLog4j {


    static final Logger logger = Logger.getLogger(ExampleLog4j.class);
    
    public static void main(String[] args) {
        BasicConfigurator.configure();
        logger.debug("Here goes the debug message");
        logger.error("Here goes the error message");
        logger.fatal("Here goes the fatal message");
        logger.info("Here goes the info message");
        logger.warn("Here goes the warn message");
    }
}

The output of the above code looks as given below:

0 [main] DEBUG com.iqjava.log4j.ExampleLog4j  - Here goes the debug message
2 [main] ERROR com.iqjava.log4j.ExampleLog4j  - Here goes the error message
2 [main] FATAL com.iqjava.log4j.ExampleLog4j  - Here goes the fatal message
2 [main] INFO com.iqjava.log4j.ExampleLog4j  - Here goes the info message
2 [main] WARN com.iqjava.log4j.ExampleLog4j  - Here goes the warn message

The numbers in the beginning of the output represents time elapsed from the beginning of the execution of the code in milliseconds, thread name, logger level and then log message.

The other logging configuration using log4j is with properties or XML file.Watch out for the next post, it will be related to that.

Velocity With XML

2009-09-23T07:34:00.000-07:00

In this post, a code snippet describing a basic integration of XML with Velocity framework. Please ensure all runtime jar files associated with Velocity and Xerces XML parser are in your build path.

The following files are part of this code snippet;

1.XMLVelocityExample.java
2.xml.vm
3.book.xml

Here goes the Java code i.e. XMLVelocityExample.java:

import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;

import org.jdom.Document;

import org.jdom.input.SAXBuilder;

import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import java.io.Writer;


public class XMLVelocityExample {
    public XMLVelocityExample(String templateFile) {
        Writer writer = null;

        try {
            Velocity.init();

            SAXBuilder builder;
            Document root = null;

            try {
                builder = new SAXBuilder("org.apache.xerces.parsers.SAXParser");
                root = builder.build("book.xml");
            } catch (Exception exception) {
                exception.printStackTrace();
            }

            VelocityContext context = new VelocityContext();
            context.put("root", root);

            Template template = Velocity.getTemplate(templateFile);

            writer = new BufferedWriter(new OutputStreamWriter(System.out));
            template.merge(context, writer);
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (writer != null) {
                try {
                    writer.flush();
                    writer.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        XMLVelocityExample test = new XMLVelocityExample("xml.vm");
    }
}

xml.vm looks like:

#macro ( recursive $xml $indent )     
#if( $xml.getChildren().size() > 0 )
$indent <$xml.getName()> 
#foreach ($child in $xml.getChildren() ) 
#recursive( $child "$indent  " )
#end
$indent </$xml.getName()>
#else
$indent <$xml.getName()>
$indent    $xml.getTextTrim()
$indent </$xml.getName()>
#end
#end

#set($i = " ")

Here goes document tree with a recursive Velocity macro :

#recursive( $root.getRootElement() $i )


Now accessing data directly :

email : $root.getRootElement().getChild("properties").getChild("author").getChild("email").getText()
last name :  $root.getRootElement().getChild("properties").getChild("author").getChild("name").getChild("fullname").getText()

book.xml file looks like:

<?xml version="1.0" encoding="UTF-8"?>
<document>
  <properties>
    <author>
    <email>sunnyg@sunnyg.com</email>
    <name>
       <lastname>
        Gavaskar
       </lastname>
       <first>
        Sunil
       </first>
       <fullname>Sunil Gavaskar</fullname>
        
    </name>
    </author>
    <title>
       Sunny Days
    </title>
  </properties>

  <body>
    Sunny within a body.
  </body>
</document>

This is how output looks like:

Here goes document tree with a recursive Velocity macro :

  <document> 
    <properties> 
      <author> 
        <email>
           sunnyg@sunnyg.com
        </email>
        <name> 
          <lastname>
             Gavaskar
          </lastname>
          <first>
             Sunil
          </first>
          <fullname>
             Sunil Gavaskar
          </fullname>
        </name>
      </author>
      <title>
         Sunny Days
      </title>
    </properties>
    <body>
       Sunny within a body.
    </body>
  </document>


Now accessing data directly :

email : sunnyg@sunnyg.com
last name :  Sunil Gavaskar

EMailing Through Velocity Framework

2009-09-17T06:50:00.000-07:00

Velocity Framework helps in creating a pre-formatted template based email response mechanism. The code snippet in this post elaborates how one can use this feature from Velocity framework.

While running this application, ensure you have all required Velocity framework related library classes/jars in you project build path.

Here the code is distributed in following java files:

1.EMailer.java
2.EMailClient.java
3.Customer.java
4.Order.java

Template file:
5.email.vm

Here goes:

1. EMailer.java

import java.io.StringWriter;
import java.util.HashMap;
import java.util.Properties;

import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader;


public class Emailer
{
    /**
     * Field description
     *
     * @since 1.0
     */
    VelocityEngine engine = new VelocityEngine();

    /**
     * Constructor description.
     *
     * @throws Exception Description
     */
    public Emailer() throws Exception
    {
        configure(engine);
    }

    /**
     * "Sends" (actually writes to System.out for demonstration  purposes) a
     * receipt e-mail for the specified order.
     *
     * @param order Description
     */
    public void sendReceipt(Order order) throws Exception
    {
        Template template = engine.getTemplate("email.vm");
        VelocityContext context = createContext();
        context.put("order", order);

        StringWriter writer = new StringWriter();
        template.merge(context, writer);
        writer.close();
        System.out.println("To: " + order.getCustomer().getEmail());
        System.out.println("Subject: " + context.get("subject"));
        System.out.println(writer.getBuffer());
    }

    /**
     * Configures the engine to use classpath to find templates
     *
     * @param engine Description
     */
    private void configure(VelocityEngine engine) throws Exception
    {
        Properties props = new Properties();
        props.setProperty(VelocityEngine.RESOURCE_LOADER, "classpath");
        props.setProperty("classpath." + VelocityEngine.RESOURCE_LOADER +
                          ".class",
                          ClasspathResourceLoader.class.getName());
        engine.init(props);
    }
    /**
      * Creates a Velocity context and adds a formatter tool
      * and store information.
      */
     private VelocityContext createContext() {
       VelocityContext context = new VelocityContext();
       context.put("formatter", new Formatter());

       HashMap store = new HashMap();
       store.put("name", "Amazon.com Bookstore");
       store.put("url", "http://amazon.comm");

       context.put("store", store);
       return context;
     }
}

2.EMailClient.java

import java.util.ArrayList;


public class EmailClient {
    /**
     * Example usage of Emailer functionality
     *
     * @param args Description
     */
    public static void main(String[] args) throws Exception {
        Emailer emailer = new Emailer();

        ArrayList lineItems = new ArrayList();
        lineItems.add(new Item("Thinking in Java", 24.05f));
        lineItems.add(new Item("Core Java Volume I", 34.30f));

        Customer customer = new Customer("John", "Brown", "jb@gmail.com");

        emailer.sendReceipt(new Order(customer, lineItems));
    }
}

3.Customer.java

public class Customer
{

    private String firstName;

    private String lastName;

    private String email;

    /**
     * Constructor 
     */
    public Customer(String firstName, String lastName, String email)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
    }
    public String getFirstName()
    {
        return firstName;
    }
    public String getLastName()
    {
        return lastName;
    }
    public String getEmail()
    {
        return email;
    }
    public String getId()
    {
        return "" + firstName.charAt(0) + lastName.charAt(0);
    }
}

4. Order.java

import java.util.Date;
import java.util.Iterator;
import java.util.List;



public class Order
{
    private Customer customer;
    private List lineItems;
    private String orderNumber;

    public Order(Customer customer, List lineItems)
    {
        this.customer = customer;
        this.lineItems = lineItems;

        orderNumber = customer.getId() + "-" + new Date().getTime();
    }

    public Customer getCustomer()
    {
        return customer;
    }

    public List getLineItems()
    {
        return lineItems;
    }

    public String getOrderNumber()
    {
        return orderNumber;
    }

    public float total()
    {
        float total = 0;

        for (Iterator iterator = lineItems.iterator(); iterator.hasNext();)
        {
            Item item = (Item)iterator.next();
            total += item.getCost();
        }

        return total;
    }
}

5. email.vm file

 #set ($customer = ${order.customer})
 #macro(currency $amount)${formatter.currency($amount)}#end
 #macro(pad $string)${formatter.pad($string, 30)}#end
 #macro(description $item)#pad($item.description)#end

 ${customer.firstName},

 Thank you for your purchase.
 Your order number is ${order.orderNumber}.

 #pad("Description") Cost
 #foreach ($item in ${order.lineItems})
 #description($item) #currency(${item.cost})

 #end

 #pad("Total") #currency($order.total())


 Visit us again at ${store.url}!

 #set ($subject="${store.name} receipt")

This is how the result looks like:

To: jb@gmail.com
Subject: Amazon.com Bookstore receipt

 John,

 Thank you for your purchase.
 Your order number is JB-1253195547000.

 Description                    Cost
  Thinking in Java               $24.05
  Core Java Volume I             $34.30

 Total                          $58.35

 Visit us again at http://amazon.comm!

Objects and Java Building Object-Oriented, Multi-Threaded Applications with Java by Bill Venners

2009-09-08T03:14:00.000-07:00

A book which is in HTML format and slight draw back is that you have to be online to go through the contents of the book or you just store all HTML pages of this book.If that does not bog you much, a fascinating book by Bill Venners who has also written 'Inside Java Virtual Machine'.

No PDF is available.

Read online...

Sams Teach Yourself Java 2 in 24 Hours

2009-09-08T03:13:00.000-07:00

Sams Teach Yourself Java in 24 Hours is a step-by-step tutorial that teaches someone with no previous programming experience how to create simple Java programs and applets.

No PDF is available.

Read online...

Thinking In Java by Bruce Eckel,Ist,IInd and IIIrd Editions

2009-09-08T03:12:00.002-07:00

Thinking in Java is a printed version of Bruce Eckel's online materials that provides a useful perspective on mastering Java for those with previous programming experience. The author's take on the essence of Java as a new programming language and the thorough introduction to Java's features make this a worthwhile tutorial.

Thinking in Java begins in a beautiful way to keep an interest of its readers like a suspense thriller...:-), with the author's reflections on why Java is new and better. The author outlines his thoughts on why Java will make you a better programmer, without all the complexity. The book is better when he presents actual language features.

PDF is available.

Download...

The Java Tutorial IIIrd Edition

2009-09-08T03:12:00.001-07:00

Whether you're taking a class or learning on the job, The Java Tutorial, Third Edition, is a hands-on guide that lets you quickly become proficient with the Java programming language. Written by members of the Java Software team at Sun Microsystems, the book uses an interactive approach to help you learn the Java platform by example.
Since it's first online release in 1995, the material in The Java Tutorial has been updated continuously to reflect reader feedback and new releases of the Java platform. This third edition has been thoroughly updated to cover v1.3 of the Java Platform, Standard Edition, as well as preceding versions as early as JDK 1.1.

No PDF is available.

Read online...

The Java Tutorial Continued

2009-09-08T03:10:00.000-07:00

The Java Tutorial Continued provides accurate, up-to-date coverage of features added to the original core Java platform. Written by the experts, The Java Tutorial Continued employs a hands-on, self-paced, example-driven approach. This book concentrates on JDK 1.2 APIs but also contains the information you need to use the JDK 1.1 versions of the APIs.

The tutorial books, including this book and The Java Tutorial, are the definitive programmers' guides to the core JDK. This book covers a broad spectrum of JDK features, including:

-The Java Collections Framework
-Internationalization
-2D Graphics and Sound
-JavaBeans(tm)
-IDL (Interface Definition Language), which adds CORBA capabilities to the Java platform
-Database connectivity through the JDBC(tm)
-RMI (Remote Method Invocation)
-Security
-JNI (Java Native Interface)
-Reflection
-Other topics such as JAR, the Standard Extension Mechanism, and Servlets

No PDF is available.

Read online...

Introduction To Programming Using Java

2009-09-08T03:09:00.000-07:00

A free, on-line textbook on introductory programming, which uses Java as the language of instruction. This book is directed mainly towards beginning programmers, although it might also be useful for experienced programmers who want to learn something about Java. It is certainly not meant to provide complete coverage of the Java language.

The fifth edition covers Java 5.0. You will find many Java applets on the web pages that make up this book, and many of those applets require Java 5.0 or higher to function. Earlier editions, which covered earlier versions of Java, are still available; see the preface for links.

PDF version of this book is available.

Download...

A Java GUI Programmer's Primer

2009-09-08T03:06:00.000-07:00

This book contains an introduction to the systematic development of Graphical User Interfaces (GUIs) using the Java environment. It does not attempt to introduce the Java language and it is assumed that the reader has some familiarity with Object Oriented Development (OOD) and its practical expression in Java.

Read online...

The Java Swing Tutorial

2009-09-08T03:05:00.000-07:00

The Java(tm) Tutorial, is a guide to using the new Swing components, which are provided by the Java Foundation Classes (JFC). Developed and co-written by the lead writer on the Swing team, this book covers everything you need to know to write GUIs that use Swing components. The JFC Swing Tutorial uses a task-oriented, example-driven approach to introduce you to fundamental concepts and applications.
Designed to be read either cover-to-cover or as a quick reference, this book explains how to use each Swing component, perform layout, do basic drawing, and convert 1.1 AWT programs to Swing. This book covers Swing 1.1.1, which is available both as an extension to JDK(tm) 1.1 and as a core part of the Java(R) 2 Platform.

Read Online...

Java Look And Feel Design Guidelines

2009-09-08T02:36:00.000-07:00

Java Look and Feel Design Guidelines, second edition, provides essential information for anyone involved in creating cross-platform GUI (graphical user interface) applications and applets in the JavaTM programming language. In particular, this book offers design guidelines for software that uses the Swing classes together with the Java look and feel.
This revised and expanded edition contains a collection of toolbar graphics, lists of terms localized for European and Asian languages, and an appendix on look and feel switching. New and revised guidelines are provided throughout, and new sections discuss smooth interaction, the use of badges in button graphics, and revised standards for window titles.

Read Online...

Inside the Java Virtual Machine by Bill Venners

2009-09-08T02:35:00.002-07:00

Inside the Java Virtual Machine explains Java's architecture and internals, and several Java APIs closely tied to the virtual machine, to Java programmers. Reading this book will help you gain a deeper understanding of Java technology, and in the process, help you become more effective at Java programming.

Read online...

The Java Virtual Machine Specification

2009-09-08T02:35:00.001-07:00

In The Java Virtual Machine Specification, Second Edition, Sun's designers of the Java virtual machine provide comprehensive coverage of the Java virtual machine class file format and instruction set. In addition, the book contains directions for compiling the virtual machine with numerous practical examples to clarify how it operates in practice. The book also demonstrates the Java virtual machine's powerful verification techniques.

Read online...

Object-Oriented Software Composition

2009-09-08T02:34:00.001-07:00

Object-Oriented Software Composition adopts the viewpoint that object-oriented technology is essentially about composing flexible software applications from software components. Although object-oriented languages, tools and methods have come a long way since the birth of object-oriented programming, the technology is not yet mature. This book presents the results of a series of research projects related to object-oriented software composition that were carried out within the Object Systems Group at the University of Geneva, or by partners in collaborative research projects, during a period of about ten years.

This book is available in PDF format to download...

Download...

Processing XML with Java

2009-09-08T02:31:00.000-07:00

A book by Elliotte Rusty Harold, is a complete tutorial about writing Java programs that read and write XML documents. This is the most comprehensive and up-to-date book about integrating XML with Java (and vice versa) you can buy. It contains over 1000 pages of detailed information on SAX, DOM, JDOM, JAXP, TrAX, XPath, XSLT, SOAP, and lots of other juicy acronyms. This book is written for Java programmers who want to learn how to read and write XML documents from their code.

Read Online...

Enterprise JavaBeans™

2009-09-08T02:29:00.002-07:00

A book by Richard Monson-Haefel on Enterprise Java Beans from O'Reilly publishers.

Read online...

EJB Design Patterns

2009-09-08T02:29:00.001-07:00

EJB Design Patterns goes beyond high-level design pattern descriptions into critical EJB-specific implementation issues, illustrated with source code implementations. The book contains a catalog of twenty advanced EJB patterns and provides strategies for mapping application requirements to patterns-driven design, J2EE development best practices, and a collection of EJB tips and strategies, and other topics such as Build-System best practices using Ant, JUnit testing strategies, using Java Data Objects (JDO) as an alternative to entity beans, and more.

Download...

Mastering Enterprise JavaBeans Third Edition

2009-09-08T02:26:00.000-07:00

Mastering EJB is updated for EJB2.1 and also features new chapters on security and Web services integration. The book is about EJB concepts, methodology and development. This book also contains a number of advanced EJB topics, giving you a practical and real world understanding of the subject. By reading this book, you will acquire a deep understanding of EJB.

Download...

One of the best selling book Mastering EJB is now in its fourth edition and has been updated for EJB 3.0. This edition features chapters on session beans and message-driven beans, EJB-Java EE integration and advanced persistence concepts. In-depth coverage of the Java Persistence API and using POJO entities with EJB is also included. By reading this book, you will acquire a deep understanding of EJB 3.0.

Download...

Designing Web Services with the J2EE 1.4 Platform: JAX-RPC, SOAP, and XML Technologies

2009-09-08T02:25:00.000-07:00

Since Web services is a major extension of the Web computing model, developers need to understand the Web computing model technology itself as well as how to effectively implement a Web service with the J2EE technologies. Java BluePrints provides an effective way to combine both into one easy-to-follow, step-by-step examination of the architecture and implementation of the Java Adventure Builder Reference application.

Read Online...

Java Web Services Tutorial

2009-09-08T02:24:00.000-07:00

Java™ Web Services Tutorial is a guide to developing Web applications with the Java Web Services Developer Pack (Java WSDP). The Java WSDP is an all-in-one download containing key technologies to simplify building of Web services using the Java 2 Platform.

Download PDF...

Jakarta-Struts Live

2009-09-08T02:23:00.000-07:00

This book is offered by TheServerSide.com and SourceBeat Publications in collaboration.It talks about Jakarta Struts technology with lucid examples in detail.

Download...

EBook: Java Testing and Design

2009-09-08T02:00:00.000-07:00

This book,from Unit Testing to Automated Web Tests, teaches you a fast and efficient method to build production-worthy, scalable, and well performing Web-enabled applications. The techniques, methodology, and tools presented in this book will enable developers, QA technicians, and IT managers to work together to achieve unprecedented productivity in development and test automation.

Download...

EBooks On Java, JavaEE Technologies

2009-09-07T09:35:00.000-07:00

Jakarta-Struts Live

Java Web Services Tutorial

Designing Web Services with the J2EE 1.4 Platform: JAX-RPC, SOAP, and XML Technologies

Mastering Enterprise JavaBeans Third Edition

EJB Design Patterns

Enterprise JavaBeans™

Thinking In Patterns by Bruce Eckel

Processing XML With Java

Object-Oriented Software Composition

The Java Virtual Machine Specification

Inside the Java Virtual Machine by Bill Venners

Murach Java Sevlets And JSP

Java Servlet Programming by O'Reilly

Core Servlets and JavaServer Pages by Marty Hall, I Edition

More Servlets and JavaServer Pages

Servlets and JavaServer Pages: The J2EE Technology Web Tier

Java Look And Feel Design Guidelines

The Java Swing Tutorial

Java Foundation Classes in a Nutshell: A Deskop Quick Reference

A Java GUI Programmer's Primer

Java AWT Reference

Introduction To Programming Using Java

Java Tutorial Continued

The Java Tutorial IIIrd Edition

Thinking In Java by Bruce Eckel,Ist,IInd and IIIrd Editions

Sams Teach Yourself Java 2 in 24 Hours

Objects and Java Building Object-Oriented, Multi-Threaded Applications with Java by Bill Venners

Java™ in a Nutshell: A Deskop Quick Reference.

Exploring Java

Java Fundamental Classes Reference

Java Testing and Design

Miscellaneous EBooks

2009-09-07T09:31:00.002-07:00

Introduction to Computer Science using Java

The Java Language Specification

Advanced Programming for the Java 2 Platform

Data Structures and Algorithms with Object-Oriented Design Patterns in Java

How To Become A Hacker by Eric Steven Raymond

Java Resources on IBM Redbook

Design and Implement Servlets, JSPs, and EJBs for IBM WebSphere Application Server

1000 Java Tips!

O'Reilly Open Books

Securing Java

How to Think Like a Computer Scientist Java Version

Bleeding at the Keyboard :A Guide to Modern Programming with Java

Java an Object First Approach

Java™ Security.

Java™ Distributed Computing

Collection APIs Related Interview Questions

2009-08-30T00:56:00.000-07:00

You may like to read following posts before going through the list of questions mentioned on Collections APIs in this post:

Questions on java.util.* and java.io.* package

Core Java Questions With Short Answers

Q. How will you synchronize a collection?
A. The code sample given below elaborates on synchronization of various collection objects:

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;


public class CollectionSynchronization {
public static void main(String[] args) {
Collection collection = Collections.synchronizedCollection(new ArrayList());
List list = Collections.synchronizedList(new ArrayList());
Set set = Collections.synchronizedSet(new HashSet());
Map map = Collections.synchronizedMap(new HashMap());
SortedMap sortedMap = Collections.synchronizedSortedMap(new TreeMap());
SortedSet sortedSet = Collections.synchronizedSortedSet(new TreeSet());
}
}

Q. Why is it advisable to override hashCode() method as well, when equals() method is overridden?
A. When equals() method is overridden, then each object must have same hashcode for pair of objects which have equals() method overridden.If the .hashCode() method of your custom class doesn't work the same way your .equals() method works, the results of your code will be erroneous.

Q. If a collection object has duplicate values then how will you convert into a collection having unique values?
A. Here goes the listing:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;


public class CollectionExample {
public static void main(String[] args) {
 ArrayList list = new ArrayList();
 list.add("Apple");
 list.add("Apple");
 list.add("Apple");
 list.add("Mango");
 list.add("Guvava");
 list.add("Pineapple");
 Set set = new TreeSet(list);
 Iterator iterator = set.iterator();
   while (iterator.hasNext()) {
  String str= (String)iterator.next();
  System.out.println(""+str);
  }

 

}
}

Output:

Apple
Guvava
Mango
Pineapple

Q. How will you address the scenario given below to decide on collection object to work with:
- Multiple keys with multiple values
- Multiple keys with single value
- Single key with multiple values
- Single key with single value
A. In the given scenario, HashMap will be the best choice. As long as the keys are unique, one can enter multiple values in an ArrayList and associate this with a key inside HashMap and retrieve those multiple values from unique key.

Q.How to get a TreeSet from a TreeMap?
A.The possibility of creating a TreeSet from the keyset of TreeMap.Check the example given as below:

import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;


public class CollectionExample {
public static void main(String[] args) {
    TreeMap treeMap = new TreeMap();
    treeMap.put("1", "Apple");
    treeMap.put("2", "Mango");
    treeMap.put("3", "Guvava");
    treeMap.put("4", "Banana");
    treeMap.put("5", "Grapes");

    Set set = new TreeSet(treeMap.keySet());
    Iterator iterator = set.iterator();

    while (iterator.hasNext()) {
        String str = (String) iterator.next();
        System.out.println("" + str);
    }
}
}

Output:
1
2
3
4
5

Q.How a TreeSet different from HashSet?
A.One line answer is : TreeSet contains-> Unique and Ordered/Sorted values(as per natural order or based on Comparator implemented logic).It is backed by TreeMap.

While HashSet contains-> Unique values but not Ordered/Sorted

The example given below will explain the same:

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;


public class CollectionExample {
  public static void main(String[] args) {
      Set hashSet = new HashSet();
      Set treeSet = new TreeSet();

      addElements(hashSet);
      addElements(treeSet);

      System.out.println("HashSet:"+hashSet);
      System.out.println("TreeSet"+treeSet);
  }

  private static void addElements(Set aTreeSet) {
      aTreeSet.add(Integer.valueOf(6));
      aTreeSet.add(Integer.valueOf(2));
      aTreeSet.add(Integer.valueOf(2));
      aTreeSet.add(Integer.valueOf(4));
      aTreeSet.add(Integer.valueOf(7));
      aTreeSet.add(Integer.valueOf(7));
      aTreeSet.add(Integer.valueOf(1));
  }
}

The Output is:

HashSet:[2, 4, 6, 1, 7]
TreeSet[1, 2, 4, 6, 7]

Q.A practical problem, I want to choose a collection object which allows me to put only unique values inside it and in the same order as it is coming out of a database, here data from the database can contain duplicate values.What collection object will you choose?
A.Choose:


LinkedHashSet uniqueData = new LinkedHashSet(dataFromDB);

Q. What is the initial capacity of Vector?
A. 10. Try out the code given below:


import java.util.Set;
import java.util.Vector;


public class CollectionExample {
   public static void main(String[] args) {
       Vector vector = new Vector();
       int capacity = vector.capacity();
       System.out.println("Capacity:" + capacity);
   }
}

The Output is:

Capacity:10

An article on JavaWorld on Collections' API

Various Popular Configuration Management Tools Used In Enterprise Level IT projects.

2009-08-29T09:40:00.000-07:00

SVN(Subversion)
Subversion is a stable,open source, free to use and extensible version control system.Subversion was originally designed to be a better CVS, so it has most of CVS's features.SVN project was initiated by CollabNet in the year 2000.SVN is easily integrated with existing IDEs like Eclipse,JDeveloper,NetBeans,Visual Studio.SVN more details can be captured on their official website, check this out here.

IBM Rational Synergy
As IBM has taken over Telelogic and erstwhile CM Synergy is now IBM Synergy.The IBM® Rational® Synergy environment is a task-based software development and delivery solution that brings together global, distributed development teams on a unified change, configuration and release management platform.

Visual Source Safe is source control software from Microsoft.It was initially developed by a company called One Tree Software. During that time MS had relatively unstable Source code version tool named Delta and they eventually acquired One Tree Software and went on to modify the 16-bit version of SourceSafe 3.1.The result was version 4.0 of
Visual SourceSafe (VSS), which was a 32-bit edition of the product and was released sometime around 1995.

IBM Rational Clearcase
An SCM tool which helps in controlling and tracking source code changes. Clearcase can support big projects configuration needs where team size can go upto thousands of developers.It comes in two flavors: UCM and base Clearcase. UCM is an out of box configuration management solution while base Clearcase provides a basic infrastructure upon which UCM is built. It can run over various platforms like Windows, AIX, zOS, Solaris etc.

There are more versioning tools available which are open source like Aegis,ArX,Bazaar etc.

I have listed most of the confoguration management tools that I actively used in this post, which you may like to explore.

Short Questions On Java

2009-07-04T04:53:00.000-07:00

Q.If I am extracting data from database which is have redundancy and not sorted, which collection object will you choose in order to make this data unique and sorted?
A. TreeSet
An Example

import java.util.*;

public class TreeSetExample {

public static void main(final String[] args) {
TreeSet treeset = new TreeSet();
treeset.add("Lincoln");
treeset.add("Clinton");
treeset.add("Obama");
treeset.add("Obama");
treeset.add("Regan");
treeset.add("Washington");
treeset.add("Bush");
System.out.println("TreeSet with Prez:");
Iterator iterator = treeset.iterator();
while (iterator.hasNext()) {
Object object = iterator.next();
System.out.println(object);
}
}
}

The Out put of the program is:

TreeSet with Prez:
Bush
Clinton
Lincoln
Obama
Regan
Washington

Q. Is GC a high priority thread?
A. No, it is low priority thread.

Q.Does Java supports multi-dimensional arrays?
A.No, Java supports nested arrays only.

Q. What will a following division return? float value= 200.00/0.0.
A. NAN(Not a Number) instead of Exception

Q. Can local vairables be declared as static ?
A. No, local variables cannot be static. Only member variables be declared as static.

Q.What are the special cases in which serialization cannot happen?
A. There are following scenarios in which serialization cannot happen:

a. Variables are transient.
b. Variables are static.
c. Base class variables are serialized if class itself is serializable.

Q.When a class or interface can be unloaded ?
A. A class or interface can be unloaded if and only if the classloader is unreachable. Though in case of system classes, they may never be unloaded as bootstrap class loader is always reachable.

Q.What are the different states that an object can be in during its life cycle?
A.An object goes through most of the following states during its life cycle, from creation to the point when all the resources associated with it are released for reuse:

-Created-In use (strongly reachable)

-Invisible

-Unreachable

-Collected

-Finalized

-Deallocated

Q.Where do we use enums and how are they different from public,static,final constants?
A. If there are constants which are unlikely to change in future then they can be defined using enum. Take four directions EAST,WEST,NORTH,SOUTH for example which will never change and is best suited while defined in enum.
Moreover public static final constants are not typesafe. While enums can be used for switch case scenarios, are serializable.


public enum Direction  {     EAST, WEST, NORTH, SOUTH  }

The detailed answer can be found here.

Interview Questions on Java 5 - Part II

2009-05-26T06:19:00.000-07:00

- What are Generic types and how it helps developers?
Generic types are now part of J2SE 5.0. At the first instance one will see them in action is the Collections API. The Collections API provides common functionality like LinkedLists, ArrayLists and HashMaps that can be used by more than one Java type. The next example uses the 1.4.2 libraries and the default javac compile mode.


ArrayList list = new ArrayList();
list.add(0, new Long(10));
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();

The user of a generified API has to simply declare the type used at compile type using the <> notation. No casts are needed and in this example trying to add a String object to an Integer typed collection would be caught at compile time.

Hence Generic types enable an API designer to provide common functionality that can be used with multiple data types and which also can be checked for type safety at compile time.
- What are Annotations and how are they used?

Annotations have no direct impact on the execution of the code.They provide additional data about the program which is not part of the program itself.

Annotations are used for:

-Preferred over comments as documentation of a program is made quite flexible.
-Program's declarations of classes, fields, methods, and other program elements.
-Can be used by the compiler to detect errors or suppress warnings.
-Compiler-time and deployment-time processing where annotation information can be processed to generate code, XML files, and so forth.
—Some annotations are available to be examined at runtime.

The annotation appears first, often (by convention) on its own line, and may include elements with named or unnamed values:


@Author(
  name = "Victor Hugo",
  date = "9/20/2009"
)
class SampleClass() { }

or

@SuppressWarnings(value = "unchecked")
void sampleMethod() { }
If there is just one element named "value," then the name may be omitted, as in:
@SuppressWarnings("unchecked")
void sampleMethod() { }
Also, if an annotation has no elements, the parentheses may be omitted, as in:
@Override
void mySuperMethod() { }

- What is Enhanced for-loop feature?

It is a popular feature introduced with in Java SE 5.0.
There is always a backward compatibility with old style of for looping. The changed was of for-loop in Java 5 look something like the following:


The newer form:
for (String name : nameArray) {
    System.out.println("Name: " + name);
}

- What is static import feature in Java 5?
- Enables imported static members to be referred as if class declares them within to be used. So no more need of qualifying static class name to access the methods defined in the class. Here is an example as given below:


import static java.lang.Math.*;

public class SampleStaticImport 
{
   public static void main( String args[] ) 
   {
      System.out.println(sqrt(625.0 ) );
      System.out.println(sin( 90.0 ) );
   }  
}

- What are Varargs?

The varargs functionality allows multiple arguments to be passed as parameters to methods. It requires the simple ... notation for the method that accepts the argument list and is used to implement the flexible number of arguments required for printf.They are most fondly used in core APIs including reflection, message formatting, and the new printf facility in Java 5. Read an article here on varargs for more details.

Interview Questions on Java 5

2009-04-14T02:28:00.000-07:00

- What are the new features in Java 5 as compared to its earlier versions?

Java 2 Platform Standard Edition 5.0 was a major feature release. The following features were introduced in 5.0 since previous major release and that was 1.4.0.

Summary:
- Performance Enhancements
a.Garbage collection performance enhancements
b.Introduction to StringBuilder
c.Java 2D technology
d.Image I/O - Performance and memory

- Language Specific Features:
a.Generics
b.Enhanced for Loop
c.Autoboxing/Unboxing
d.Typesafe Enums
e.Varargs
f.Static Import
g.Metadata (Annotations)

The list is long which you can catch in detail at following URL:

Java 5 New Features

- What is Autoboxing/Unboxing and what are its advantages?

The conversion from primitive types to wrapper types objects is automated. This facility eleminates pain of manual conversion from primitive to wrapper types.
Boxing converts primitive values to objects of corresponding wrapper types.
Unboxing converts objects of wrapper types to values of corresponding primitive types.

Assignment Conversions on boolean and numeric types.
boolean boolValue = true;
byte b = 2;
short s = 2;
char c ='2';
int i = 2;

// Boxing
Boolean boolReference = boolValue;
Byte bReference = (byte) 4;
Short sReference = (short) 4;
// both byte and short type casting is to be done as int cannot be assigned to Byte and Short respectively
Character cReference = '4';
Integer iReference = 4;

// Unboxing
boolean boolValue1 = boolReference;
byte b1 = bReference;
short s1 = sReference;
char c1 = cReference;
int i1 = iReference;

The usage of autoboxing/unboxing can be found:
- In the if statement, condition can be Boolean.
- In the switch statement, the switch expression can be Character, Byte, Short or Integer.
- In the while, do-while and for statements, the condition can be Boolean.

More questions in my next post on Java 5.

What are different System Contracts in JCA?

2009-03-21T06:48:00.001-07:00

System Contracts

An application server and an EIS collaborate to keep all system-level mechanisms, such as transactions, security, and connection management, transparent from the application components.

The JCA Version 1.0 defines the following set of system-level contracts between an application server and EIS, which enables outbound connectivity to an EIS:

A Connection Management contract that lets an application server pool connections to an underlying EIS, and lets application components connect to an EIS. This leads to a scalable application environment that can support a large number of clients requiring access to EISs

A Transaction Management contract between the transaction manager and transactional access to EIS resource managers. It lets an application server use a transaction manager to manage transactions across multiple resource managers.

A Security contract that enables a secure access to an EIS. This contract provides support for a secure application environment, which reduces security threats to the EIS and protects valuable information resources managed by the EIS.

JCA Version 1.5 defines the following set of system-level contracts between an application server and EIS, which enables inbound connectivity from an EIS:

A Transaction Inflow contract that allows a resource adapter to propagate an imported transaction to an application server. This contract also allows a resource adapter to flowin transaction completion and crash recovery calls initiated by an EIS, and ensures that the ACID properties of the imported transaction are preserved.

A Message Inflow contract that allows a resource adapter to asynchronously deliver messages to message endpoints residing in the application server independent of the specific messaging style, messaging semantics and messaging infrastructure used to deliver messages. It provides pluggability for message providers (Java Message Service (JMS), Java API for XML Messaging (JAXM), and so on) to any J2EE technology-compatible application server via a resource adapter.

JCA Version 1.5 also defines the following set of system-level contracts between an application server and EIS, which enables resource adapter lifecycle management and thread management:

A Lifecycle Management contract that allows an application server to manage the lifecycle of a resource adapter. This contract provides a mechanism for the application server to bootstrap a resource adapter instance during its deployment or application server startup, and to notify the resource adapter instance during its undeployment or during an orderly shutdown of the application server.

A Work Management contract that allows a resource adapter to do work (monitor network endpoints, call application components, etc.) by submitting Work instances to an application server for execution.

What is J2EE Connector Architectcure?

2009-03-21T05:33:00.000-07:00

J2EE Connector Architecture(JCA) is a standard architecture that targets integration of new web based application with existing heterogeneous Enterprise Information Systems(EIS), enhancing Business to Business(B2B) transactions.While various application servers extend their containers and support connectivity to heterogeneous EISs and enterprise tools and Enterprise Application Integration (EAI) vendors provide tools and frameworks to simplify the EIS integration task.

Under JCA hood:

- JCA enables application components deployed on the application server to access the underlying EIS systems.

- JCA provides an EIS vendor specific standard resource adapter for its EIS.

- The resource adapter plugs into an application server, providing connectivity between the EIS, the application server, and the enterprise application.(Look at the diagram given below)

- An application server vendor has to extend its system to support the JCA which assures of seamless connectivity to multiple EISs.

- One can have multiple resource adapters. They all are are pluggable into an application server and each unique resource adapter corresponds to a particular type of EIS. An EIS vendor has to provide just one standard resource adapter which has the capability to plug in to any application server that supports the JCA.

Launch of Java,Java EE and Open Source Technology Discussion Forum

2008-10-04T04:24:00.000-07:00

A new forum has been created by me today where you all can give me a feedback on this blog and more.The name of this forum is "Java,Java EE and Open Source". Moreover once you all will register here, this will open a new vista to share our thoughts,knowledge and ideas on Java,Java EE and Open source technologies and frameworks. I have created few topics, to start with, e.g. Open Source Technologies and Frameworks,Java EE Topics,Java Programming . You may create a topic as per your choice where you want to create some buzz and interact with like minded.

Let us create an active community using this forum to discuss general topics related to the Java programming language.

Don't forget to provide me inputs where should I focus in order to improve my blog to serve better to my readers.

I invite you to register on this forum today.Please feel free to get in touch with me if in case you have any queries.

The Power Of Java

2008-10-03T09:55:00.000-07:00

Recently stumbled upon this ad campaign of Java technology from Sun on Metacafe. I found it simply impressive.Enjoy!!

What are various myths surrounding Services Oriented Architecture?

2008-09-28T07:43:00.001-07:00

Some myths that are surrounding Services Oriented Architecture are:

- Any software system which is using webservices is aligned to SOA.
- SOA is a downloadable software to solve any complex business problem.
- SOA is easy to implement.
- SOA will solve all your complex business problems forever and can be
seen as a panacea.
- SOA is nothing but integrating existing enterprise level
applications to paint a big business picture.
- SOA is expensive and time consuming.
- All constituent components of SOA are reusable.
- SOA is Enterprise Application Integration(EAI).
- SOA is not aligned to any standards.
- SOA roll out cannot happen without new infrastructure support.
- SOA based solution is not performance conscious.

In next few posts I will try to dig each of the above listed myths
centering SOA in detail.

What is Test Driven Development?

2008-09-09T06:32:00.001-07:00

Test-Driven Development (TDD) is a software development technique :

- where all test cases covering all functionalities and/or enhancements of a system are written first iteratively.
- the production code must pass all tests implemented.
- software is refactored to accommodate changes.

TDD makes availability of tests before actual development. This approach ensures quality of deliverable resulting in least rework in code. If any change request or enhancement comes then already existing test case coverage ensures sanctity of all existing functionalities of software. TDD is emphasized as a method of designing software, not merely a method of testing.TDD is also linked with test-first programming concepts like Extreme Programming.TDD helps great deal to improve software quality from legacy code that was not developed in this way.

TDD requires an automated unit test, defining requirements of the code, all positive and negative scenarios which your code has to undergo are written before the code itself. These tests contain assertions that are either true or false. When these tests are run then it gives rapid confirmation of correct behavior as the code evolves and is refactored. In Java world unit testing mechanism is introduced using JUnits and mocking the expected result or behaviour using JMock framework.JMock is a library that supports TDD of Java code with mock objects.These mock objects help you design and test the interactions between actual objects in your programs.

What is webhosting and how it works?

2008-09-06T12:27:00.000-07:00

Web hosting service is a type of Internet hosting service.It allows individuals and organizations to provide their own website accessible via the World Wide Web. Web hosts are companies that provide space on a server they own for use by their clients as well as providing Internet connectivity, typically in a data center. These web hosts can also provide data center space and connectivity to the Internet for servers they do not own to be located in their data center, called colocation.

A simple website may be representing a personal web space which may be consisted of few normal HTML pages, while more complex commercial organizations would need more then just showing web pages to its end users.It demands more comprehensive application development platforms like Java,PHP,Ruby on Rails,Cold Fusion and ASP.NET and many more web bases technologies and database support.Web hosting will also provide interface to its end users to control and monitor a website's or portal's various factors like visitors details, most visited pages, webpages meeting revenue targets etc.

What is JAXP ?

2008-08-08T08:52:00.000-07:00

JAXP represents set of APIs which are used to parse, transform, validate and query XML documents.JAXP is used seamlessly in XML based applications' integration ,web publishing and e-commerce solutions. JAXP supports a number of different industry-wide standards to process XML documents.

JAXP 1.3 is Production Quality in J2SE 5.0, and the latest JAXP 1.4 is Production Quality Development in Java SE 6. You can find more details of JAXP here.

JAXP supports following standards:

-JAXP 1.4 specification
-SAX 2.0.2
-StAX 1.0, JSR 173
-XML 1.0, XML 1.1
-XInclude 1.0
-DOM Level 3 Core, DOM Level 3 Load and Save
-W3C XML Schema 1.0
-XSLT 1.0
-XPath 1.0

One can capture some sample codes of JAXP usage at Sun Developer's website and Sun Java website.

More useful links on XML and related technologies can be found here.

All Posts On Java Coding Standards

2008-08-04T08:45:00.000-07:00

As most of my readers demanded, here is this post summarizes series of posts that I did on Java coding standards,best practices and guidelines. This is a quick reference for all readers who are looking for a consolidated information in a single post as the direct reference for same will be found on my main page.
Here we go:

Layout(I)
Layout(II)
Documentation
Naming Conventions
Exception Handling,Logging and JUnits
Best Practices

Java Coding Standards: Best Practices

2008-08-04T07:56:00.001-07:00

This is my last post in series of Java coding standards posts. It focuses on best practices or dos and don'ts while coding. I am sure these good practices once observed while writing code will make your Java code consistent and in most cases bugs free. If you make these practices a habit, it ensures better code quality,less rework and robustness of one's application.

Here goes the list:

·Put each class in a separate file (except where a private class is used exclusively by one class only and also when using inner classes and anonymous classes).

·Use relative path with respect to the location of the execution directory.

·No Compiler warnings / Exceptions should be allowed in the final source code.

·Declare all class variables in one place (at the top of the class).

·Initialize the class/instance variables in default constructor or with declaration.

· Initialize all local variables where they are declared.

·Put declaration only at the beginning of the blocks. Don't wait to declare the variables to until where they are first used (one exception is indexes to loops).

·Avoid using an object to access a class (static) variable or method. Use a class name instead.

·Numerical constants (literals) should not be coded directly, except for –1, 0 and 1, which can appear in a for loop as counter values.

·Avoid assigning several variables to the same value in a single statement. It is hard to read.

·Do not use embedded assignments in an attempt to improve run-time performance. It is the job of the compiler. Example:
d = ( a = b + c) + f; //Avoid
Should be written as
a = b + c;
d = a + f;

· Generally prefer long to int, and double to float. But use int for compatibility with standard Java constructs and classes.

·Minimize direct internal access to instance variables inside methods. Use protected access and update methods instead.

·Prefer declaring arrays as Type[] arrayName rather than Type arrayName[].

·Ensure that non-private statics have sensible values even if no instances are ever created. Use static initializers if necessary.

·Define return types as void unless they return results that are not accessible otherwise

·Avoid hard coding. If hard coding is inevitable due to functionality, give proper comments.

· Constants specific to a class/module should be part of interfaces related to that domain. All constants must relate to some domain specific grouping. If at all possible the interfaces that define globals should be located with the classes which they would operate on.

·Variables for local use should not be declared global.

·Method Names, variable names, class names should be meaningful.
Give proper names for methods, variables, class names focusing on
Maintainability, Readability.

·Variables should be named in such a way that it conveys the actual usage of thevariable.

·All get methods should return a value.

·All set methods should accept values.

·Vector, Array position specific code should not be present.

·Similar methods/parts of code in different classes should be refactored.

·Code inside a method should exactly serve the purpose.
For example, a method written for validation should not do any focus/tab setting.

·The method/variable should be declared as private if it isn't used outside the current class.

·Avoid NullPointerException by checking the input parameters for null in a method and throwing an IllegalArgumentException with the appropriate message.

·If the code in the constructor is too large, logical parts should be separated out into methods.

·If a particular piece of logic is repeated in a class, make a private static method and move that logic in that. If the logic is shared across different classes, then it should be moved in some utility class.

·Make use of appropriate data structure Collection – unordered objects, List – ordered objects, Set – unique objects, HashMap – unordered key- value pairs, LinkedHashMap – ordered key-value pairs.

·Use inline comments for all complex calculations or business logics.

·Check for unnecessary code like System.out.printlns in the code.

·Avoid using Strings in double quoted form. Declare a local private static final constant variable for that.

·Use a Iterator class for iterating a Collection, List or Set instead of using a for( ; ; ) loop. This would make the code more consistent.

·Implementation should be based on proper abstraction. Use Interfaces and abstract classes for hiding the implementation from the client code.

·Try and identify the immutable attributes of your classes and make them final member variables assigned in the constructor. This can prevent some coding errors.

·Always override hashCode method when you override equals. Failure to do so will result in violation of the general contract for Object.hashCode which will prevent your class from functioning properly with conjunction with all hash-based collections, including HashMap, HashSet and HashTable

·Return zero-length arrays instead of nulls. Can prevent null pointer exceptions or complicated if (results == null) tests.

·Try to avoid returning null from methods. Consider the NULL Object pattern as a replacement for returning Null. E.g create a static final constant class instance to represent an empty/null object. E.g Within the Employee interface public static final Employee NULL = new Employee(); So now the calling client code can test for if (Employee.NULL == result). Leads to clearer code and removes some potential for null pointer issues.

·Refer to objects by their interfaces if appropriate interface exists.

·Choose interfaces over abstract classes. If you know something is going to be a base class, your first choice should be to make it an interface, and only if you're forced to have method definitions or member variables should you change it to an abstract class. An interface talks about what the client wants to do, while a class tends to focus on (or allow) implementation details.

·First make it work, then make it fast. This is true even if you are certain that a piece of code is really important and that it will be a principal bottleneck in your system. Don't do it. Get the system going first with as simple a design as possible. Then if it isn't going fast enough, profile it. You'll almost always discover that "your" bottleneck isn't the problem. Save your time for the really important stuff.

·Watch for switch statements or chained if-else clauses. This is typically an indicator of type-check coding, which means that you are choosing what code to execute based on some kind of type information (the exact type may not be obvious at first). You can usually replace this kind of code with inheritance and polymorphism; a polymorphic method call will perform the type checking for you and allow for more reliable and easier extensibility. For Example-



interface IVehicle{
void drive(Car car);
}

class Car {
// These Car classes could as easily be interfaces, with no impact on the examples.
// members
}
class HondaCar extends Car {
// members
}


class BMWCar extends Car {
// members
}

Good Practice

class Car implements IVehicle {
public void drive(HondaCar car){
// handle standard drive
}
public void drive(BMWCar car){
// handle BMW car
}
}

Bad Practice

class Car implements IVehicle {
public void drive(Car car){

if(car instanceOf HondaCar ) 
// perform HondaCar logic
}

if(car instanceOf BMWCar) 
// perform BMWCar logic
}

}

·From a design standpoint, look for and separate things that change from things that stay the same. That is, search for the elements in a system that you might want to change without forcing a redesign, then encapsulate those elements in classes.

·Keep scopes as small as possible so the visibility and lifetime of your objects are as small as possible.

·A class should only one reason to change. Attempt to keep your classes cohesive. E.g. to only do one thing and model one abstraction.

·Try to understand the Open-Closed principle when designing classes. Classes should be open for extension, but closed for modification. Basically, if you need to open up your classes to add new requirements / functions this is likely to indicate that you have not modeled the domain / abstractions correctly. Interfaces, Abstract base classes are all tools you can use to correctly model and abstract the domain requirements.

·Try to understand the Liskov substitution principle. Ok, nice name – good at the interviews. However, the underlying principle is sound. All subtypes must be substitutable for their base types. If you create subtypes you must ensure that if they are used in the same context as the base class that their behavior is predicable. E.g. in sub classing a type do not change its basic type behavior. Inherit because you are of that type not because you simply need some underlying common behavior.

·If there are no formalized code reviews try to discuss your design concepts and code with other team members. Even if they have the same / less experience than you. Sometimes the act of talking something out load can highlight good and bad elements in your code.

Java Coding Standards:Exception Handling,Logging,JUnits

2008-07-25T23:06:00.001-07:00

At enterprise level writing robust code is essential and test driven development technique is helping one in achieving that. So while you code your business components then writing JUnits in parallel is an essential exercise. This helps in checking all positive and negative scenarios which your code can get exposed to. While putting erroneous conditions, your code will behave erroneously,throwing relevant exceptions at right levels with messages making correct sense where and what went wrong. Besides correct exception handling,ensuring right way of logging errors,debug information and general information is significant from testing your code correctly.This post will focus on exception handling,logging and JUnits related coding standards.

In this post focus is writing/compiling standards required for Exception handling,logging and JUnits coding. I am sure these tips will give you some practical insight to achieve

Exception Handling
- Use runtime exception or extensions of this type. Checked exceptions should be avoided unless they make semantic sense for the interface/method. If not all clients of that component have to handle the checked exception even if there is nothing they can do without other than re throw it. These leads to a lot of messy try catch re throw code.
- Log all exceptions at the boundaries of the application. Exceptions should not be logged at every level they are caught and re-thrown. This can cause a lot of noise in the log files. Exceptions should be caught and logged at the boundaries of the application. E.g Middletier/service delegate level, webservice component level etc. The fact that a sub component throws an exception may not be a critical situation for the calling component. As such exceptions should be "bubbled" up to the top most layer of the application and logged just before the application loses programmatic control e.g to the application server or some other invocation framework (webservices, messaging systems etc).
-If rethrowing an exception ensure that the stack trace from the original exception is propagated to the new exception. E.g. converting from a checked to a runtime exception.


try {
} catch (RealException realException){
throw new RuntimeException(message,realException);
}

Logging
This section lists the practices, which should be followed while using Logging. Following these practices make bug fixing easy.

- Logger variable should always be declared as private static variable. For example
private static final Logger logger = Logger.getLogger(Main.class);
- Use the appropriate message level.
* INFO – For logging successful completion of a process.
* DEBUG – For logging the input and output parameters and understanding the behavior in detail.
* ERROR – For logging the failure messages from exceptions.
- Check whether the logging has been enabled for that severity. E.g

if (logger.isDebugEnabled()){
//log something;
}

- All Exception should be logged in the catch block with ERROR as the message level.

JUnit
This section lists the practices, which should be followed for coding Junit test cases as well as execution of Junits.

- All classes should have a reasonable Junit coverage. To the extent possible all public methods in the class should have one or more corresponding Junit methods. E.g. one positive test method and another negative test method corresponding to a public method. This is just a thumb rule, the no of test methods could even be more. The only exceptions to this rule are getters and setters methods.
- How easy a class is to test depends on how good the underlying design is. Difficult classes to test, which have too many dependencies that need to be resolved or have poor interfaces, may need to be refactored accordingly.
- If the assertEquals () requires a comparison of two Objects, then make a customized assert<ObjectName>Equals() method which carries the assertEquals() on each property of the object with appropriate message.
- When writing a negative test case use the following convention:


                try{
                      class.method();
                       fail(<appropriate message>);
                       }
                 catch(SpecificException ex){
                      // Successful condition
                    }

- For any bug reported during onsite or offshore system/unit testing, new unit test cases must be added Bottom line the test cases must be expanded to test the resolution to a given bug. So I would see at a minimum for each bug raised there should be a test case to replicate the conditions and validate the resolution.

Java Coding Standards:Naming Conventions

2008-07-21T09:27:00.001-07:00

While coding it is significant to stick to naming conventions of the language and Java is also no exception in that.The reason of this practice is to make your code look consistent and easy to comprehend.In most of the situations these conventions are set at organization level but some of them on a broader level are summarized under points given below:
Package
-Capitals should not be used in the packages names.
-Automated unit test cases using frameworks like JUnit should be placed in a parallel package hierarchy in a separate source folder.
-Using the same package naming convention for them would cater to easy testability of complex protected methods

Classes
-Class name should be noun in mixed case, with the first letter upper case and the first letter of any subsequent words capitalized.
-If your class implements as design pattern then a the pattern as a suffix to the class name e.g <ClassName>Singleton, <ClassName>Decorator, <ClassName>Factory, <ClassName>Builder,<ClassName>Strategy.

Methods
-Method names should be verbs or verb phrases, with first letter in lower case and first letter of every subsequent word in uppercase. Underscore should not be used in method names. Some examples of conforming names are
createUserGroup()

Variables
-Variables should have names that are nouns, noun phrases, or abbreviations for nouns. Names of fields that are not final should have the first letter in lower case and first letter of the subsequent words in uppercase. Underscore should not be used in variable names. Some examples of conforming names are logger, logManager
-One –character local variable or parameter names should be avoided, except for temporary and looping variables, or where a variable holds an undistinguished value of a type.
-Variables should not have the same name as one in a super class.
-Collection classes, such as vectors and hashes should always be pluralized Member variables. E.g deviceNames, deviceNamesVector etc.
-All member variables should be prefixed with f. E.g. fMyMemberVariable. Use of the this.variable definition should be avoided for scope resolution between local and class level variables.

Constants
-The names of constants in interface types and final variables of class types should be a sequence of one or more words, acronyms, or abbreviations, all uppercase, with words separated by underscore "_" characters. All constants should public/private static final.
-Some examples of conforming names are
MIN_VALUE
MAX_VALUE

Exceptions
-Exceptions should follow the same naming conventions as those for naming classes; they must additionally be suffixed by the word Exception. For example, if more than one Exceptionvariable is in scope exception variables should be suffixed by Ex. Normal IDE behavior is to create an initial Exception variable in a try catch block as simply (e). This is acceptable. If more than one variable is required then these should be distinguished using the naming model defined below.

-The exception variables should be prefixed by some acronym. Commonly used ones are locEx for LocalizedException, sqlEx for SQLException, ioEx for IOException.

JUnits
Test must be used in the name of the junit as suffix.
Example:
Class name: UserLogon
Junit Test Class name: UserLogonTest

Learning Eclipse IDE

2008-07-05T02:22:00.000-07:00

Recently stumbled upon some good tutorials on Eclipse IDE.I just thought of sharing with you all who are new to Eclipse and want to try their hands on it.

An Eclipse-Java Tutorial for Total Beginners:

An Eclipse-Java Tutorial on Introducing Persistence:

An Eclipse Tutorial on Using Debugger:

There are more Java learning video tutorials from Eclipse tutorials portal which can be downloaded from the following URL:

Eclipse and Java Video Tutorials

In case of any broken link please report to me so that I can make relevant changes.