Hot cup with JAVA Technologies!!

Quick View - Java 7 Features

2010-11-19T17:54:00.000-08:00

1. Up-gradation to class loader architecture to avoid deadlocks in non-hierarchical class-loader topologies.
2. A method has been added to free the underlying resources, such as open files, held by a URLClassLoader.
3. A lightweight fork/join framework, flexible and reusable synchronization barriers, transfer queues, a concurrent-reference HashMap, and thread-local pseudo-random number generators.
4. Upgraded to supported version of Unicode 6.0 for more from internationalization.
5. the java.util.Locale class to support IETF BCP 47 and UTR 35 now.
6. Now there will be a two separate locale for user and user-interface.
7. New APIs for filesystem access, scalable asynchronous I/O operations, socket-channel binding and configuration, and multicast datagrams
8. New fully functional file system provider NIO.2 for zip/jar archiving.
9. JDBC upgraded to 4.1 and Rowset to 1.1
10. XML stack is upgraded to new stable version for more on web.
11. JSR 292 providing support for dynamically typed language.

OutOfMemoryError: PermGen space while reloading webapp in tomcat

2010-11-18T06:13:00.000-08:00

This annoying error of PermGen space OOMs when reloading the webapp in tomact is because in tomcat the class loader only loads the classes and this class loader and loaded classes are never garbage collected. Each time you reload your webapp, copies of classes will be added to memory, basically the permanent heap space used by tomcat. This eventually makes tomcat run out of memory to further carry out operation.

This is common and can happen with other containers also until unless in some version the owner have made changes to take care of this. Try reloading the application again and again until unless your container cry of Out of Memory Error. What we can do in such a situation is to restart the container which basically clean up the heap and load the application again.

Additionally try no putting your JDBC and commons jar in the WEB-INF. Instead you can put them in the TOMCAT-HOME/common/lib folder because these are already bootstrapped by tomcat. If you face issue of 'No suitable driver' Exception after placing your jdbc jar in tomcat common/lib, try adding you jndi db definition in context.xml like
<\Context path="/test" reloadable="true" debug="1">
<\Resource name="jdbc/db" auth="Container" type="javax.sql.DataSource" maxActive="30" maxIdle="3"
maxWait="10000" username="testing" password="testing" driverClassName="net.sourceforge.jtds.jdbc.Driver" url="jdbc:testdburl;lastupdatecount=true" />

equals and hashcode

2010-10-31T07:00:00.000-07:00

Object equals will just compare references and hashcode is native which always return difference integer even if objects are same but different instances. So of you override equals and not hashcode for any object being used as a key in hashmap, then I will not get value corresponding to key because it wont be able to find hashcode for new instance of key. As it will look into the wrong bucket (new bucket) if I override hashcode and not equals, even there I wont be able to get the value because I can find the bucket but objects equal check references which will be different for stored object and my key object (new instance of old key object).

DB Connection class

2010-10-31T06:52:00.000-07:00

DriverManager.getConnection (url, user, pwd).getClass().getName().equals("java.sql.Connection") = false

This is false because left hand side will return a class of the underlying database connection class i.e. oracle.jdbc.driver.OracleConnection in case of oracle. So this will be a instance of java.sql.Connection but can not be equal.

Cut rectangular cake half

2010-10-31T06:45:00.000-07:00

Given a rectangular cake with rectangular piece removed (any size, any orientation), how would you cut remainder cake in two equal haves with one straight cut of knife.

Cut the piece horizontally

Serializable Singleton

2010-10-31T06:30:00.000-07:00

In a class write below code to prevent singleton class from losing its behavior if you make it serializable.

protected Object readResolve(){
return singletonObj;
}

Deserialization creates another object instance, so to avoid that situation this needs to be done.

Java Threading

2010-10-31T05:36:00.000-07:00

public static void myMethod(){
    synchronized(this){
        //do stuff
    }
}

This will not get a class level lock, many threads can enter this static method of class and with individual object lock can execute code in it.

public static synchronized void myMethod() {
    //do stuff
}
-----is equivalent to-----
public void myMethod(){
    synchronized(MyClass.class){
         //do stuff
    }
}

In both the case, threads will obtain a class level lock butt there will just be a difference of timing for how long lock is being obtained.

1. Threads that synchronize on the same object will block each other. Threads that synchronize on different objects will not.
2. A static synchronized method and a non-static synchronized method will not block each other, ever. The static method locks on a class instance while non-static method locks on this instance these actions do not interfere with each other at all.
3. Threads calling static synchronized methods in the same class will always block each other - they all lock the same class instance.
4. Threads calling non-static synchronized methods in the same class will only block each other if they are invoked using same instance.
5. A thread can acquire more that one lock. A thread can enter a synchronized method, acquiring a lock and then immediately invoke a synchronized method on a different object, acquiring that locak as well. A thread acquires a lock and then attempts to call a synchronized method on the same object, no problem because thread already have lock of this object.
6. If a class has both synchronized and non-synchronized methods, multiple threads can still access the class's non-synchronized methods.

Thread Join-
If you have a thread B that can't do its work until another thread A has completed its work, then you want B to join thread A.
This means that thread B will not become runnable until thread A has finished.
Thread t = new Thread();
t.start();
t.join();
This code take currently running thread and joins it to the end of thread t. Current thread become runnable after thread t is no longer alive.

Fibonacci

2010-10-31T04:55:00.000-07:00

public void fibonacci(){
    int curr = 1;
    int prv = 0;
    int prvHolder=0;
    for(int c = 0; c <= 30; c++){
        Sysout (curr);
        prvHolder=prv;
        prv=curr;
        curr += prvHolder;
    }
}

Prime factorization

2010-10-31T04:50:00.000-07:00

public void primeFactor (int num){
List factors = new ArrayList();
    for (int i = 2; i <= n; i++){
        while (n % i == 0){
            factors.add(i);
            n /= i;
        }
    }
}

Greatest Common Divisor

2010-10-31T04:47:00.000-07:00

public int gcd (int p, int q){
    if (q=-=0){
return p;
   }
   return gcd (q, p%q);
}

Annotation

2010-10-31T04:45:00.000-07:00

It releives java developer from sumbersome configuration. Declarative programming style - programmer says what should be done & tools emit the code to do it. These are meta-tag information.

DisplayTag

2010-10-31T04:43:00.000-07:00

<display:table export="true" is="data" name="sessionScope.UserForm.forbesList" requestURI="/userAction.do" poagesize="10" >
<display:column property="rank" title="Rank" sortable="true" />
....
</display:table>

export - to export table data as excel, csv or xml
sortable - makes column sortable by providing clickable title
pagesize - for pagination

Hibernate mapping

2010-10-31T04:01:00.000-07:00

Event table (LocationID - FK, EventID - PK)
Attendee Table (AttendeeID - PK)
SpeakerID (SpeakerID - PK, EventID - FK)
Event_Attendee (EventID, AttendeeID)

An event can have many attendee and speakers. An attendee can attend many events. One location can also have many events.

<hibernate-mapping>
<class name="Event" table="events">
        <id name="id" column="uid" type="long">
             <generator class="increment">
        </id>
        <property name="name" type="string" length="100"/>
        <many-to-one name="location" column="locationID" class="Location"/>
        <set name="speakers" cascade="all">
              <key column="eventID"/>
          <one-to-many class=Speakers"/>
        </set>
        <set name="attendee" table="event_attendee" cascade="all">
              <key column="eventID"/>
          <many-to-many column="AttendeeID" class=Attendee"/>
        </set>
    </class>
</hibernate-mapping>

Find circular linked list

2010-10-31T03:44:00.001-07:00

Start with two pointers. Increase one ptr by 1 and second ptr by 2. If they meet then list is circular.

Reverse a string

2010-10-31T03:42:00.000-07:00

To reverse a string in java, tokenize the string and starting printing from len-1 to 0.

Summing column value in SQL

2010-10-31T03:39:00.001-07:00

To sum the columns' of a record in table use '+' operator like -
select col1+col2 from table test

Do you work with presentation

2010-09-25T04:30:00.001-07:00

If you work with powerpoint presentation you must see this clip to get best out of it.

http://www.youtube.com/watch?v=lpvgfmEU2Ck&feature=player_embedded

Macrodef in Ant Script

2010-08-14T08:46:00.000-07:00

Very frequently we invoke the same task repeatedly with a small variance. Mostly, we parameterize the variance, then such tasks can be refactored and invoked with different argument repeatedly, just like a Java method call that is invoked with different arguments. Prior to Ant 1.6, the and tasks came in handy. For most part these two core tasks are similar, except the task allows invoking targets in another build file whereas restricted the invoked targets to the local file.
The point to consider is re-parses the build file and re-runs the targets, even though all that changes from one call to another is, in most cases, just the parameter values. Since Ant 1.6 a smarter alternative is available: the task. It offers all the benefits of without the overhead of reparsing. It offers additional features such as ordered execution of nested tasks using the construct. Optional attributes can be supplied with default values, and the caller may omit them.

Sample Code

For further information - Ant - Macrodef

Clustering

2010-08-01T06:47:00.004-07:00

J2EE application server vendors define a cluster as a group of machines working together to transparently provide enterprise services (support for JNDI, EJB, JSP, HttpSession and component failover, and so on). They leave the definition purposely vague because each vendor implements clustering differently. At one end of the spectrum rest vendors who put a dispatcher in front of a group of independent machines, none of which has knowledge of the other machines in the cluster. In this scheme, the dispatcher receives an initial request from a user and replies with an HTTP redirect header to pin the client to a particular member server of the cluster. At the other end of the spectrum reside vendors who implement a federation of tightly integrated machines, with each machine totally aware of the other machines around it along with the objects on those machines.

Purpose -
1. Reducing downtime - Another machine in cluster transperently takeover in case of failure of a particular machine.
2. Scalibility - More server can be added to handle the increased users.
3. Spreading load - Different machines in the cluster will be responsible for the indivudual module of the application hence decreasing the load on individual machine.

A cluster is a group of application servers that transparently run your J2EE application as if it were a single entity. To scale, you should include additional machines within the cluster. To minimize downtime, make sure every component of the cluster is redundant.

For More Information - Java World - Clustering

Runtime exception in JSP

2010-08-01T06:47:00.002-07:00

How does JSP handle run-time exceptions?

Runtime exceptions are easy to handle in a JSP application, because they are stored one at a time in the implicit object named exception. You can use the exception object in a special type of JSP page called an error page, where you display the exception's name and class, its stack trace, and an informative message for your user.

We can use the errorPage attribute of the page directive to have uncaught run-time exceptions automatically forwarded to an error processing page. For example:

<\%@ page errorPage="error.jsp" %>

redirects the browser to the JSP page error.jsp if an uncaught exception is encountered during request processing.

Within error.jsp, if you indicate that it is an error-processing page, via the directive:

<\%@ page isErrorPage="true" %>

the Throwable object describing the exception may be accessed within the error page via the exception implicit object.

Note: You must always use a relative URL as the value for the errorPage attribute.

Simply Singleton

2010-08-01T06:47:00.000-07:00

Singleton Design Pattern is the among the most widely used design patterns in IT world. It addresses the problem of creating exactly one instance of a class which can be globally accessible. This instance or object of class is singleton.

Singletons maintain a static reference to the sole singleton instance and return a reference to that instance from a static instance() method.

public class MySingleton {
private static MySingleton instance = null;
protected MySingleton() {
// Exists only to defeat instantiation.
}
public static MySingleton getInstance() {
if(instance == null) {
instance = new MySingleton();
}
return instance;
}
}

public class SingletonInstantiator {
public SingletonInstantiator() {
ClassicSingleton instance = ClassicSingleton.getInstance();
ClassicSingleton anotherInstance =
new ClassicSingleton();
...
}
}

This technique of implementing Singleton is known as lazy loading as the object is instantiated when getInstance() method is called for the first time.

Why constructor is protected?? - First thing first. Protected constructor can be called by subclasses or by other classes in the same package. So keeping the MySingleton and SingletonInstantiator in the same package allows the former class to create instance of singleton class. So what should be done? First, make the constructor of MySingleton private, but then this class can not be subclassed. Second, declare MySingleton as final. Third, put your singleton class in explicit package.

A third interesting point about ClassicSingleton: it's possible to have multiple singleton instances if classes loaded by different classloaders access a singleton. That scenario is not so far-fetched; for example, some servlet containers use distinct classloaders for each servlet, so if two servlets access a singleton, they will each have their own instance.

Fourth, if ClassicSingleton implements the java.io.Serializable interface, the class's instances can be serialized and deserialized. However, if you serialize a singleton object and subsequently deserialize that object more than once, you will have multiple singleton instances.

Finally, and perhaps most important, Example 1's ClassicSingleton class is not thread-safe. If two threads—we'll call them Thread 1 and Thread 2—call ClassicSingleton.getInstance() at the same time, two ClassicSingleton instances can be created if Thread 1 is preempted just after it enters the if block and control is subsequently given to Thread 2. The solution to this is to synchronize the getInstance() method in our MySingleton class or just the block where we are creating the instance to improve performance by locking the object for short time.

For more information -
Java World - Simply Singleton

How to get Remote Machine Name

2010-08-01T06:46:00.001-07:00

In order to get machine name or the computer name of the remote system, the system which is send some http request to your server, you just need to get IP from the request and using that IP and the InetAddress class of java.net package, we can very well get the name of that machine. Here is the code.

public void doPost(HttpServletRequest req, HttpServletResponse res) throws IOException, ServletException{

byte ipAddr[] = {0,0,0,0};
String ipAddress = req.getRemoteAddr();

if(ipAddress != null && !ipAddress.equals("")){
StringTokenizer tokenize = new StringTokenizer(ipAddress,".");

int iLen = tokenize.countTokens();

for(int i = 0 ; i < iLen;i++){
int temp = Integer.parseInt(tokenize.nextToken());
ipAddr[i] = (byte)temp;
}

InetAddress nIpAddress = InetAddress.getByAddress(ipAddr);

if(nIpAddress != null && nIpAddress.isReachable(5000) && nIpAddress.isSiteLocalAddress()){

System.out.println("Servlet - "+InetAddress.getByAddress(ipAddr).getHostName());

req.setAttribute("IP", InetAddress.getByAddress(ipAddr).getHostName());
}

}

Java 1.5 - Nothing un-official about it!!

2010-08-01T06:45:00.003-07:00

Features in Java 1.5

1. For/Each loop
Instead of looping with a numeric index, set a local variable to each item of a collection or array in order.

public void goThis(String[] strArray){
for(String obj:strArray){
System.out.println(obj);
}
}

2. Scanner Class - Scanner class is easily used to read the input from console.

Scanner inputScanner = new Scanner(System.in);
String s = inputScanner.nextLine();
int i = inputScanner.nextInt();
double d = inputScanner.nextDouble();

But you can also attach a Scanner to a File, a Socket, a Process, and more

3. Autoboxing - To insert java primitive into tables, list or anything expecting Object can be done using Java wrappers.

Although its a useful feature of java5 still its a performance hit because -
1. Every insert converts to wrapper type.
2. Every retrieval converts to primitive type

List arrayList = new ArrayList();
int i = 12;
arrayList.add(i);
int num = arrayList.get(0);
arrayList.add(num+1);

4. Varargs - A way to pass any number of a particular type of argument to the method. It becomes an array of that type. It should be te last in the list of arguments like

public static String method (String name, int ... numbers);

Sample code -

public class MathUtils {

public static int min(int ... numbers) {

int minimum = Integer.MAX_VALUE;

for(int number: numbers) {
if (number < minimum) {
minimum = number;
}
}

return(minimum);

}

public static void main(String[] args) {

System.out.printf("Min of 2 nums: %d.%n",min(2,1));
System.out.printf("Min of 7 nums: %d.%n",min(2,4,6,8,1,2,3));

}

Collect all about Garbage Collection

2010-08-01T06:45:00.001-07:00

>>> The purpose of garbage collection is to identify and discard objects that are no longer needed by a program so that their resources can be reclaimed and reused.

>>> An unreachable object is subjected to gc. Unreachable objects are those which can not be referenced.

>>> Garbage collection is also called automatic memory management as JVM automatically removes the unused variables/objects (value is null) from the memory.

>>> Every class inherits finalize() method from java.lang.Object, the finalize() method is called by garbage collector when it determines no more references to the object exists.

>>> In Java, it is good idea to explicitly assign null into a variable when no more in use.

>>> In Java on calling System.gc() and Runtime.gc(), JVM tries to recycle the unused objects, but there is no guarantee when all the objects will garbage collected.

>>> Garbage collection is an automatic process and can't be forced.

>>> gc thread is a dameon thread.

Except exceptions!!

2010-08-01T06:44:00.005-07:00

Exception in layman term is abnormal behaviour of your program. A bunch of things can lead to exceptions, including hardware failures, resource exhaustion, and good old bugs. When an exceptional event occurs in Java, an exception is said to be thrown. The code that’s responsible for doing something about the exception is called an exception handler, and it catches the thrown exception.

>>> Order of catch block matters.

>>> The finally clause is used to provide the capability to execute code no matter whether or not an exception is thrown or caught.

>>> A checked exception is some subclass of Exception (or Exception itself) excluding class RuntimeException and its subclasses, which are forced by compiler to be checked. Example: IOException.
Unchecked exceptions are RuntimeException and any of its subclasses. Class Error and its subclasses also are unchecked. The compiler doesn't force client programmers either to catch the exception or declare it in a throws clause. In fact, client programmers may not even know that the exception could be thrown. Example: ArrayIndexOutOfBoundsException. Errors are often irrecoverable conditions.

>>> Throwable is the base class of Error and Exception.

>>> The throw keyword denotes a statement that causes an exception to be initiated. The throws keyword is a modifier of a method that denotes that an exception may be thrown by the method.

>>> Error's are generally system's error and Excepion are programmer's error.

>>> Finally block get executed whether exception is thrown or not. Even if there is return statement in try block, finally block get executed after the return statement.

Defensive Coding for NPE -
1. If name is null
don't do - if(name.equals("Peter")) - chances to get NPE
do - if("Peter".equals(name))
2. Always return empty collection instead of null like
return Collections.EMPTY_LIST;
3. Always check for null before carrying out operation on the object and define alternate course of action.