Java , J2EE , FLEX

Signs that your code sucks

2009-10-22T06:39:00.000-07:00

Nice read.

Java Inner classes

2009-10-15T06:32:00.000-07:00

Nice Article.

100 GB JVM

2009-10-03T06:33:00.000-07:00

interesting article to read.

Nullness analysis of Java

2009-07-01T02:24:00.000-07:00

Found this tool that helps in nullness analysis of Java.

More details about it in the video

Flex Flip effect

2009-06-15T22:23:00.000-07:00

Found some useful links for flip effect
this and this

LDAP Intro

2009-05-06T04:20:00.000-07:00

LDAP is standardized. The body of LDAP standards, including the network protocols, the directory structure, and the services provided by an LDAP server, are all available in the form of RFCs (Requests For Comments).

LDAP was designed to be a general-purpose directory server. It has not been designed with the purpose of capturing a specific type of data (like telephone numbers or email addresses). Instead, it was designed to give implementers the ability to define—clearly and carefully—what data the directory should store.

Such a generic directory server ought to be able to store many different kinds of information.

Let's continue with our comparison of a directory server and a phone book. A phone book contains a very specific type of information, organized in a very specific way, and designed to fulfil a very specific purpose. Here's an example phone book entry:

Acme Services
123 W. First St.
Chicago, IL 60616-1234
(773) 555-8943 or (800) 555 9834

As mentioned earlier, this sort of directory has specific information, organized in a specific way, designed to fulfill a specific purpose: it is information about how to contact a specific organization (Acme Services) organized in a familiar pattern (address and phone number). And it is designed so that a person, having a particular name in mind, can quickly scan through the directory (which is ordered alphabetically by organization name), and find the desired contact information.

But there are a few things to note about the phone book entry:

* The data is arranged for searching by only one value: the name of the organization. If you should happen to have the phone number of the organization, but not the name, searching the phone book for the matching telephone number in order to ascertain the name would be a taxing, and probably futile task.
* The format of the entry is sparse, and requires that the reader will be able to recognize the format and supply auxiliary information required for making sense of the data. One accustomed to reading phone book entries will be able to extrapolate from the previous entry, and identify the information this way:

Organization Name: Acme Services
Street Address: 123 West First Street
City: Chicago
State: Illinois
Postal Code: 60616-1234
Country: USA
Phone Number: +1 773 555 8943
Phone Number: +1 800 555 9834

In this example, the meaning of the information is made more explicit. Each value is preceded by a name that identifies the type of information given. Acme Services is now identified as the name of an organization. Information is also broken up into smaller chunks (city and state on separate lines), and some information which was implicit in the previous entry (such as the country) has been made explicit. And where two pieces of information (the two phone numbers) were initially compressed onto one line, they have now been separated, making the information more explicit.

This form of entry is closer to the way a record would look in an LDAP directory. But there is still another issue to address. How can we distinguish between two very similar records?

For example, say we have a telephone directory for the entire state of Illinois. And in Illinois, we have a company called Acme Services located in the city of Chicago, and another company named Acme Services located in the city of Springfield.

Simply knowing the company name alone is not sufficient information to isolate just one entry in the phone book. To do that, we would need some sort of unique name—a name that exists only once in the entire directory, and which can be used to refer to one specific entry.

A Unique Name: The DN
One way of distinguishing between two very similar records is to create a unique name for each record in the directory. This is the strategy adopted by LDAP; each record in the directory has a distinguished name. The distinguished name is an important LDAP term; usually it is abbreviated as DN.

In an LDAP directory, the directory designer is the one who decides what components will make up a DN, but typically the DN reflects where the record is in the directory (a concept we will examine in the next part), as well as some information that distinguishes this record from other near records.

A DN then, is composed of a combination of directory information, and looks something like this:

dn: o=Acme Services, l=Chicago, st=Illinois, c=US

This single identifier is sufficient to pick it out from the Springfield company by the same name. The DN of the Springfield company named Acme Services would, according to the previous scheme, look something like this:

dn: o=Acme Services, l=Springfield, st=Illinois, c=US

Some parts of LDAP records are case sensitive, and others are not. DNs, for example, are not case sensitive.

Let's take a specific look at what an LDAP entry looks like.

A LDAP entry is composed of a DN and one or more attributes. The DN serves as a unique identifier within an LDAP directory information tree. Attributes provide information about that entry. Let's convert our previous telephone directory entry into an LDAP record:

dn: o=Acme Services, l=Chicago, st=Illinois, c=US
o: Acme Services
postalAddress: 123 West First Street
l: Chicago
st: Illinois
postalCode: 60616-1234
c: US
telephoneNumber: +1 773 555 8943
telephoneNumber: +1 800 555 9834
objectclass: organization

The first line is the DN. All other lines in this record represent attributes.

These attribute names, like o and postalAddress, refer to well-defined attribute definitions contained in an LDAP schema. They cannot be "invented" on the fly, or made up as you go. Creating new attributes requires writing a schema.

An attribute describes a specific type of information. There are eight attributes here in our example, representing the following:

1. Organization Name (o)
2. Mailing address (postalAddress)
3. Locality (l), which may be the name of a city, town, village, and so forth
4. State or Province (st)
5. Postal Code or ZIP Code (postalCode)
6. Country (c)
7. Telephone Number (telephoneNumber)
8. Object Class (objectclass), which specifies what type (or types) of record this entry is

An attribute may have one or more attribute names, where these names are synonyms. For example c and countryName are both names for the attribute type that identify a country. Both identify the same information, and LDAP will treat the two names as describing the same type of information.

In any given record, an attribute may have one or more values (assuming the attribute's definition allows more than one value). The record above has only one attribute that contains more than one value. The telephoneNumber attribute has two values, each representing a different phone number.

Attribute names are not case sensitive. The attribute name o is treated as synonymous with the name O. Likewise, GivenName, givenname, and givenName are all evaluated as the same attribute name.

As for the values of attributes, case sensitivity depends on the attribute definition. For example, the values of DNs and objectclass attributes are not case sensitive, but a URI (labeledURI) attribute value is case sensitive.

The Object Class Attribute

The last attribute in the given record is the objectclass attribute. This is a special attribute that provides information about what type of record (or entry) this is.

An object class determines what attributes may be given to a record.

ADF security

2009-05-05T21:46:00.000-07:00

Whenever one enables the security in an ADF web application one must always cross verify if jdev has generated "adf-config.xml" in the folder "web-project/.adf/META-INF"

from the docs "To enable Oracle ADF Security authorization, you create a configuration file named adf-config.xml that sets the application's container to use Oracle ADF Security. The file initializes the ADFContext and SecurityContext."

more details of ADF xml can be found here.

Selenium and code coverage

2009-03-31T05:57:00.000-07:00

More details at
http://bxm.at/blogs/java/2006/12/29/webappliction_code_coverage

JSF and Error pages

2009-03-03T00:51:00.000-08:00

Have been looking around for a general strategy that for adding an error page to an ADF Application. found there options

Option 1 : make html error pages for each type of exception
Option 2 : make one error page and generalized bean
Option 3 : Make one error page, One task flow for it , In all the managaed beans inside try catch do add return "error_page_task_flow"

Different approaches may be useful in different scenarious

why we cant mock static methods

2009-03-01T22:55:00.000-08:00

This wasn't obvious to me at first, it took me a while to get why we can't mock static methods. So here it goes the reason in one line,

"Static methods aren't polymorphic, they are resolved at compile time, therefor it's not possible to use mock objects to test."

Hope this help you guys who are scratching your head like I was.... (if you are not sure about polymorphism, think of it as late binding)

In my previous posts i showed one of the ways you can mock static methods, but the limitation is that you need to know the implementation of the class. What if i am using another classes static method whose cource code i dont know.

for example : FacesContext fc = facesContext.getInstance();

Mocking singletons and Factories

2009-03-01T20:29:00.000-08:00

Mocking singletons ., factories may not be that obvious.

public class Singleton {
private Singleton instance = new Singleton ();
public static Singleton getInstance() {
return instance;
}
}

@Test
public void testSingleton() {
Field instanceField = Singleton .class.getField("instance");
instanceField.setAccessible(true);
Singleton realSingleton = instanceField.get(null);
Singleton mockSingleton = EasyMock.createMock(Singleton .class);
try {
instanceField.set(null, mockSingleton);
// now do your testing, Singleton.getInstance() should now return the mock
} finally {
instanceField.set(null, reallSingleton);
instanceField.setAccessible(false);
}
}

This is fairly hacky, not robust to changes in the singleton class, won't work with a security manager, and it may not work well in the case where the field is instantiated in a static initializer and other fields use that instance when they are initialized. But it probably will work in many cases.

Difference between rebuild and make in jdeveloper

2009-02-02T19:27:00.000-08:00

The difference is ...

Rebuild is compiling all selected .java files, regardless if an up-to-date .class file is available or not
Make is compiling those selected .java files for which no up-to-date .class file is available PLUS all .java files which are on the source path AND dependent on the selected .java files

Please note that in both cases the selection makes a difference:

if your selection includes only .java files or packages, only files in the same project will be compiled
if you select one or more projects, compilation will also include any projects which depend on the selected project(s). To prevent building a long list of dependend projects the latest builds of JDev offer the feature Build | Make Only and Build | Rebuild Only, respectively.

Java Util package doesnt have a generic tree ?

2009-01-26T04:38:00.000-08:00

Hi
Many a times developers say that java util package doesn't support a geveric java tree
the api does have

A generic tree can be written as here and here

Google created its own collections framework that is being used in many of its applications as explained in videos 1 and 2. the project can be downloaded from here.

Oracle doesnt support dirty read

2009-01-23T01:38:00.000-08:00

more details at


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import oracle.jdbc.OracleStatement;

public class ConnectionClass {
  public ConnectionClass() {
  }
  public Connection getConnection() throws ClassNotFoundException,
                                           SQLException {
              Class.forName("oracle.jdbc.driver.OracleDriver");
              Connection con = DriverManager.getConnection(
              "jdbc:oracle:thin:@hyc65003fwks.idc.oracle.com:1521:nn11g",
              "scott","tiger");
              con.setAutoCommit(false);
              System.out.println("isolation lvl "+con.getTransactionIsolation());
              con.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
              return con;
          }

  public static void main(String[] args) throws ClassNotFoundException,
                                                SQLException {
      ConnectionClass obj = new ConnectionClass();
      Connection con1 = obj.getConnection();
      Connection con2 = obj.getConnection();
      obj.doUpdate(con1);
   
      obj.read(con2);
      con1.rollback();
      con1.close();
      System.out.println("again reading.......");
      obj.read(con2);
      con2.close();
  }
  int i=0;
  public void doUpdate(Connection con) throws SQLException {
      Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
   
      i++;
      String sql = "insert into delme values('aa"+i+"')";
      System.out.println("sql >>>"+sql);
      System.out.println(stmt.executeUpdate(sql));
      stmt.close();
  }
  public void read(Connection con) throws SQLException {
      Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
      String sql = "select * from delme";
      System.out.println("sql >>>"+sql);
      ResultSet rs = stmt.executeQuery(sql);
      while(rs.next()) {
          System.out.println(rs.getString(1));
      }
      rs.close();
      stmt.close();
   
  }


}
/* Exception in thread "main" java.sql.SQLException: READ_COMMITTED and SERIALIZABLE are the only valid transaction levels
  at oracle.jdbc.driver.SQLStateMapping.newSQLException(SQLStateMapping.java:70)
  at oracle.jdbc.driver.DatabaseError.newSQLException(DatabaseError.java:110)
  at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:171)
  at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:227)
  at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:439)
  at oracle.jdbc.driver.PhysicalConnection.setTransactionIsolation(PhysicalConnection.java:3988)
  at jdbcproj.ConnectionClass.getConnection(ConnectionClass.java:22)
  at jdbcproj.ConnectionClass.main(ConnectionClass.java:29)
Process exited with exit code 1. */

HashMap and null keys

2009-01-22T23:17:00.000-08:00

most of us know a hashMap allows null keys and also null values , but what if we add two values corresponding to same null key

      map.put(null,null);
     map.put(null,"D");
         map.put(null,"E");

What will be the output of
System.out.println(map)

will for the null key it will print the last key value pair , i.e. as per my understanding the null key is unique and on adding more value elements to the same null key will override the old values

Convert HashMap to HashTable

2009-01-22T23:14:00.000-08:00

How will you convert a HashMap having null values and/or keys to a hash table ?


import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class HashTableHashMap
{

  public static void main(String[] args) {
      Map map = new HashMap();
      map.put("a",null);
      map.put("b","B");
      map.put(null,"D");
      System.out.println(map);
      Hashtable ht = new Hashtable();
      Set set = map.entrySet();
      Iterator itr = set.iterator();
      while(itr.hasNext()){
          Map.Entry entry =  (Map.Entry)itr.next();
          Object key = entry.getKey();
          Object val = entry.getValue();
          if(key==null){
              key = ""+null; // Or whatever you want
            }
          if(val==null){
              val = ""+null; // Or whatever you want
            }
          ht.put(key,val);
      }
      System.out.println(ht);
  }
}

iPhone apps using java

2009-01-19T19:45:00.000-08:00

hi
this video tutorial at google provides good insight
http://developerlife.com/theblog/?p=842

Design Pattern : chain of responsibility

2009-01-12T00:43:00.000-08:00

Found two links...

JSF page refresh

2009-01-06T23:11:00.000-08:00

To refresh a JSF page the following piece of code is useful

FacesContext context = FacesContext.getCurrentInstance();
String viewId = context.getViewRoot().getViewId();
ViewHandler handler = context.getApplication().getViewHandler();
UIViewRoot root = handler.createView(context, viewId);
root.setViewId(viewId);
context.setViewRoot(root);

If your page is not getting refreshed due to browser caching

 FacesContext facesContext = event.getFacesContext();
HttpServletResponse response = (HttpServletResponse) facesContext.getExternalContext().getResponse();
response.addHeader("Pragma", "no-cache");
response.addHeader("Cache-Control", "no-cache");
response.setHeader("Cache-Control", "no-store");
response.addHeader("Cache-Control", "must-revalidate");

Data Structures

2009-01-05T03:11:00.000-08:00

Few good links for Data Structures

C API : http://code.google.com/p/c-generic-library/
google collections : http://code.google.com/p/google-collections/
java listenable collections : http://code.google.com/p/jalico/
JRDF : http://code.google.com/p/jrdf/
J5Collections : http://code.google.com/p/j5collections/
Stanford video tutorial : http://in.youtube.com/view_play_list?p=84A56BC7F4A1F852
Book : http://www.brpreiss.com/books/opus5/html/page257.html

How to empty a StringBuffer

2008-12-11T22:16:00.001-08:00

We know that StringBuffer is reusable , We may want to empty a String Buffer ( lets say at end of a loop )
so how do you do it ?

The easiest way i came across use the method setLength()

public void setLength(int newLength)

You may have the case like
StringBuffer sb = new StringBuffer("HelloWorld")
// after many iterations and manipulations
sb.setlength(0);
// reuse sb

Please note you cant say
StringBuffer sb = "";
You will get a type mismatch error saying that "Cannot assign a value of type String to StringBuffer"
Makes sense as StringBuffer is not String , and they both inherit from java.lang.Object

Java ques

2008-11-27T02:16:00.001-08:00

There are three types of empty string, null, "" and " ". Here is how to check for each flavour:

if ( s == null ) echo ( "was null" );
else if ( s.length() == 0 ) echo ( "was empty" );
else if ( s.trim().length () == 0 ) echo ( "was blank or other whitespace" );

We cant use the following
String s="";
if(s.equals(""))
sop("string equal");

Java tricky ques

2008-11-27T02:15:00.001-08:00

Q: How can I check a string has no numbers?

A: The simplest way to check that a String does not contain any numbers is to use the regular expression class Pattern in the java.util.regex package. The method below uses the regular expression [^0-9]+ to check that none of the characters in the input string is a number. The square brackets define a character class. The negation modifier, ^, followed by the number range 0-9 means "not a number". The + quantifier asks the regular expression to match the character class one or more times.

Java String tricky ques

2008-11-26T23:39:00.000-08:00

String s1 = "hello world";
String s2 = "hello world";

if(s1==s2)
System.out.println("Yes");
else
System.out.println("No");

// output of first is Yes
the reason being that in above code you are comparing two references

public static void point1()
{
String s = new String("Friday");
String s1 = new String("Friday");
if (s == s1)
System.out.println("Equal A");
if (s.equals("Friday"))
System.out.println("Equal B");
}
ANS : Equal B
Because they are two different objects on heap , refering diff memeory addresses
hence their reference is not same.

more explanation here.

dont develop for a living you will be a better developer

2008-11-04T20:13:00.000-08:00

Hi
Totally agree with this article

Netbeans 6.1 and Tomcat 5.5

2008-09-28T06:23:00.000-07:00

I was trying add Tomcat5.5 , i had used windows installer for it , to netbeans6.1 on windows and I always get the error "cannot find catalina.bat you cannot start your server through netbeans"
After spending quite some time on why was i getting this error I figured out that i must "Download the .zip formated Tomcat, not the Windows executable. It will have the files netbeans6.1 needs."

A lesson learned :)

Installing Netbeans without glassfish

2008-09-28T05:49:00.000-07:00

Hi
This is crazy but true , you can install netbeans 6.1 without glassfish .. how ?? simple if you have no space in C drive and install Netbeans in D drive , i tried it out today and saw it happened that way for me

:)

Windows Vista and Tomcat 5.5

2008-09-28T04:52:00.000-07:00

Seems like vista is incompatible with tomcat 5.5 too , because of renaming permission ...

Windows Vista and NetBeans6.1 Axis2 plugin issue

2008-09-27T13:18:00.000-07:00

Hi
Discovered that Netbeans 6.1 Axis2 plugin is incompatible with windows vista. The methods at http://www.netbeans.org/kb/61/websvc/gs-axis.html

To deploy an Axis2 web service to the server:

1. Right-click the web service's node. The context menu opens. Select Deploy to Server. The IDE compiles an Axis2 AAR file and copies it to the axis2.war file used by the application server.

The above step cant be completed in windows vista because , windows vista gives a popup and expects user to click "OK" to rename a file.

Error is Unable to rename old file axis.war , because

Eclipse 3.4 Axis2 1.4 invocationtargetexception

2008-09-27T11:45:00.000-07:00

Hi
After wasting few precious hour , i finally concluded that Eclipse 3.4 and Axis2 1.4 are not compatible
many people have faced similar errors ..

http://wuhai.wordpress.com/2008/07/28/axis2-codegen-for-eclipse-invocationtargetexception/
http://wso2.org/library/1719

and the posts are as old as march 08 , and still the members of eclipse dev team havent corrected it , no wonder Eclipse which used to be KING of Java editor is no longer "recommended" anymore , and Netbeans has taken over !!

Solution ?
Take Axis2 eclipse codegen wizard 1.4 from http://www.javaeye.com/post/560587
Or take Eclipse 3.0.1 from http://archive.eclipse.org/eclipse/downloads/drops/R-3.0.1-200409161125/index.php

Social Networking & Adverstising

2008-08-19T05:18:00.000-07:00

I agree with him on quite a few points ,

mobile phone is the center of gravity for teens today !
Virtual gifting is growing at a rapid pace ( $600,000 a month ) any one send you a scrap but how do i show that i really care ... spend on a virtual gift !! People show off virtual gifts on the social networking sites.
Dating is Gaming... It has been traditionally popular on tv shows , it will be HUGE hit on internet
Twitter has grown from "what are you doing" to "what r u doing & where are you"
Etsy : Your place to buy and sell handmade things online. its limited place
Threadless : consumer generated fashion label
StartMobile :

An individual seeks "youtube" , "google" , "etsy" , "threadless" all day and advertisers sees them on these sites.

Bebo n Me

2008-08-19T04:57:00.000-07:00

I am not talking of Bebo as in Kareena Kapoor , the bollywood star , who happens to be nicknamed as Bibo , To be very frank there is nothing that will force ANYONE to put my name and her name in the same sentence ;-)

Anyways I heard about this social networking that...

Bebo is a social networking website
This social networking site is about sharing content.
You can share the videos , music etc that you like with your friends
You can even create a quiz and pass it to your friend.
Bebo has skins ( like most soc networking do ) that can be sponsored
Created by Michael Birch and Xochi Birch
The growing popularity drew the attention of media giants, and AOL shelled out $850 million for Bebo earlier this year.

the couple was recently intervievied on Europe 2007

One can create an application on facebook and port it to bebo. They seem to be compatible.

Flipping Card in Flex

2008-07-31T04:21:00.000-07:00

Was doing some RnD , was looking for a kind of flipping card in flex
Here is what i found ..

Other sites for flex components

ActionScript and MXML relation

2008-07-30T09:47:00.000-07:00

How do MXML and ActionScript relate to one another? The compiler, after parsing through the different idioms, translates MXML into the same objects, so that
< mx:button id="btn" height="100" label="My Button" >

and

var btn:Button = new Button();
btn.label = "My Button";
btn.height = 100;

produce the same object. ActionScript and MXML compiles into a SWF file

Adobe Flex Buildre Free for Students / Proffesors

2008-07-21T05:46:00.001-07:00

Flex 4 : Gumbo

2008-07-20T21:31:00.000-07:00

Found some interesting links for same
Plan for Gumbo
Gumbo architecture

Flex : Self Growing Button

2008-07-18T22:42:00.000-07:00

I have been experimenting around with flex , figured out you can make a Self growing button easily in flex.

< id="button1" label="Click to Increase Size" height="20" click="button1.width+=10;button1.height+=5; ">

I am not trying to display something unusual here. But just a thought its so easy in Flex. If I had to do something similar in JSF or Ajax then it would have involved lot more coding and would use Partial Page Refresh.

Password Management : Too Many passwords ... how do u manage them ??

2008-07-17T23:07:00.000-07:00

With technology touching our lives more than ever before , this is becoming a common issues faced by MANY ...
A partial solution came up ... OpenID With some drawbacks

Not applicable to secure sites like banking etc
Adopted by most NOT ALL.

So how to solve it ??

Well the answer is simple ALGORITHM .. he he .. wondering how ??
let me give you an example...

Generate an algorthim , exploiting the fact that the website names are unique.
If you are member of two websites www.websiteone.com and websitetwo.com
your password may be ... webONEsite and webTWOsite
And if you decide to join another www.websitethree.com then following your example you may keep your password as webTHRsiteEE

The algorithm used above is ... take the 1st three letters of website , append with the last three letters of website and then followed by the remaining letters.

Intelligent lot may think of Exceptional cases like

What if the website name is less than 6 letters ( eg yahoo.com , gmail.com )
What if it is exactly 6 letter
etc , etc ....

Well i would say that its YOUR responsibility to make a proper algorithm that works for most of the sites that you log on to. And i just gave an example here to make your life easier I am not researching on this technique to make EFFICIENT ALGOs.

There are certain Implicit Requirement of this technique. The generated password must follow certain guidelines.

for example your Algorithm may be take the first three letters of website and then append with last three letter's ascii value.
So
www.websiteone.com => web797869
www.websitetwo.com => web848779

Well thats better.. you are a quick learner. :)

But the downside of this algorithm is that it will give same password for sites like webXXXone.com and webYYYone.com or infact webYYYYone.com well thats not a downside how can someone know that you have same password for two of your website ??

Hope this helps
~cheerz !!

Selenium tutorial

2008-07-03T03:07:00.000-07:00

http://www.theautomatedtester.co.uk/selenium_training.htm

FileInputStream is slow

2008-06-25T22:13:00.001-07:00

http://bannister.us/weblog/2008/06/22/why-fileinputstream-is-slow/

others
http://www.wbrogden.com/
http://www.ghostganz.com/blog/articles/2008/06/24/tostring-is-evil
http://www.jroller.com/eu/entry/throwng_npe
http://tech.puredanger.com/2008/06/24/performance-testing-tip-keep-a-log/

Java puzzle

2008-06-25T22:05:00.001-07:00

Good puzzle...
interface.getSuperClass( ) will return null
as interface allows multiple inherutance

http://tech.puredanger.com/2008/06/24/java-puzzler-interface-super-classes/

Video tuts from great Univ

2008-06-23T21:44:00.000-07:00

http://www.oculture.com/2007/07/freeonlinecourses.html
http://www.youtube.com/profile_play_list?user=nptelhrd

Good Reads

2008-06-08T21:53:00.000-07:00

Java 5 Oracle driver : bug ?

2008-06-06T21:08:00.000-07:00

Nice read
http://www.jroller.com/morisil/entry/can_i_trust_oracle_jdbc

Linked Architecture

2008-06-06T21:03:00.000-07:00

good read ...

http://cookiesareforclosers.com/blog/2008/06/linkedin-architecture

Difference between JVM , JRE , JDK

2008-06-06T06:07:00.000-07:00

Simple some say ... Tricky as seen by others ... your decision :)
Answer is

JVM : Have you ever seen a software to install JVM ? NO ... Because you cant install it . Its considered to be subpart of JRE. Engineers at sun say its hypothetical Java engine that reads and run byte code.

JRE : = JVM + everything needed to run java program ( or should i say class file )

JDK : = JRE + extra tools needed to make java progran. see figure below.

Can you install JRE without JDK ? yes find them on suns site.

You might as well have observed when installing JDK JRE also gets installed

String Buffer vs StringBuilder vs Concatination Operator +

2008-06-06T03:50:00.000-07:00

Run this code ... you will realize using concatination operator is better than stringBuilder
Most of us ( including me ) had the idea that StringBuilder will be fast


                long now = System.currentTimeMillis();
                for (int i=0; i<10000000; i++) {
                    String str = "one; two " +
                        ";three four; five; six" +
                        "seven eight nine ten";
                }
                long then = System.currentTimeMillis();
                System.out.println("+ " + Long.toString(then - now));

                now = System.currentTimeMillis();
                for (int i=0; i<10000000; i++) {
                    StringBuilder sb = new StringBuilder(200);
                    sb.append("one; two ");
                    sb.append(
                     ";three four; five; six");
                    sb.append(
                     "seven eight nine ten");
                    String str = sb.toString();
                }
                then = System.currentTimeMillis();
                System.out.println("StringBuilder " + Long.toString(then - now));
           
         now = System.currentTimeMillis();
        for (int i=0; i<10000000; i++) {
             StringBuffer sb = new StringBuffer(200);
             sb.append("one; two ");
             sb.append(
              ";three four; five; six");
             sb.append(
              "seven eight nine ten");
             String str = sb.toString();
         }
         then = System.currentTimeMillis();
         System.out.println("String Buffer " + Long.toString(then - now));

Output on my PC was ...


+ 32
StringBuilder  9031
String Buffer  12125

Good Blogs

2008-06-06T02:39:00.001-07:00

http://tech.puredanger.com/2008/06/03/favorite-java-resources/
http://www.techper.net/2008/06/03/flex-leads-to-clash-between-java-and-flash-communities/
http://thoughts.bharathganesh.com/2008/06/interesting-leak.html
http://linkmingle.com/user/interview_questions/google_interview_questions
http://jeremymanson.blogspot.com/

Shutdown Windows using Java

2008-06-05T23:22:00.001-07:00

Using JNI for it may be an overkill ...

may try


String command = ""; ( click here for shutdown_command )
Process child = Runtime.getRuntime().exec(command);

Or may be try one of these ...
Try one of these (they've both worked, but there might be problems with one - too long ago, don't remember, though )

C:\WINDOWS\RUNDLL32.EXE SHELL32.DLL,SHExitWindowsEx 1
C:\WINDOWS\RUNDLL32.EXE user,exitwindows

All Head First Series eBooks

2008-06-05T22:26:00.000-07:00

For those of you ... who like to collect eBooks ...
Heres the BAAP of all eBooks you collected so far

and above all most of them don't require password ...

Save the links ... as i may delete the post soon ... :)

Head First JSP Servlet
Head First EJB Part1 , Part2 , Part3 , Part4
Head First Design Patterns
Head First Software Development
Head First SQL
Head First Object Oriented n Analysis
Head First JavaScript
Head First HTML
Head First Java ( !! Link changed now !! )
http://www.4shared.com/file/45872148/188712df/Head-First-Java-2nd-edition.html?s=1
J2EE Web Services by Richard Monson Haefel ( password is "books_for_all" )

I couldnt find password less links for ... "Head First Ajax" may be someone can help me with that ....

cheerz !!

More links

http://ebooksresource.wordpress.com/category/design-pattern/
http://martinfowler.com/books.html#eaa
http://knowfree.net/

Is Java Pass by value or pass by reference

2008-06-05T09:55:00.000-07:00

Congratulations .... you are the 99,99,999 person to ask that ... click "here" to clain your prize.... ;-)
Let me see .. whats the correct ans....
Some of you may say its "pass by value for primitive data types and pass by reference for objects" ... hmmmm wrong ... actually the intellignet lot ( at least the booky's ) would say "java is pass by value for primitive types and passes refernce by value for objects.. so java is pass by value"... correct buddy ..... you the man !!

BUT ... thats incomplete my friend ... complete answer is .... java is pass by value for primitive types , passes reference by value for object types ... and when passing objects to remote method (ie RMI) its pass by object copy NOT reference copy.

Unofficial google shell

2008-06-03T22:00:00.001-07:00

Try it to beleive it ...
http://goosh.org/

Java Memory Model FAQ

2008-06-01T21:50:00.000-07:00

JSR 133 FAQ

Implicit VS explicit cursor

2008-05-31T07:01:00.000-07:00

PL/SQL employs an implicit cursor for each UPDATE, DELETE, or INSERT statement you execute in a program. You cannot, execute these statements within an explicit cursor, even if you want to.
You have a choice between using an implicit or explicit cursor only when you execute a single-row SELECT statement (a SELECT that returns only one row).
When SELECT returns more than one row you may or may not have to use explicit cursor depends on usecase.
If you use an implicit cursor, Oracle performs the open, fetches, and close for you automatically; these actions are outside of your programmatic control.

SQL Faqs

2008-05-31T06:30:00.000-07:00

find the two minimum salaries among table
This Query returns duplicate value.
select sal from (select * from order by sal asc) where rownum < 3

This Query retuns only the second minimum salary
Select min(salary) from where Salary>(Select min(salary) from )

Whereas the following Query returns the distinct first two minmum salary in a table
Select min(salary) from union
Select min(salary) from where salary>(Select min(salary) from )

Find out nth highest salary from emp table
directly we can not give the condition as rownum=2....this is the most optimal soluton for the given problem
select * from (select rownum r,salary from (select distinct(salary)from employees where salary is NOT NULL order by salary desc)) where r=2
Best way is using CORRELATED SUBQUERY : as below
Select * From TableName T1 Where (N-1) = (Select Count(Distinct(E2.ColumnName)) From TableName T2 Where T2.ColumnName > T1.ColumnName)
For Required Case We can use it as :-
Select * From EMP T1 Where (2-1) = (Select Count(Distinct(E2.sal)) From EMP T2 Where T2.sal > T1.sal)

XML vs HTML : differences

2008-05-31T06:20:00.000-07:00

XML is basically ment to represent data in portable way while HTML to show data.
XML have custom tags HTML has predefined tags.
XML is case sensitive and HTML is not.
XML document has to wellformed HTML doc need not be.

Looking forward for your input... :)

All About JSP : TagHandler

2008-05-31T02:32:00.000-07:00

The package javax.servlet.jsp.tagext package has interfaces

Tag
IterationTag
BodyTag

There are classes provided in the javax.servlet.jsp.tagext package which provide default implementation for the above interfaces :

TagSupport
BodyTagSupport

THERE s no IterationTagSupport

Tag interface
The six methods which Tag interface provides and which we have to implement are :

setPageContext(PageContext pc)
setParent(Tag parent)
getParent()
doStartTag()
doEndTag()
release()

Above six methods are a must.
If there are attributes in tag then we have additional setter & getter for them.

Tag Interface Lifecycle

The setPageContext() method : is the first method that is called in the life cycle of a custom tag.
The setParent() and getParent() methods : are used when custom tags are nested one inside the other. The JSP container calls the setParent() method on the child tag and passes it a reference to the parent tag. The getParent() method is usually called by one of the child tags and not directly by the JSP container.
the setters of attributes are called
doStartTag() method : After setting up the tag with appropriate references by calling the setPageContext(), setParent(), and setter methods, the container calls the doStartTag() method on the tag. After initialization, the doStartTag() method decides whether or not to continue evaluating its body content. As a result, it returns one of the two integer constants defined in the Tag interface: EVAL_BODY_INCLUDE or SKIP_BODY. May throw a JSPException.
doEndTag() method : After the body of the tag is evaluated or skipped (depending on the return value of doStartTag()), the container calls the doEndTag() method. May throw a JSPException.
release() method : Finally, the container calls the release() method on the handler class when the tag handler object is no longer required. A custom tag may occur multiple times on a JSP page. A single instance of the tag handler may be used to handle all of these occurrences. The JSP container calls the release() method on the handler class when the handler object is no longer required. It is important to note that this method is not called after every call to doEndTag().

IterationTag Interface

The IterationTag interface extends the Tag interface and allows us to include the body content multiple times, in a way that is similar to the loop functionality of a programming language. The IterationTag interface declares one method and one constant

int doAfterBody() : This method is called after each evaluation of the tag body. It can return either of two values: IterationTag.EVAL_BODY_AGAIN or Tag.SKIP_BODY. The return value determines whether or not the body needs to be reevaluated.

EVAL_BODY_AGAIN : Return value for doAfterBody(). This constant instructs the JSP engine to evaluate the tag body and include it in the output.

If doStartTag() returns SKIP_BODY, then the body is skipped and the container calls doEndTag(). In this case, the doAfterBody() method is never called on the iterative tag. However, if doStartTag() returns EVAL_BODY_INCLUDE, the body of the tag is evaluated, the result is included in the output, and the container calls doAfterBody() for the very first time.

BodyTag Interface

The BodyTag interface extends IterationTag and adds a new functionality that lets the tag handler evaluate its body content in a temporary buffer. This feature allows the tag to process the generated contents at will. For example, after evaluation, the tag handler can view the body content, discard it completely, modify it, or add more data to it before sending it to the output stream. Since it is derived from IterationTag, BodyTag can also handle the evaluation and processing of the content as many times as required.

void setBodyContent(BodyContent) : Called by the JSP container to pass a reference to a
BodyContent object.

void doInitBody( ) : Called by the JSP container after calling setBodyContent(), to allow the tag handler class to perform initialization steps on BodyContent.

EVAL_BODY_BUFFERED : A constant defined as a return value for doStartTag() and doAfterBody() for tags that want to buffer the evaluation of their content

LifeCycle

The doStartTag() method of a class that implements the BodyTag interface returns any one of three values: EVAL_BODY_INCLUDE or SKIP_BODY inherited from the Tag interface, or EVAL_BODY_BUFFERED, which is defined in the BodyTag interface. The actions taken by the JSP container for the return values EVAL_BODY_INCLUDE and SKIP_BODY are the same as for the IterationTag interface.

However, if doStartTag() returns EVAL_BODY_BUFFERED, the JSP container takes a different course of action. It first creates an instance of the BodyContent class. The BodyContent class is a subclass of JspWriter and overrides all the print and write methods of JspWriter to buffer any data written into it rather than sending it to the output stream of the response. The JSP container passes the newly created BodyContent instance to the tag handler using its setBodyContent() method, calls doInitBody() on the tag, and finally evaluates the body of the tag, filling the BodyContent buffer with the result of the body tag evaluation.

The container calls doAfterBody() after evaluating the body, writing the data directly into the output or buffering it, as the case may be. If the output was buffered, we can add, modify, or delete the contents of this buffer. Finally, this method returns EVAL_BODY_AGAIN or EVAL_BODY_BUFFERED to continue evaluating the body in a loop, or returns SKIP_BODY to terminate the loop.

Finally, the container calls doEndTag(), and, as with the other interfaces, the tag handler class that is implementing the BodyTag interface can return either SKIP_PAGE or EVAL_PAGE.

All about JSP : Custom Tags

2008-05-30T23:44:00.000-07:00

What's Custom Tag ? and Whats Use ??
Custom tags allow us to move the presentation logic outside the JSP pages into independent Java classes. One may choose to make custom tag for particular project or as an independent jar file.

There are diff kinds of custom tags

Empty Tags
Tags with attributes
Tags with JSP code
Tags with nested tags

Whats TagHandler ?
As name suggest its something that handles Tag and that something can only be java class. A tag handler is a Java class that implements one of the tag interfaces—Tag, IterationTag, or BodyTag—of the package javax.servlet.jsp.tagext.

The JSP specification defines a tag handler as a runtime, container-managed object that evaluates custom actions during the execution of a JSP page.

Whats Tag library descriptor ?
Its the way to let JSP engine know the tag handler classes for custom tags.

How to inform JSP Engine about custom tag library ?
TWO ways
(1) Use the taglib directive


< % @ taglib prefix="test" uri="testLib.tld" % >

(2) Use jsp root

< jsp="http://java.sun.com/JSP/Page" test="testLib.tld" version="1.2">
   ...JSP PAGE...
< / jsp:root>

Above examples shows URI. It can be of many type right ?
Three Types
(1) Absolute URI :
A URI that has a protocol, a hostname, and optionally a port number.
http://localhost:8080/mytaglibs

(2) Root Relative URI :
A URI that starts with a / "and" that does not have a protocol, a hostname, or a port number. It is interpreted as relative to the document root of the web application.
/myLib
/mytaglib/myLib

(3) Non-root Relative URI :
does not start with a / "and" that does not have a protocol, a hostname, or a port number. It is interpreted as relative to either the current JSP page "or" the WEB-INF, depending on where it is used.
myLib
mytaglib/myLib

< % @ taglib prefix="test" uri="sampleLib.tld" % >
The JSP engine searches for the file in the same directory as the JSP page.
Though keeping all the JSP pages and the TLD files in the same directory is the simplest way to use a taglib directive, it has two major drawbacks: security and flexibility.

How is the URI mapped to TLD ?
Through mapping ... standard reason ... achieve security & flexibility by maintaining a level of redirection ... If we wanted to switch to a newer version of the library, say myLib2.tld, then we would have to manually modify all the JSP pages that are affected by this change. The JSP container maintains a map between the URIs that we use in taglib directives and the actual physical location of the TLD files in the file system.
With this approach, instead of using a page-relative path, we use an absolute URI path:
< % @ taglib prefix="test" uri="http://www.myserver.com/myLib" % >
When the JSP engine reads the above URI, it refers to its internal map to find the corresponding
TLD file location.

The JSP specification mandates that, when deployed in a JAR file, a TLD file be
placed either directly under or inside a subdirectory of the META-INF directory. In
addition, the name of the TLD file must be taglib.tld. Thus, a JAR file containing
a packaged tag library is typically structured like this:

myPackage/myTagHandler1.class
myPackage/myTagHandler2.class
myPackage/myTagHandler3.class
META-INF/taglib.tld

How can the jsp container populate the taglib map
Three ways ...
• First, the container reads the user-defined mapping entries present in the deployment descriptor. This is called explicit mapping. We will learn how to add new entries to the deployment descriptor in the next section.
• Then, the container reads all the taglib.tld files present in the packaged JARs. For each jarred TLD file that contains information about its own URI, the JSP container automatically creates a mapping between the specified URI and the current location of the JAR file. This is called implicit mapping. We will learn how to add the URI information to a TLD file in the next chapter, where we will create a custom tag library.
• Finally, the JSP container adds entries for the URIs that are known to the container by default. These URIs are called well-known URIs. The element of a JSP document contains an example of a well-known URI: http://java.sun.com/JSP/Page

Algorithm ?
• If the value of the uri attribute matches any of the entries, the engine uses the value of the corresponding to locate the actual TLD file.
• If the value is a root-relative URI (that is, it starts with a /), the JSP engine assumes the location to be relative to the web application’s document root directory. Thus, the location for the URI http://www.manning.com/studyKit in listing 15.1 will resolve to
the TLD file /myLibs/studyKit.tld.
• If the value is a non-root relative URI (that is, it starts without a /), the JSP engine prepends /WEB-INF/ to the URI and assumes the location to be relative to the web application’s document root directory. Thus, the location for the URI http://www.manning.com/
sample.jar in listing 15.1 will resolve to the TLD file /WEB-INF/yourLibs/studyKit.tld.

• If the value of the uri attribute of the taglib directive does not match any of the entries, then the following three possibilities arise:
• If the specified uri attribute is an absolute URI, then it is an error and is reported at translation time.
• If the specified uri attribute is a root-relative URI, it is assumed to be relative to the web application’s document root directory.
• If the specified uri attribute is a non-root-relative URI, it is assumed to be relative to the current JSP page. Thus, if the JSP file /jsp/test.jsp contains the directive < % @ taglib prefix="test" uri="sample.tld" % >, the engine will expect to find the sample.tld file at /jsp/sample.tld.

Ques Where will it look for TLD file ?
< % @ taglib uri="www.myserver.com/myLib.tld" prefix="mylib" % >
Ans
The URI www.myserver.com/myLib.tld does not contain a protocol; therefore, it is not an absolute URI. It does not start with a /, so it is not a root-relative URI either. It is a page-relative URI. After failing to find an entry in the map, the engine will search for the file hello.tld at the location relative to the current page. Suppose the JSP page is at location
C:\tomcat\webapps\app15\test.jsp
The engine will look for the file at
C:\tomcat\webapps\app\www.myserver.com\hello.tld

Note
The value of cannot be an absolute URI. and both the and are mandatory when defining absoulte way.

google collections library

2008-05-30T22:05:00.001-07:00

Link is more than enough :)
http://code.google.com/p/google-collections/

Java Tricky Question - 6

2008-05-28T07:07:00.000-07:00

whats the difference between


 < servlet-mapping >
     < servlet-name >ServletOne< / servlet-name >
     < url-pattern >/mywebsite/myservlet< / url-pattern >
 < / servlet-mapping >


  < servlet-mapping >
     < servlet-name >ServletTwo< / servlet-name >
     < url-pattern >/mywebsite/myservlet/< / url-pattern >
 < / servlet-mapping >


  < servlet-mapping >
     < servlet-name >ServletThree< / servlet-name >
     < url-pattern >/mywebsite/myservlet/*< / url-pattern >
 < / servlet-mapping >

Dont ask me the answer ,,,, rather help me finding one ... ;o)
this one is still under discussion ... at java ranch

Java Tricky Question - 5

2008-05-28T06:47:00.001-07:00

Q: How can you associate an array of values for an initialization parameter of a servlet?

A: You can’t; at least not directly! The deployment descriptor does not
allow you to specify multiple parameters with the same name. So you
have to do something like this:
< init-param >
< param-name > param1 < / param-name >
< param-value > val1 , val2 , val3 , val4 < / param-value >
< init-param >
You would then have to parse the param-value string in the servlet
and interpret the multiple values listed in the string.

Java Tricky Question - 4

2008-05-28T06:46:00.001-07:00

Q : Your web application includes an applet packaged as a JAR file. Which directory would you keep the JAR file in?
A:
Because an applet is only run on the client side, the applet JAR file
should be accessible to the clients. This means that it may be kept anywhere
in the document root of the application except in the WEB-INF
directory and its subdirectories.
( As the contents inside the WEB-INF is not visible to client )

Java Tricky Question - 3

2008-05-28T05:32:00.001-07:00

Both the interfaces ServletContext and ServletRequest have method getRequestDispatcher() .. whats the difference between them ??

Ans :
You can pass a relative path to the getRequestDispatcher() method of ServletRequest but not to the getRequestDispatcher() method of ServletContext. For example, request.getRequestDispatcher("../html/somePage.html") is valid, and the getRequestDispatcher() method of ServletRequest will evaluate the path relative to the path of the request. For the getRequestDispatcher() method of ServletContext, the path parameter cannot be relative and must start with /. This makes sense because ServletRequest has a current request path to evaluate the relative path while ServletContext does not.

Java Tricky Questions - 2

2008-05-28T04:40:00.000-07:00

How can you create multiple servlet objects of the same servlet class if You are not allowed to implements the SingleThreadModel interface ??

Ans :
More than one element is defined in the web.xml file having the same servlet class names.
( some of you may say the ans is stupid ... I mean ques is more literal than technical ... but hey it can be a twister for many )

Practical Use :
You can do this if you want to have multiple sets of initialization parameters. For example, you may want one instance to connect to one database and a second instance to connect to another database.

Good Flex sites

2008-05-27T23:17:00.000-07:00

the site http://www.flowww.com/

and This "Book tool" is simply superb... http://www.rubenswieringa.com/code/as3/flex/Book/

I wonder if Java ? ADF ? or JavaFX can make such tools .. sites
If yes how easy / tough would it be .... no idea ... !!

Java Tricky Questions - 1

2008-05-27T22:22:00.000-07:00

Whats the difference between


int length = 5;
int breadth = 10;
int area = length * breadth;

and


final int length = 5;
final int breadth = 10;
int area = length * breadth;

dont scroll down until you have thought over the answer
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
gave it a thought ?
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
sure ?
.
.
.
.
.
.
.
.
.
.
.
Ok then heres the answer...
In the second code snippet multiplication is done at compile time.
In first multiplication is done at Runtime.
Reason
Java compiler uses something known as Constant Folding. Constant folding refers to the compiler precalculating constant expressions.
Query
I wonder what will happen if the code is


int length = 5;
final int breadth = 10;
int area = length * breadth;

The above code will not use constant folding for length but do so for breadth.
What if ?


static final int breadth = 10;
int area = 5 * breadth;

then compiler will use constant folding for breadth.

HashMap : Not thread safe structure

2008-05-26T22:06:00.000-07:00

Nice Read
http://pveentjer.wordpress.com/2008/05/26/hashmap-is-not-a-thread-safe-structure/

Java Tricky questions

2008-05-26T04:28:00.001-07:00

Found this link
bad part is answers are not explained

http://www.mydeveloperconnection.com/html/JavaTrap.htm

All About Java Exceptions

2008-05-26T01:19:00.000-07:00

Common Java wisdom gives us a few general principles about how to work with exceptions:

1. Don’t use exceptions for flow control and expected business situations, but only for exceptional situations
2. Use unchecked exceptions for programming errors, bugs, situations where the application or the current operation cannot expect to recover from.
3. Use checked exceptions for situations where the caller is expected to be able to make a full or partial recovery after the failure

If we keep the function return type as


public boolean doSomeWork()
{
if(success)
    return true;
else
    return false;
...
}

two probs
1) Caller will have to check the return value : if he doesnt he may continue with wrong assumption
2) The caller doesn’t have enough information to see what went wrong

With this kind of solution we are back to the way C programs were written... but remember this is java

Another way is...


public class SomeException extends RuntimeException
{
   ...
}
public boolean doSomeWork()
{
if(success)
    return true;
else
    throw new SomeException();
...
}

You may have to do some documentation for the new exception class. Which is a disadvantage if you are LAZY ;).
Else the advantages are
* If the client code fails to treat the exception at least the program doesn’t continue on a wrong path.
* We can send more information about the failure context in the exception class through the exception type and the exception instance content.
Disadvantages
* The client code programmer is not automatically warned to treat the exception

One more way is ...


public class SomeException extends Exception
{
   ...
}
public boolean doSomeWork() throws SomeException
{
if(success)
    return true;
else
    throw new SomeException();
...
}

Client code will use try / catch block

How can you catch multiple exceptions in java ??


Statement stmt = null;
try {
 // do stuff that uses Statement instance
} catch (SQLException e) {
// handle state
log.error("Bad database", e);
} catch (NullPointerException e) {
// handle state
log.error("Bad parameter", e);
} catch (Exception e) {
// handle state
log.error("Bad luck", e);
} finally {
try {
  stmt.close();
} catch (Exception ex) {}
}

Summary
Rule of thumb: Use Checked Exceptions for recoverable conditions and Runtime Exceptions for programming errors.
Checked exceptions are great in theory, but in practice lots of developers use them poorly and then the rest of us are left to clean up their mess.
checked exceptions are domain exceptions.

Links
http://truecode.blogspot.com/2008/01/bypassing-java-checked-exception.html
http://dev2dev.bea.com/pub/a/2006/11/effective-exceptions.html
http://dev2dev.bea.com/pub/a/2007/06/exception-advice.html
http://www.csd.uoc.gr/~andreou/

JSF FAQs

2008-05-22T05:06:00.001-07:00

JSF is MVC2 ?
As per my knowledge There is no MVC1 and MVC2
there is JSP model 1 and model 2 as explained in the article
http://www.javaworld.com/javaworld/jw-12-1999/jw-12-ssj-jspmvc.html
JSF is in the scope of model 2

Other frameworks like JSF ?
Apple's WebObjects is a similar architecture to JSF and so is ASP.net.

Difference betwwen managed beans and backing beans ??

f:facet ??

Advantages
JSF's fine-tuned event model allows your applications to be less tied to HTTP details and simplifies your development effort.

http://forum.java.sun.com/thread.jspa?threadID=674446

Servlets Basics

2008-05-20T05:32:00.000-07:00

javax.servlet.http.HttpServlet Is an abstract class that extends the javax.servlet.GenericServlet class.
All the methods in it have protected identifier and the service method is overloaded


protected  void service(HttpServletRequest req, HttpServletResponse resp)

Receives standard HTTP requests from the public service method and dispatches them to the doXXX methods defined in this class.

 void service(ServletRequest req, ServletResponse res)

Dispatches client requests to the protected service method.

Clicking on a hyperlink always sends a GET request and thus, the doGet() method of the servlet will be called. < href = " /servlet/TestServlet " method="POST"> Some URL < / a >
The method="POST" attribute-value pair does not make sense in the anchor tag.
Retrieve Request Parameter


String[ ] getParameterValues(String paramName)

The above method is for html element like dropbox etc

 Enumeration getParameterNames()

This method is useful when you don’t know the names of the parameters. You can iterate through the Enumeration of Strings returned by this method and for each element you can call getParameter() or getParameterValues().

Retrieve request headers

There is one difference , though; unlike parameters, headers are specific to the HTTP protocol and so the methods that deal with the headers belong to HttpServletRequest and not to ServletRequest.

 String getHeader(String headerName)

This method returns just one of the values associated with the given header.

 Enumeration getHeaderValues(String headerName)

This method returns all the values associated with the header as an Enumeration of String object.

 Enumeration getHeaderNames()

This method is useful when you don’t know the names of the headers. You can iterate through the enumeration returned by this method, and for each element you can call getHeader() or getHeaderValues().

Which method would you use to retrieve the number of parameters present in a request?
Neither ServletRequest nor HttpServletRequest provides any method to retrieve the number of parameters directly. You’ll have to use ServletRequest.getParameterNames(), which returns an Enumeration, and count the number of parameters yourself.

GET vs POST

2008-05-20T05:17:00.000-07:00

FEATURE	GET method	POST method
Type of data	text	text & binary
Amount of data	Browser dependent gen is 255	unlimited
Visibility	data is part of URL	Part of body not URL
Caching	can be cached	cant be
Bookmarkable	Can bookmark	Cant bookmark
Spl Case	Cant be used in case data is character set other than ASCII	Can use any type of character set
Use Case	used when the form processing is "idempotent"	used in all other cases
Default	Its default for HTML FORM element	Its not .. need to use method attribute

HashMap : Basics

2008-05-19T05:58:00.000-07:00


package datastructure.delme;
import java.util.*;

class SimpleClass {
   private String desc;
   public SimpleClass(String s) {
       desc=s;
   }
   public String getDesc() {
       return desc;
   }
   @Override
   public String toString() {
       return "description is "+desc;
   }
}

public class DelMeCollection {
   public static void main(String[] args) {
       System.out.println("in main");
       SimpleClass s1 = new SimpleClass("one");
       SimpleClass s2 = new SimpleClass("two");
       SimpleClass s3 = new SimpleClass("three");
       SimpleClass s4 = new SimpleClass("four");
     
       HashMap  hm = new HashMap();
       hm.put("1",s1);
       hm.put("2",s2);
       hm.put("3",s3);
       hm.put("4",s4);
       Iterator hmKeyItr = hm.keySet().iterator();
       while(hmKeyItr.hasNext())
       {
           String tempKey= (String)hmKeyItr.next();
           System.out.println(tempKey+" val is "+hm.get(tempKey));
       }

       Iterator hmValItr = hm.values().iterator();
       while(hmValItr.hasNext())
       {
           SimpleClass tempVal = (SimpleClass)hmValItr.next();
           System.out.println(" val is "+tempVal);
       }
     
       for (Map.Entry entry: hm.entrySet())
       {
           System.out.println(entry.getKey() + " -> " + entry.getValue());
       }      

     
   }
}

also tried UPCASTING
the following gave error


HashMap < string , object > hm = new HashMap < string , simpleclass >();
HashMap < string , simpleclass > hm = new HashMap < string , object >();
HashMap < string , simpleclass > hm = new HashMap < object , sipleclass >();
HashMap < object , simpleclass > hm = new HashMap< string , simpleclass >();

Moreover java.util.HashMap

Note that this implementation is not synchronized. If multiple threads access this map concurrently, and at least one of the threads modifies the map structurally, it must be synchronized externally. (A structural modification is any operation that adds or deletes one or more mappings; merely changing the value associated with a key that an instance already contains is not a structural modification.) This is typically accomplished by synchronizing on some object that naturally encapsulates the map. If no such object exists, the map should be "wrapped" using the Collections.synchronizedMap method. This is best done at creation time, to prevent accidental unsynchronized access to the map:

Map m = Collections.synchronizedMap(new HashMap(...));

Clear the Screen In Java 5

2008-05-16T05:13:00.000-07:00

Ask your friend to write a simple command line utility in java that gives a set of options like ...


      1. Press 1 to add element to LinkedList
      2. Press 2 to Delete an element in LinkedList
      3. Press 3 to traverse the LinkedList
      4. Press 4 to exit

     Enter Your Choice : _

When user choses one of the above mentioned options ,
First , the screen should be cleared off
Second , the corresponding details (if any) should be asked ( like eneter value to add / delete )
Third , perform the action
Fourth , ReDisplay the above menu

To complete the above program you need to write a method like...


public void clearTheScreen( ) {
....
}

or may be


public boolean clearTheScreen( ) {
....
// return true if screen deleted else false
}

How to complete this method ??

hhhmmmm lets "BRAIN STORM"

"first" reply may be...

Runtime.getRuntime.exec("cls");

No you say ...
System-specific tasks such as these may be performed via Runtime.exec( )
it allows you to perform certain system-specific tasks BUT with very little control.

Actually, this won't work. Yes, the 'cls' command is invoked, *but* it is
invoked in a new process ['command.com' or 'cmd.exe' is exected creating a
new process], and *does not* clear the Java application's console.

If your friend is intelligent may argue ...
But if they can implement "beep", and they do, they should be able to implement "cls" too.
But you are MORE intelligent , you say
That's because BELL is a standard ASCII character (code 7) and it's
pretty much standard that any terminal/console would render it by beeping.

The "second" reply may be

System.out.print("\n\n\n\n\n\n\n\n\n\n\n\n");

and you say ... its obviously incorrect ( BTW your friend is stupid if he mentions this option ) ,
as it scrolls the menu above so that its not visible to user NOT clean the screen.

"third" reply may be
I heard about this method:

System.out.print((char)27 + "[2J");

Dont get scared probably your friend probably was good DOS progarmmr at some time as + "[2J" is the ANSI escape sequence for clearing the screen.
However, it doen't work unless "ansi.sys" is loaded and very few WinXP user's have this.

If your friend is a Windows geek he may say

Yes, we can add the following command in the c:\windows\system32\config.nt.
device=c:\windows\system32\ansi.sys
This will load the ansi.sys

But that wont work buddy ... you may try it yourself .. and besides
Thats Platform dependent !! and Java is platform independent right ?
so take a "Chill Pill dude"

"fourth" may be ( if your friends guesses this .. he is really good with java / linux )
Printing out the form-feed character will clear the screen
System.out.print("\f");
It works but only on linux , not on windows ... But java code should be platform independent

Your friend : " So WHAT SHOULD I DO ??? "
You ( with a smile ) : Write Java Native Interface [JNI] routines which tap into the relevant operating system functionality
Your Friend : " ?? WHY ?? "
You : Unfortunately these tasks are inherently operating system-specific, and cannot be implemented in any standard way across platforms. Some platforms, in fact, don't even understand the concepts of 'screen', or 'cursor', so wouldn't even have any use for classes that implemented these abstractions. Even the 'standard' C and C++ languages which, like Java, aim for platform independance, do not implement such functionality.

Most intelligent of your friend may say ...
( you know the Phd types )

Maybe a nested class could be added to 'System', containing all the
system-specific console-management routines, something like:


class System
{
...
public class Console
{
...
public static native void cls();
public static native void setCurPos(int row, int col);
public static native String inputString();
public static native double inputNumeric();
...
}
...
}

You could then do something like:


System.Console.cls();

and YOU calmly reply ...
Amego !! It would defeat the purpose of platform-independance, since not all
platforms have the concept of a "console".

Real solution ??
Write JNI ( platform dependent way ) OR
Look at jcurses on sourceforge. ( but using this is an overkill )
http://sourceforge.net/projects/javacurses/

NeXt ... ask your friend .. to write a code to Accept input [say a single keystroke] without pressing ENTER and let me know how it goes ;o)

Contradiction
Contradicting my self ... Recently discovered that with Java 6 , Its very much possible ...
In Java 6 a better way of interacting with the command prompt was introduced, the java.io.Console class.
Together with the utility class java.util.Scanner introduced in Java 5 this new API can be used to develop more advanced Java console applications.

For more detaisl checkout
http://java.dzone.com/news/console-applications-java-6
http://java.sun.com/javase/6/docs/api/java/io/Console.html

Java Sort

2008-05-16T01:56:00.000-07:00

http://mindprod.com/jgloss/sort.html

Java Hashing

2008-05-15T10:39:00.000-07:00

lets start with hashing in general and how does java implement same and what are the drawbacks ( if any )

hashing is a process of generating an index or address ( which is of smaller length) basing on ur data . A good hash function is the one which generates distinct addresses for distinct file names.

As a simple example of the using of hashing in databases, a group of people could be arranged in a database like this:
Abernathy, Sara Epperdingle, Roscoe Moore, Wilfred Smith, David (and many more sorted into alphabetical order)
Each of these names would be the key in the database for that person's data. A database search mechanism would first have to start looking character-by-character across the name for matches until it found the match (or ruled the other entries out). But if each of the names were hashed, it might be possible (depending on the number of names in the database) to generate a unique four-digit key for each name. For example:
7864 Abernathy, Sara 9802 Epperdingle, Roscoe 1990 Moore, Wilfred 8822 Smith, David (and so forth)
A search for any name would first consist of computing the hash value (using the same hash function used to store the item) and then comparing for a match using that value. It would, in general, be much faster to find a match across four digits, each having only 10 possibilities, than across an unpredictable value length where each character had 26 possibilities.

The hashing algorithm is also called hash function

Uses of hashing
(i) Hashes play a role in security systems where they're used to ensure that transmitted messages have not been tampered with. The sender generates a hash of the message, encrypts it, and sends it with the message itself. The recipient then decrypts both the message and the hash, produces another hash from the received message, and compares the two hashes. If they're the same, there is a very high probability that the message was transmitted intact.

(ii) Hashing is also a common method of accessing data records.

Java and hashing
Every Java object has a hashCode() and an equals() method. While the Java language does not provide direct support for associative arrays -- arrays that can take any object as an index -- the presence of the hashCode() method in the root Object class clearly anticipates the ubiquitous use of HashMap (and its predecessor, Hashtable). Under ideal conditions, hash-based containers offer both efficient insertion and efficient retrieval; supporting hashing directly in the object model facilitates the development and use of hash-based containers.

if two objects are equal according to the equals() method, they must have the same hashCode() value (although the reverse is not generally true).

Why override equals() and hashCode()?

What would happen if a class did not override equals() and hashCode()? Nothing, if we never used an that class as a key in a HashMap or other hash-based collection. However, if we were to use such a classes object for a key in a HashMap, we would not be able to reliably retrieve the associated value, unless we used the exact same classes instance in the get() call as we did in the put() call. This would require ensuring that we only use a single instance of the Integer object corresponding to a particular integer value throughout our program. Needless to say, this approach would be inconvenient and error prone.

There are some restrictions placed on the behavior of equals() and hashCode(), which are enumerated in the documentation for Object. In particular, the equals() method must exhibit the following properties:
· Symmetry: For two references, a and b, a.equals(b) if and only if b.equals(a)
· Reflexivity: For all non-null references, a.equals(a)
· Transitivity: If a.equals(b) and b.equals(c), then a.equals(c)
· Consistency with hashCode(): Two equal objects must have the same hashCode() value
· For any non-null reference value x, x.equals(null) must return false.

public boolean equals(Object o) {
if (o == null)
return false;
...
}

public boolean equals(Object o) {
if (!(o instanceof MyType))
return false; // also return null if o is null .. no spl check required
...
}

Building hashing into the root object class of the Java class library was a very sensible design compromise -- it makes using hash-based containers so much easier and more efficient. However, several criticisms have been made of the approach to and implementation of hashing and equality in the Java class library. The hash-based containers in java.util are very convenient and easy to use, but may not be suitable for applications that require very high performance. While most of these will never be changed, it is worthwhile to keep in mind when you're designing applications that rely heavily on the efficiency of hash-based containers. These criticisms include:

Too small a hash range. Using int, instead of long, for the return type of hashCode() increases the possibility of hash collisions.

Bad distribution of hash values. The hash values for short strings and small integers are themselves small integers, and are close to the hash values of other "nearby" objects. A more well-behaved hash function would distribute the hash values more evenly across the hash range.

No defined hashing operations. While some classes, such as String and List, define a hash algorithm to be used in combining the hash values of its constituent elements into a single hash value, the language specification does not define any approved means of combining the hash values of multiple objects into a new hash value.

Difficulty writing equals() when extending an instantiable class that already overrides equals(). The "obvious" ways to define equals() when extending an instantiable class that already overrides equals() all fail to meet the symmetry or transitivity requirements of the equals() method. This means that you must understand the structure and implementation details of classes you are extending when overriding equals(), and may even need to expose private fields in the base class as protected to do so, which violates principles of good object-oriented design.

Basically what happens is when hashCode returns a number then its searched for in collection and gets a list, and then it uses equals( ) to search in bucket that it got.

Equals( ) defines logical equality

Recipie for a equals( ) method

1. Use the == operator to check if the argument is a reference to this object.
If so, return true. This is just a performance optimization, but one that is worth
doing if the comparison is potentially expensive.
2. Use the instanceof operator to check if the argument is of the correct
type. If not, return false. Typically, the correct type is the class in which the
method occurs. Occasionally, it is some interface implemented by this class.
Use an interface if the class implements an interface that refines the equals
contract to permit comparisons across classes that implement the interface. The
collection interfaces Set, List, Map, and Map.Entry have this property.
3. Cast the argument to the correct type. Because this cast was preceded by an
instanceof test, it is guaranteed to succeed.
4. For each “significant” field in the class, check to see if that field of the argument
matches the corresponding field of this object. If all these tests succeed,
return true; otherwise, return false.
5. When you are finished writing your equals method, ask yourself three
questions: Is it symmetric, is it transitive, and is it consistent?

Here is the contract, copied from the java.lang.Object specification:
n Whenever it is invoked on the same object more than once during an execution
of an application, the hashCode method must consistently return the
same integer, provided no information used in equals comparisons on the
object is modified. This integer need not remain consistent from one execution
of an application to another execution of the same application.
n If two objects are equal according to the equals(Object) method, then calling
the hashCode method on each of the two objects must produce the same
integer result.
n It is not required that if two objects are unequal according to the equals(Object)
method, then calling the hashCode method on each of the two objects
must produce distinct integer results. However, the programmer should be
aware that producing distinct integer results for unequal objects may improve
the performance of hash tables.

References
http://java.sun.com/docs/books/effective/chapters.html
http://www.owasp.org/index.php/Hashing_Java

Java Iterator

2008-05-15T05:16:00.000-07:00

Iterator also has a method remove( ) , when its called it will remove from source the last item retrieved from next( )

If remove is called twice in succesion without a call to next in between IllegalStateException is thrown can get Concurrent MOdification exceptiion if someone else is modifying the collection

according to http://java.sun.com/j2se/1.4.2/docs/api/java/util/Iterator.html#remove()
The behavior of an iterator is unspecified if the underlying collection is modified while the iteration is in progress in any way other than by calling this method.


import java.util.*;
public class DelMeCollection {
    public static List l = new ArrayList(25);
    static class ListIterateThread extends Thread {
        public void run( ){
            System.out.println("thread started ");
            Iterator listItr = l.iterator();
            System.out.println("got the iterator ");
            try {
            while(listItr.hasNext())
                    System.out.println("val is "+listItr.next());
            } catch(Exception e ) {
                System.out.println("some exception "+e);
                // wonder why no concurrent modification exception
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("inside main THREAD");
        ListIterateThread lt= new ListIterateThread();
        List l = new ArrayList(25);
        lt.start();
        l.add("1");          System.out.println("added 1");
        l.add("2");          System.out.println("added 2");
        l.add("3");          System.out.println("added 3");
        l.add("4");          System.out.println("added 4");
        l.add("5");          System.out.println("added 5");


        l.add("11");        System.out.println("added 11");
        l.add("12");        System.out.println("added 12");
        l.add("13");        System.out.println("added 13");
        l.add("14");        System.out.println("added 14");
        l.add("15");        System.out.println("added 15");

        try {
            Thread.currentThread().sleep(5);
        } catch (InterruptedException e) {
            System.out.println("exception "+e);
        }
        
        l.add("21");        System.out.println("added 21");
        l.add("22");        System.out.println("added 22");
        l.add("23");        System.out.println("added 23");
        l.add("24");        System.out.println("added 24");
        l.add("25");        System.out.println("added 25");
        
        l.add("31");        System.out.println("added 31");
        l.add("32");        System.out.println("added 32");
        l.add("33");        System.out.println("added 33");
        l.add("34");        System.out.println("added 34");
        l.add("35");        System.out.println("added 35");
        
    }
}

Got Output


inside main THREAD
added 1
added 2
added 3
added 4
thread started 
added 5
got the iterator 
added 11
added 12
added 13
added 14
added 15
added 21
added 22
added 23
added 24
added 25
added 31
added 32
added 33
added 34
added 35

If you want to iterate through "Filtered Collection" try this

Java Collections

2008-05-15T04:59:00.000-07:00

Framework consisits of three parts

interfaces -
implementation - of above interfaces
algorithms - general applicable to either interfaces / implementation

Interfaces

Collection - A collection represents a group of objects, known as its elements. may or may not have duplicate elements .. defines no order. JDK has no direct implementation of this interface.
List - defines order , may have dup
Set - no dup
SortedSet - set with order
Map - not part of hierarchy , just store key value pairs

Implementations
Keeping the two concepts ( interface & implementation) seperate can help you write code like

List l = new ....{ }

You can change implementation when your business condition require you to do so

<>

LinkedList is gr8 if u want to add/remove data from middle , if you want indexed access then ArrayList is better

All implementations are unsynchronised
All implementations offer fail fast iterators
All implementations are serializable and cloneable
All implementations support having null elements

Collection - A collection represents a group of objects, known as its elements. may or may not have duplicate elements .. defines no order. JDK has no direct implementation of this interface.
List - defines order , may have dup
Set - no dup
SortedSet - set with order
Map - not part of hierarchy , just store key value pairs

Implementations
Keeping the two concepts ( interface & implementation) seperate can help you write code like
List l = new ....{ }
You can change implementation when your business condition require you to do so

INTERFACE	HASH TABLE	RESIZABLE ARRAY	BALANCED TREE	LINKED LIST	HISTORICAL
SET	Hah Set		TreeSet
SORTEDSET			TreeSet
LIST		ArrayList		LinkedList
MAP	HashMap WeakHashMap		TreeMap		Vector Stack HashTable Properties
SORTEDMAP			TreeMap

LinkedList is gr8 if u want to add/remove data from middle , if you want indexed access then ArrayList is better

All implementations are unsynchronised
All implementations offer fail fast iterators
All implementations are serializable and cloneable
All implementations support having null elements

Algorithm
the Collections class has methods that allow you to perform action on these data
This class consists exclusively of static methods that operate on or return collections.
Has static variables like EMPTY_LIST , EMPTY_MAP , EMPTY_SET
methods like binarySearch , min , max , reverse

java.util.Collection
All general-purpose Collection implementation classes (which typically implement Collection indirectly through one of its subinterfaces) should provide two "standard" constructors: a void (no arguments) constructor, which creates an empty collection, and a constructor with a single argument of type Collection, which creates a new collection with the same elements as its argument.

Adding Elements
public boolean add(Object a) -- can only throw UnsupportedOperation exception , not nullpointerExcep
public boolean addAll(Collection c)

Removing Elements
public void clear()
public boolean remove(Object elem)
public boolean removeAll(Collection c)
if original was {1,5,3,8,1,8,2,4,1,3,7,6}
and passed list is {1,7}
every instance of 1 nad 7 will be removed
you get {5,3,8,8,2,4,3,6}

public boolean retainAll(Collection c)
opposite of remove

public Iterator iterator()

finding elements
public boolean contains(Object elem)
public boolean containsAll(Collection c)

checking size
public int size()
public boolean isEmpty()

copy and cloning collection
public Object[] toArray( )
public Object[] toArray(Object[] a)
consults the passed collection in terms of return type and size
if collections.siz() <= a.size() ... elements are returned in array and returned


Collection c = ....
String array[] = new String[c.size()];
array = (String[])c.toArray(array);

check for equality
public boolean equals(Object o)
Note besides Object.equals() interface also has this method to imphasize the fact that need to override Its not necessary to override the Object.equals( ) The general contract for the Object.equals method states that equals must be symmetric (in other words, a.equals(b) if and only if b.equals(a)). The contracts for List.equals and Set.equals state that lists are only equal to other lists, and sets to other sets. Thus, a custom equals method for a collection class that implements neither the List nor Set interface must return false when this collection is compared to any list or set. -- dont try to add colection to itself


       List l = new ArrayList(6);
       l.add("1");
       System.out.println("added 1");
       l.add("2");
       System.out.println("added 2");
       l.add(l);
       System.out.println("KABOOM !!");
       Iterator listItr = l.iterator();
       while(listItr.hasNext())
               System.out.println("val is "+listItr.next());

I got the output


added 1
 added 2
 KABOOM !!
 val is 1
 val is 2
 val is [1, 2, (this Collection)]

collection VS Collection VS Collections

Java Garbage Collection

2008-05-15T03:15:00.000-07:00

A garbage collector is responsible for

allocating memory
ensuring that any referenced objects remain in memory, and
recovering memory used by objects that are no longer reachable from references in executing code.

Space is allocated by a large space called heap. The JVM's heap stores all objects created by an executing Java program. Objects are created by Java's "new" operator, and memory for new objects is allocated on the heap at run time.

In addition to freeing unreferenced objects, a garbage collector may also combat heap fragmentation. Heap fragmentation occurs through the course of normal program execution. New objects are allocated, and unreferenced objects are freed such that free blocks of heap memory are left in between blocks occupied by live objects

Code for System.gc is as follows


public static void gc() {
 Runtime.getRuntime().gc();
}

System.gc() is just more convinient to call/use


freeMem = Runtime.getRuntime().freeMemory();
System.gc();
System.out.println("free memory after running gc(): " + freeMem);


Interesting links
http://chaoticjava.com/posts/garbage-collection-the-comic-panel/
http://chaoticjava.com/posts/how-does-garbage-collection-work/
http://chaoticjava.com/posts/parallel-and-concurrent-garbage-collectors/
http://chaoticjava.com/posts/gc-tips-and-memory-leaks/

Java and MS-Office

2008-05-14T06:00:00.000-07:00

Just in case ever need to

In Conference Java One 2008 , Oracle also gave demo on how to integrate MS-Excel with ADF

Java Strings Immutable

2008-05-14T02:45:00.000-07:00

Many modern languages (like java) employ “the immutable object” paradigm, which solves a lot of problems including the

Memory conservation
Addressing concurrency concerns
Cache localization

Memory Conservation - A pool of string objects ( constant ) is maintained with references pointing to the constant objects. Instead of each variable having new String object. Re usability leads to lesser memory usage.

Concurrency Concerns - if you change any string need to consider that more than one references may be pointing to same string , so if you will change that string all references must also be updated ( thats tough ) so a new object for changed string will be created and only that particular reference will be point to that new object hence actual object will never change.

I am not sure about cache localization ??

Linux : how to list directory only

2008-05-14T01:40:00.000-07:00

To see a listing of all directories in current directory

ls -l | grep ^d ( this will show names with details )
ls -d */ ( will how names only )

If you want to see hidden directory also

ls -d .*"/" *"/"
find . -type d -exec ls -d {} \;
find . -type d

JavaScript : String Performance

2008-05-13T21:51:00.000-07:00

Just wanted to book mark these two "excellent" blog entries ...

Servlets and Garbage Collection

2008-05-13T06:34:00.000-07:00

Basic Cycle

The destroy() method is called by the servlet container when the container decides to unload the servlet instance itself.
After the destroy() method completes, the servlet engine unloads the servlet,.
Then, the JVM eventually performs garbage collection on the memory resources associated with that servlet object.

Effecient Servlet : Goals

When can you say that a Servlet is efficient , well of course when it does your work in most effecient manner or in other words the algorithm/logic that you have in it is effecient... but there's more to its efficiency .. Read On !!

Secondly even for High volume Web applications, one needs to carefully control the amount of garbage created during page generation. More the garbage created, fewer the pages generated, and the slower is the response time for a particular request. ( This bottleneck occurs because the Java VM has to steal cycles to run garbage collection when it should be generating pages. ) On the flip side , if too much garbage is created, request processing could halt entirely. Which is unacceptable.

Third is to keep the browser active: not too much of "waiting for response" messages. To put it in programatic terms the time a bean spends querying backend is the time a user spends waiting for page to display. This can -- and should -- be avoided using servlet response streaming techniques.

All About Servlets : Run The Servlet

2008-05-13T06:12:00.000-07:00


import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.*;
import javax.servlet.http.*;

public class AllAboutServlet extends HttpServlet {
   private static final String CONTENT_TYPE = "text/html; charset=windows-1252";

  public AllAboutServlet() {
       System.out.println("CTOR : Servlet constructor can be overriden .. " +
       "should not be private , protected , nor default");
       System.out.println("CTOR : The ctor will be called by the container ... ");
       System.out.println("CTOR : At present its a normal java object .. " +
       "doesnt understand ServletContext and ServletConfig ");
       System.out.println("CTOR : Servlets are usually instantiated by the servlet " +
       "container using the Class.newInstance() method, with no arguments");
   }
 
   private AllAboutServlet(int i){
       System.out.println("Parameterized ctor value  "+i);
       System.out.println("It is possible to have a custom constructor for a servlet, " +
       "so long as you also add a default constructor with no arguments ?? WHY ??");
       System.out.println("the servlet gets instantiated by the container dynamically");
       System.out.println("java does not allow to call parametrized constuctor for dynamically " +
       "loaded clases");
   }
 
   public static void static_method(){
       System.out.println("Can have Static method in servlet .. who can call it ??");
       System.out.println("Probably no one is stopping other classes to use servlet to" +
       "instantiate amnd use it as a normal object ");
       System.out.println("Other classes may even call init() service() and then destroy() " +
       "that wont make it servlet.. unless container call");
       System.out.println("Only container can use servlet class as a servlet ");
   }  

   public void init(ServletConfig config) throws ServletException {
       System.out.println("INIT : Servlet init called .. now java object turns servlet .. " +
       "understands ServletContext and ServletConfig");
       System.out.println("INIT : perform one-time expensive operations, such as acquiring " +
       "thread-safe resource acquisition mechanisms ");
       // One effective use of the Servlet init method is the creation and caching of
        // thread-safe resource acquisition mechanisms, such as JDBC DataSources, EJB Homes,
        // and Web Services SOAP Mapping Registry. use this for caching data ...
        super.init(config);
       // COMPULSORY the abstract superclass implementation of the method in GenericServlet
        // stores the servlet configuration object.

       // If an exception is thrown in your init(ServletConfig) method, it may be appropriate
        // to use the destroy() method to help handle the case. If so, you should still throw
        // a ServletException to ensure the servlet is not put into service in this state.
    }

   public void doGet(HttpServletRequest request,
                     HttpServletResponse response) throws ServletException, IOException {response.setContentType(CONTENT_TYPE);
       PrintWriter out = response.getWriter();
       out.println("<html>");
       out.println("<head><title>AllAboutServlet</title></head>");
       out.println("<body>");
       out.println("<p>The servlet has received a GET. This is the reply.</p>");
       out.println("</body></html>");
       out.close();
     
       System.out.println("DOGET : doGet called ");
       System.out.println("DOGET : one may call delete() from inside service() ... It will do whatever logic you have in destroy() (cleanup, remove attributes, etc.) but it won't \"unload\" the servlet instance itself");
       System.out.println("");
   }

   public void doPost(HttpServletRequest request,
                      HttpServletResponse response) throws ServletException, IOException {response.setContentType(CONTENT_TYPE);
       PrintWriter out = response.getWriter();
       out.println("<html>");
       out.println("<head><title>AllAboutServlet</title></head>");
       out.println("<body>");
       out.println("<p>The servlet has received a POST. This is the reply.</p>");
       out.println("</body></html>");
       out.close();
   }

   public void doPut(HttpServletRequest request,
                     HttpServletResponse response) throws ServletException,
                                                          IOException {
   }

   public void doDelete(HttpServletRequest request,
                        HttpServletResponse response) throws ServletException,
                                                             IOException {
   }
 
   public void destroy(){
       System.out.println("DESTROY : destroy called by contianer .. when is it called ??" +
       "When your application is stopped or Servlet Container shuts down ");
       System.out.println("DESTROY : Not when embedded oc4j stopped ");
       System.out.println("DESTROY : destroy() does not imply garbage collection");
       System.out.println("DESTROY : write the destroy() method and destroy your servlet" +
       "because if many servlets running on the same webserver are not destroyed explicitly," +
       "then the performance of the web server falls down");
       System.out.println("DESTROY : destroy() is not guaranteed to be called... but if it is, " +
       "you should make sure it works right");
   }

   public void destroy(int i){
       System.out.println("may overload .. its syntactically ok ... container wont call this...");
   }
 
   public void point1() {
       System.out.println("Is it possible that the servlet container will call destroy()" +
       "while the servlet is still processing a request inside service() on a different thread ?");
       System.out.println("yes, but it's a degenerate case. The servlet container is required" +
       "to wait a reasonable amount of time for current requests to finish processing. So if your" +
       "request is not totally lagging, it should work out fine. If you're spending more than" +
       "a few seconds processing a request, that's a UI problem that you should try to work out first.");
   }
   public void point2() {
       // GenericServlet has methods ... init() destroy() log() getInitParameter() getInitParameterNames()
        // getServletContext() getServletConfig() getServletInfo() getServletName()
    }
   public void point3() {
       // HttpServlet is declared abstract because the default implementations of the main service methods
        // do nothing and must be overridden
    }
   public void point4() {
       // The HttpServletRequestWrapper and HttpServletResponseWrapper classes are designed to make it
        // easy for developers to create custom implementations of the servlet request and response types.
        // The classes are constructed with the standard HttpServletRequest and HttpServletResponse instances
        // respectively and their default behaviour is to pass all method calls directly to the underlying
        // objects.
    }

}

All About Servlets : Introduction

2008-05-13T05:21:00.000-07:00

The Servlet Philosophy
To write a server side program , need two things

Program at socket level .. handle all the incoming requests
Program at logical level .. write the correct response to each request

The Servlet API is based on simple philosophy , letting the programmers concentrate on the second option and taking care of first option by themselves.

Load On Startup
The element load-on-startup indicates that this servlet should be loaded (instantiated and have its init() called) on the startup of the Web application. The element content of this element must be an integer indicating the order in which the servlet should be loaded.

If the value is a negative integer, or the element is not present, the container is free to load the servlet whenever it chooses.
If the value is a positive integer or 0, the container must load and initialize the servlet as the application is deployed. The container must guarantee that servlets marked with lower integers are loaded before servlets marked with higher integers. The container may choose the order of loading of servlets with the same load-on-startup value.

When is destroy( ) called ?
I could think of following cases...

When your application is stopped
Servlet Container shuts down
In init( ) method if an exception is thrown

What if i call the destroy( ) explicitly
Nothing , it will just execute like a normal java method call it wont unload the servlet. The unloading happens only if the Container calls the destroy( ).

From the Spec

The servlet container is not required to keep a servlet loaded for any particular period of time. A servlet instance may be kept active in a servlet container for a period of milliseconds, for the lifetime of the servlet container (which could be a number of days, months, or years), or any amount of time in between.

When the servlet container determines that a servlet should be removed from service, it calls the destroy method of the Servlet interface to allow the servlet to release any resources it is using and save any persistent state. For example, the container may do this when it wants to conserve memory resources, or when it is being shut down.

Before the servlet container calls the destroy method, it must allow any threads that are currently running in the service method of the servlet to complete execution, or exceed a server-defined time limit.

Once the destroy method is called on a servlet instance, the container may not route other requests to that instance of the servlet. If the container needs to enable the servlet again, it must do so with a new instance of the servlet’s class.

After the destroy method completes, the servlet container must release the servlet instance so that it is eligible for garbage collection.

Can I use a constructor instead of init(ServletConfig) ?
Servlet constructor can be overriden .. not be private , protected , nor default The constructor will be called by the container. In the constructor it doesn't understand classes like ServletContext and ServletConfig.

It is possible to have a custom constructor for a servlet, so long as you also add a default constructor with no arguments the servlet gets instantiated by the container dynamically java does not allow to call parametrized constuctor for dynamically loaded clases

It is possible to have a custom constructor for a servlet, so long as you also add a default constructor with no arguments, but constructors are not called in the standard servlet lifecycle. Servlets are usually instantiated by the servlet container using the Class.newInstance() method, with no arguments. At this point, the servlet has no reference to its configuration or the general servlet context, so it cannot do any useful start-up activity. These configuration references are only available through the init(ServletConfig) method.

Why is it necessary to call super.init(config)?

Programmers are expected to call the super.init(ServletConfig) in the init(ServletConfig) method so that the abstract superclass implementation of the method in GenericServlet stores the servlet configuration object. When the configuration object is stored in this way, the servlet methods getInitParameter(String) and getInitParameterNames() can be called instead of calling the equivalent methods on the configuration object.

Should I get my database connection in the init() method?

The init(ServletConfig) method is only called once when a servlet is brought into service by the servlet container, not for each new servlet thread. If you create a single database connection in the init(ServletConfig) method and use it to all handle servlet requests, you must ensure all operations are synchronized or you will get unpredictable results. You must also ensure the connection is closed when the servlet is taken out of service by overriding the servlet's destroy() method.

Generally it is better to use the init(ServletConfig) method to register the database driver and get a reference to the DriverManager, a DataSource or database connection pool. Then use the connection provider to get a connection for each request within a try/catch block. This way you can handle the case where the connection fails, and ensure that all connections are closed in any case. The close() method of a pooled Connection instance just returns it to the pool.

What's the difference between ServletConfig and ServletContext?

The ServletContext object - represents the context for the whole Web application in which a servlet is deployed, and contains initialisation parameters that are shared amongst all servlets in the application.
The ServletConfig object - represents the configuration for a single specific servlet.

How can I load a Properties file for my servlet?

There are standard methods for identifying and loading this type of static property set into servlets via the ServletContext object. The primary method is getResourceAsStream(String path), which opens an InputStream to the path given in the argument. The path must begin with a forward slash, /, and is relative to the context root, so for instance you might use the path:
/WEB-INF/servlet.properties

Is it possible to overload the destroy() method?

Any Java method may be overloaded, but the overloaded version will not be called directly by a servlet container's lifecycle methods. The servlet container expects all servlets to have a standard no argument destroy() method, so your servlet is safe to use destroy methods with other signatures.

    public void destroy(final String arg) {
   // Overloaded method body
    }

Can I call destroy() from the service() method ?

The destroy() method has a special significance in the servlet lifecycle when it is called by the servlet container, but is a normal method in all other respects. If you have a typical destroy() method that does servlet clean-up work before the servlet is taken out of service, it is difficult to imagine why you would want to call it from the service() method, though it is possible. Normally, you should handle service requests by overriding the relevant doGet() or doPost() method.

What happens if I call destroy() from init() ?

If the destroy() method is called from the init(ServletConfig) method, whatever statements are contained in the method will be executed and the method will return, it will not affect the lifecycle status of the servlet from the container's point of view. If the init(ServletConfig) method returns without exception, the servlet container will put the servlet into service regardless.

If an exception is thrown in your init(ServletConfig) method, it may be appropriate to use the destroy() method to help handle the case. If so, you should still throw a ServletException to ensure the servlet is not put into service in this state.

Can have Static method in Servlet .. If yes , who can call it ??
Probably no one is stopping other classes to use servlet to instantiate and use it as a normal object Other classes may even call init() service() and then destroy() that wont make a java object a servlet.. unless container calls the same methods Only container can use java class as a servlet.

Summary
To sum up basically a Servlet first becomes a Java object and then a Servlet. I mean a container will first make a Java Object then convert it to Servlet Instance.

You can very well use this as a java object ( in case you call destroy( ) from init( ) etc) but it wont effect the lifeCycle of a servlet. Life cycle of servlet is decided and executed by container servlets cant manage / change their own life cycle by calling there methods.

Flex 2 : Intro

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

One might think why blog about Flex2 .. when Flex 3 is out ?
well even i dont know why ? all i can say is ... I like flex so thought need to start somewhere !

FLEX

Flex application take advantage of Flash player 9 runtime environment ( which inturn supports 3 ) Flex application can also interact with Javascript.

Flex 2 SDK consists of

the Flex framework (class library)
the Flex compilers,
the debugger,
the MXML
ActionScript programming languages
other utilities.

Flex applications consist of MXML ( set up the UI ) and ActionScript source files

MXML is used for

Visual components - set up UI
Non visual components - acess network based components ( like webservice ) server based resorces ( flex data service ) bindings ( between UI & data )

ActionScript - provides flowcontrol and object manupilation features

Flex applications do not directly connect to a database, you use other tools and services
such as PHP, ASP, JSP, Web services, Flex Data Services, ColdFusion Flash Remoting Services,
and so on.

The Flex platform supports a range of deployment models:

Client-side only Applications run on the client and use no server resources.
Access server data through simple RPC services - Applications interact with remote data through web services and HTTP services. The Flex HTTPService and WebService tags let you retrieve data from a remote server For security, by default Flash Player does not allow an application to access a remote data source from a domain other than the domain from which the application was served. Therefore, a remote server must either be in the same domain as the server hosting your application, or the remote server must define a crossdomain.xml file.
Flex Data Services - used to provide advanced features, such as data synchronization, security, and messaging.

Flex supports two versions of Flash Player

standard flash player
debug flash player

Some questions i couldnt answer
doesnt Flex use Http request / response at low level ? if yes then how ?
if yes why is it so fast than JSF etc ? may be because of Flash player ??

May be when i read more will be able to do so

Interesting Link
http://coenraets.org/testdrive/flex4j/index.htm

Object.hashcode VS System.identityHashCode

2008-05-08T11:06:00.000-07:00

basically System.identityHashCode (Object) always returns different values for different objects
Its declared as public static int identityHashCode(Object x)

The hash code for the null reference is zero.


// FileName Test.java
class HashCodeTest
{
    int number;
    public HashCodeTest(int i)
    { this.number=i;}

    public int hashCode() { return this.number; }
}

public class Test
{
    public static void main(String[] args)
    {
        String s1="Namaste"; String s2 = s1;
        System.out.println("s1 "+ s1 + " s2 "+ s2);
        System.out.println("System.identityHashCode(s1)"  + System.identityHashCode(s1));
        System.out.println("System.identityHashCode(s2) "+ System.identityHashCode(s2));
        s1=s1 + " World";
        System.out.println(" s1 "+ s1 + " s2 " + s2);
        System.out.println("System.identityHashCode(s1) " + System.identityHashCode(s1));
        System.out.println("System.identityHashCode(s2) "+ System.identityHashCode(s2));

        HashCodeTest o1 = new HashCodeTest(5);
        HashCodeTest o2 = new HashCodeTest(5);

        System.out.println("");
        System.out.println("First Object : " + o1);
        System.out.println("Second Object : " + o2);
        System.out.println("System.identityHashCode(First_Object) : " + System.identityHashCode(o1));
        System.out.println("System.identityHashCode(Second_Object) : " + System.identityHashCode(o2));
    }
}

the output was something like

s1 Namaste s2 Namaste
System.identityHashCode(s1)1671711
System.identityHashCode(s2) 1671711
s1 Namaste World s2 Namaste
System.identityHashCode(s1) 11394033
System.identityHashCode(s2) 1671711

First Object : HashCodeTest@5
Second Object : HashCodeTest@5
System.identityHashCode(First_Object) : 4384790
System.identityHashCode(Second_Object) : 9634993

String.split( ) VS stringTokenizer

2008-05-08T11:05:00.000-07:00

tring.split() was introduced in jdk 1.4'

For one thing, StringTokenizer returns one substring at a time whereas the split method returns an array of substrings.
Best to use String's split(...) method. The StringTokenizer class is a legacy class (NOT deprecated)

By default, StringTokenizer uses whitespace to delimit tokens, and if there are two or more delimiter characters
in a row, it collapses them into one delimiter. So the split() equivalent would be

String[] result = "this is a test".split("\\s+");

But if you really want to treat each character as a separate delimiter, you just remove the plus sign again.
This is, in my opinion, the best reason to choose split(); while there is a way to do single-character delimiters in StringTokenizer, it's kludgy and awkward.

And yes, StringTokenizer is inherently faster,

StringTokenizer can split strings based on single characters, split() takes regular expressions.
I imagine that might make split() a bit slower when splitting for single characters (can't be arsed to test it
though), but usually it's more handy.

Business WebService VS Normal WebService

2008-05-05T01:32:00.000-07:00

Business WebService demands the following extra features

Security - Obvious
Context - when one webservice needs to call another can pass security context need to pass extra context parameter.
Transactions - Business Transaction Protocol can help us manage it
Process Flow - Controlling the process Flow

SOAP

2008-05-01T05:04:00.000-07:00

SOAP - Stands for Simple Object Access Protocol

Simple - transport accross HTTP using Http (mime) and SMTP headers using XML. So is XML simple ? It can be as simple or complex u want it to be. Is MIME simple? It is simple only because it uses a data formatting convention that is already in widespread use, is familiar to most IT people, and is conceptually understood by less technical people.
Object - has to do with ways of accessing object
Access - A key feature of SOAP and web services is their accessibility. Possible to create SOAP binding for almost any protocol.
Protocol - Its a rule.

SOAP messages are fundamentally one-way transmissions from a SOAP sender to a SOAP receiver; however, SOAP messages are often combined to implement patterns such as request/response.

whats the use and difference beween xsi and xsd namespace used in SOAP ??
for example xsi:type , and from xsd you get xsd:string or xsd:boolean

Http has a SOAPAction header.

Its easy to write a program that reads XML document and and wraps it inside SOAP message and send to URL. The class org.apache.soap.Envelope ( extends Lang.Object ) has a default constructor. Similarly org.apache.soap.Body has default constructor and method setBodyEntries(java.util.Vector).


// Build the Message.
org.apache.soap.messaging.Message msg = new org.apache.soap.messaging.Message( );
msg.send (new java.net.URL(m_hostURL), URI, envelope);
org.apache.soap.transport.SOAPTransport st = msg.getSOAPTransport ( );
BufferedReader br = st.receive ( );

JAXB

2008-05-01T03:17:00.000-07:00

How do you access and use an XML document through the Java ? Two ways

JAXP - Use Java API for XML Processing (JAXP) ( ie either SAX or DOM )
JAXB - Java Architecture for XML Binding (JAXB)

we can modify the second way as two step process

Bind the Schema for XML document into a set of Java classes ( and interface ) that represents the schema. All JAXB implementations provide a tool called a binding compiler to bind a schema (the way the binding compiler is invoked can be implementation-specific).
Unmarshal the document into Java content objects. Unmarshalling an XML document means creating a tree of content objects that represents the content and organization of the document. The content tree is not a DOM-based tree. In fact, content trees produced through JAXB can be more efficient in terms of memory use than DOM-based trees.

The binding framework comprises three packages. The primary package, javax.xml.bind, contains classes and interfaces for performing operations such as unmarshalling, marshalling, and validation (marshalling and validation will be covered later). A second package, javax.xml.bind.util, contains a number of utility classes. The third package, javax.xml.bind.helper, is designed for JAXB implementation providers.

(1) Get Classes from XML
To unmarshal an XML document, you:

Create a JAXBContext object. This object provides the entry point to the JAXB API. When you create the object, you need to specify a context path. This is a list of one or more package names that contain interfaces generated by the binding compiler. By allowing multiple package names in the context path, JAXB allows you to unmarshal a combination of XML data elements that correspond to different schemas.


import javax.xml.bind.JAXBContext;
JAXBContext jc = JAXBContext.newInstance("test.jaxb");

Create an Unmarshaller object.


import javax.xml.bind.Unmarshaller;
Unmarshaller unmarshaller = jc.createUnmarshaller();

Call the unmarshal method


unmarshaller.setValidating(true);// validate source data against schema
Collection collection= (Collection)unmarshaller.unmarshal(new File( "books.xml"));

Here the Collection is the base xml element not java.util.Collection

Use the get methods in the schema-derived classes to access the XML data.

you can unmarshal XML data from other input sources such as an InputStream object, a URL, or a DOM node. You can even unmarshal transformed XML data.

JAXB also allows you to access XML data without having to unmarshal it. One of the classes generated from a schema, ObjectFactory, contains methods to generate objects for each of the schema-derived interfaces and classes. For example, ObjectFactory class that has methods such as createElement_Name to create a object corresponding to Node in the XML document. You can use these methods to create a tree of content objects without doing any unmarshalling. All your program needs is access to the ObjectFactory class that's in the package for the pertinent schema. Then you can use the appropriate methods in the ObjectFactory class to create the objects you need. After you create the objects, you need to provide their content. To do that, you use the set methods in the objects.

(2) Write XML from Classes
you would:

* Bind the schema for the XML document (if it isn't already bound - same as above)
* Create the content tree.


   ObjectFactory objFactory = new ObjectFactory();
   Collection collection=(Collection) objFactory.createCollection(); // collection is element name
   Collection.BooksType booksType = objFactory.createCollectionTypeBooksType(); // books is element name ( acts as a conatiner )
   BookType book = objFactory.createBookType(); // its a element name

Then use set methods in the created objects to specify data values. For example:


       book.setItemId("307");
       book.setName("JAXB today and beyond");

* Marshal the content tree into the XML document.


   import javax.xml.bind.JAXBContext;
   import javax.xml.bind.Marshaller;
   // step 1 - create context
   JAXBContext jaxbContext = JAXBContext.newInstance("test.jaxb");
   // step 2 - create marshaller
   Marshaller marshaller = jaxbContext.createMarshaller();
   marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,new Boolean(true));
   // step 3 - call marshal
   marshaller.marshal(collection,new FileOutputStream("jaxbOutput.xml"));

Notice that validation is not performed as part of the marshalling operation. In other words, unlike the case for unmarshalling, there is no setValidating method for marshalling. Instead, when marshalling data, you use the Validator class that is a part of the binding framework to validate a content tree against a schema. For example:


import javax.xml.bind.Validator;

Validator validator = jaxbContext.createValidator();
validator.validate(collection))

(3) Updating XML document

References
http://java.sun.com/developer/technicalArticles/WebServices/jaxb/
http://wiki.java.net/bin/view/Javawsxml/JaxbArticles

Java Annotations

2008-05-01T02:17:00.000-07:00

Annotations in General
Basically it is the Metadata a syntactitcal way of adding metadata to source doe
Differences in computer languages have given rise to a variety of words for programmer-added metadata, including annotation (Java, Python), attribute (C#), pragma (C), and metadata (HTML).

Java Annotations
Annotations provide data about a program that is not part of the program itself. They have no direct effect on the operation of the code they annotate.Annotations are modifiers you can add to your code and apply to package declarations, type declarations, constructors, methods, fields, parameters, and variables.

JSR 175, A Metadata Facility for the Java Programming Language, gives more details on it.

The Interface java.lang.annotation.Annotation is extended by all annotation types. Note that an interface that manually extends this one does not define an annotation type. Also note that this interface does not itself define an annotation type.

J2SE 5 comes with following prebuilt annotations...

(1) java.lang.Overrides - If a method is decorated with this annotation type but does not override a superclass method, then the compiler will generate an error message... may be if one gives incorrect argument type then function will be overloaded so its better use this.
Should be used only on methods (not on classes, package declarations, or other constructs)


@Override
   interface Closable {
       void close();
   }

   class File implements Closable {
       @Override
       public void close() {
           //... close this file...
       }
   }

The compiler generates an error complaining that File.close doesn't override any method from its superclass. This is because it is not overriding Closable.close, it is implementing it!

While it's not required to use this annotation when overriding a method, it helps to prevent errors. If a method marked with @Override fails to correctly override a method in one of its superclasses, the compiler generates an error.

(2) java.lang.annotation.Documented
This annotation indicates that the annotation to which this is applied is to be documented by javadoc and similar tools. Note that this annotation is just a hint, and a tool can ignore the annotation if it desires to do so.

(3) java.lang.Deprecated
This annotation provides a hint to the Java compiler to warn users if they use the class, method, or field annotated with this annotation.
When an element is deprecated, it should also be documented using the Javadoc @deprecated tag, as shown in the following example. The use of the "@" symbol in both Javadoc comments and in annotations is not coincidental—they are related conceptually. Also, note that the Javadoc tag starts with a lowercase "d" and the annotation starts with an uppercase "D".


      // Javadoc comment follows
       /**
        * @deprecated
        * explanation of why it was deprecated
        */
       @Deprecated
       static void deprecatedMethod() { }
   }

(4) java.lang.annotation.Inherited
Indicates that an annotation type is automatically inherited. If an Inherited meta-annotation is present on an annotation type declaration, and the user queries the annotation type on a class declaration, and the class declaration has no annotation for this type, then the class's superclass will automatically be queried for the annotation type. This process will be repeated until an annotation for this type is found, or the top of the class hierarchy (Object) is reached. If no superclass has an annotation for this type, then the query will indicate that the class in question has no such annotation.

(5) java.lang.annotation.Retention
The Retention annotation takes a single parameter that determines the decorated annotation's availability. The values of this parameter are:

RetentionPolicy.SOURCE: The decorated annotation is available at the source code level only
RetentionPolicy.CLASS: The decorated annotation is available in the source code and compiled class file, but is not loaded into the JVM at runtime
RetentionPolicy.RUNTIME: The decorated annotation is available in the source code, the compiled class file, and is also loaded into the JVM at runtime

By default, all annotations are available at the source level only.

(6) java.lang.annotation.Target
This annotation is used to indicate the type of program element (such as a class, method, or field) to which the declared annotation is applicable. If the Target annotation is not present on an annotation type declaration, then the declared type may be used on any program element. If the Target annotation is present, then the compiler will enforce the specified usage restriction. Legal values for the Target annotation are contained in the java.lang.annotation.ElementType enumeration.

(7) SuppressWarnings


@SuppressWarnings("deprecation")
       void useDeprecatedMethod() {
           objectOne.deprecatedMethod(); //deprecation warning - suppressed
       }

Every compiler warning belongs to a category. The Java Language Specification lists two categories: "deprecation" and "unchecked." The "unchecked" warning can occur when interfacing with legacy code written before the advent of generics (discussed in the lesson titled "Generics"). To suppress more than one category of warnings, use the following syntax:


   @SuppressWarnings({"unchecked", "deprecation"})

consider the following code:


 int a;
 Object object = new Object();

I declared two variables and did nto use them in my code. When I compiled the code, I got 2 warnings:


The local variable a is never read
The local variable object is never read

To remove the warnings, I will use the @SuppressWarnings annotation.


@SuppressWarnings("unused")
Object object = new Object();
@SuppressWarnings("unused")
int a;

// Suppress warnings about missing serialVersionUID
  @SuppressWarnings( "serial" ) public void myMethod1()

Note that @SuppressWarnings(value={"unchecked"}) is same as @SuppressWarnings("unchecked")

Assertion Exception

AnnotationTypeMismatchException
Its a runtime exception. Thrown to indicate that a program has attempted to access an element of an annotation whose type has changed after the annotation was compiled (or serialized).

IncompleteAnnotationException
Its a RuntimeException
Thrown to indicate that a program has attempted to access an element of an annotation type that was added to the annotation type definition after the annotation was compiled (or serialized). This exception will not be thrown if the new element has a default value.

Custom Annotation
From Structure point of view Annotations fall into three basic categories:

* Marker annotations have no variables. The annotation simply appears, identified by name, with no additional data supplied. For example, @MarkerAnnotation is a marker annotation. It includes no data, just the annotation name.
An annotation type with no elements is termed a marker annotation type, for example:


   /**
    * Indicates that the specification of the annotated API element
    * is preliminary and subject to change.
    */
   public @interface Preliminary { }

It is permissible to omit the parentheses in marker annotations, as shown below:


   @Preliminary public class TimeTravel { ... }

* Single-value annotations are similar to markers, but provide a single piece of data. Because only a single bit of data is supplied, you can use a shortcut syntax (assuming the annotation type is defined to accept this syntax): @SingleValueAnnotation("my data"). This should look a lot like a normal Java method call, aside from the @ sign.

In annotations with a single element, the element should be named value, as shown below:


   /**
    * Associates a copyright notice with the annotated API element.
    */
   public @interface Copyright {
       String value();
   }

It is permissible to omit the element name and equals sign (=) in a single-element annotation whose element name is value, as shown below:


   @Copyright("2002 Yoyodyne Propulsion Systems")
   public class OscillationOverthruster { ... }

* Full annotations have multiple data members. As a result, you must use a fuller syntax (and the annotation doesn't look quite so much like a normal Java method anymore):

 @FullAnnotation(var1="data value 1", var2="data value 2", var3="data value 3"). <


   @interface ClassPreamble {
      String author();
      String date();
      int currentRevision() default 1;
      String lastModified() default "N/A";
      String lastModifiedBy() default "N/A";
      String[] reviewers();  // Note use of array
   }

The annotation type definition looks somewhat like an interface definition where the keyword interface is preceded by the @ character (@ = "AT" as in Annotation Type). The body of the annotation definition above contains annotation type element declarations, which look a lot like methods. Note that they may define optional default values.


// this code lives in a file called Copyright.java
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/**
* embedded copyright
*/
@Documented
@Retention(RetentionPolicy.RUNTIME) @interface Copyright
   {
// ------------------------------ FIELDS ------------------------------

   /**
    * copyright to embed via annotations so it is embedded in all classes that reference it
    */
   String defaultCopyright =
           "copyright (c) 1998-2008 Roedy Green, "
           + "Canadian Mind Products, http://mindprod.com";
// -------------------------- PUBLIC INSTANCE  METHODS --------------------------
   /**
    * get value of this annotation
    *
    * @return the copyright string
    */
   String value() default defaultCopyright;
   }

Annotation Uses
In general, annotations benefits falls into three categories: documentation, compiler checking, and code analysis.

Documentation : is probably the least relevant reason for adding metadata to the Java language. Javadoc is very powerful.
Code Analysis :
Compiler Checking : like Override

Annotations allow programmers to decorate Java code with their own attributes. These attributes can be used for code documentation, code generation, and, even during runtime, for providing special services such as enhanced business-level security or special business logic.

Metadata provides a helpful way to indicate if methods are dependent on other methods, if they are incomplete, if a certain class must reference another class, and so on. This is indeed useful, but documentation is probably the least relevant reason for adding metadata to the Java language. Javadoc already provides a fairly easy-to-understand and robust way to document code. Besides, who wants to write a documentation tool when one already exists and works fine for the most part?

Many APIs require a fair amount of boilerplate code. For example, in order to write a JAX-RPC web service, you must provide a paired interface and implementation. This boilerplate could be generated automatically by a tool if the program were “decorated” with annotations indicating which methods were remotely accessible.

Other APIs require “side files” to be maintained in parallel with programs. For example JavaBeans requires a BeanInfo class to be maintained in parallel with a bean, and Enterprise JavaBeans (EJB) requires a deployment descriptor. It would be more convenient and less error-prone if the information in these side files were maintained as annotations in the program itself.

used to create documentation
used to track down dependencies in code
used to perform rudimentary compile-time checking.

The more advanced uses of annotations include writing an annotation processor that can read a Java program and take actions based on its annotations.

and should be run by the testing tool:

import java.lang.annotation.*;

/**
* Indicates that the annotated method is a test method.
* This annotation should be used only on parameterless static methods.
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Test { }

Note that the annotation type declaration is itself annotated. Such annotations are called meta-annotations. The first (@Retention(RetentionPolicy.RUNTIME)) indicates that annotations with this type are to be retained by the VM so they can be read reflectively at run-time. The second (@Target(ElementType.METHOD)) indicates that this annotation type can be used to annotate only method declarations.

Here is the testing tool:


   import java.lang.reflect.*;

   public class RunTests {
      public static void main(String[] args) throws Exception {
         int passed = 0, failed = 0;
         for (Method m : Class.forName(args[0]).getMethods()) {
            if (m.isAnnotationPresent(Test.class)) {
               try {
                  m.invoke(null);
                  passed++;
               } catch (Throwable ex) {
                  System.out.printf("Test %s failed: %s %n", m, ex.getCause());
                  failed++;
               }
            }
         }
         System.out.printf("Passed: %d, Failed %d%n", passed, failed);
      }
   }

References *
http://mindprod.com/jgloss/annotations.html
http://java.sun.com/docs/books/tutorial/java/javaOO/annotations.html
http://www.javaworld.com/javaworld/jw-07-2004/jw-0719-tiger3.html
http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html
http://www.ibm.com/developerworks/java/library/j-annotate1/index.html

Collection and Set interface

2008-04-28T23:01:00.001-07:00

Its easy to note that the collection interface and set interface both have same methods... but the Set interface doesnt allow duplicates and the Collection interface does allow.. why is it so ??

Reason ...
Every Set IS A Collection. The reason to extend Collection is that the contract is different. Collection says nothing about duplicates. Set is not allowed to contain duplicates. Even though there are no additional methods in Set, as a developer, we know that a Set will have this additional characteristic. If there is a parameter declared as a Set, then any developer using it knows that it will not contain duplicates, and any developer assigning to it knows that he can't use a collection that allows duplicates.

why a servlet is preferred for JDBC

2007-12-25T04:31:00.000-08:00

Servlet is preferred for JDBC code and not a static initializer block in a Class because the latter will be able to provide connections only when the static initializer block is run not before that ...
on the other hand ... servlet can be loaded on startup

Google : Open Social

2007-12-25T04:06:00.000-08:00

Really interesting stuff ...
one can even make web sites that uses "Open Social API"
benefits of open social for

developer .. they have more clients
consumers ... they have more apps

Makes sense !! heres how ....

http://code.google.com/apis/opensocial/

enables one to make application that can be used accross social networks !!

All about ADF tables

2007-12-12T08:02:00.000-08:00

How do i make a ADF TreeTable ??
Saying it in very simple terms ... (i) first make POJOs ... using parent POJO and child POJO make a tree like hierarchy (ii) then using the ADF model classes convert them into ADF treeTable model !

Step one sounds easy .. can i have more details on step two ?
In ADF we have the following hierarchy...

java.lang.Object
   javax.faces.model.DataModel
      oracle.adf.view.faces.model.CollectionModel
         oracle.adf.view.faces.model.TreeModel
            oracle.adf.view.faces.model.ChildPropertyTreeModel

javax.faces.model.DataModel
has default constructor
inherits directly from java.lang.Object
The data collection underlying a DataModel instance is modeled as a collection of row objects that can be accessed by a zero-relative cursor (row index). The APIs provide mechanisms to position to a specified zero-relative row index, and to retrieve an object that represents the data that corresponds to the current row index.
DataModel is an abstraction around arbitrary data binding technologies that can be used to adapt a variety of data sources for use by JavaServer Faces components that support per-row processing for their child components
has a property rowIndex that starts from 0 ... up to max_no_of_child
has other methods like getRowData() getRowCount() .. setWrappedData() and getWrappedData() .. they set the object representing the data collection wrapped by this DataModel

oracle.adf.view.faces.model.CollectionModel
implements no RowKeyIndex
has default ctor
The data model that is used by ADF Table components. This extends the faces DataModel class and adds on support for rowKeys and sorting.

*** oracle.adf.view.faces.model.TreeModel ***
It just has a default constructor ...

rows in a treeModel may contain other rows...
to figure out if current row is a container use method isContainer()
If a row is a container, use the enterContainer() method to access its child rows. Once the enterContainer() method is called all the CollectionModel API's methods (like DataModel.getRowCount()) operate on the child collection. To return back to the parent row, use the exitContainer() method.

|-Root1 (rowKey="r1", rowIndex=0)
| |-Folder1 (rowKey="r1f1", rowIndex=0)
| | |-Node1 (rowKey="r1f1n1", rowIndex=0)
| | |-Node2 (rowKey="r1f1n2", rowIndex=1)
| | |-Node3 (rowKey="r1f1n3", rowIndex=2)
| |
| |-Folder2 (rowKey="r1f2", rowIndex=1)
| |-Node4 (rowKey="r1f2n1", rowIndex=0)
|
|-Root2 (rowKey="r2", rowIndex=1)
|-Root3 (rowKey="r3", rowIndex=2)
|-Root4 (rowKey="r4", rowIndex=3)

so each row has a setRowKey() and setRowIndex() ... rowKey is inherited from CollectionModel and rowIndex from DataModel... the rowKey is unique accross the whole table ... rowIndex is relative to its parent ...
use setRowKey(null) to reach the root ...

To access Node4 use:

setRowIndex(0); // isContainer()==true
enterContainer(); // enter Root1, getRowCount()==2
setRowIndex(1); // isContainer()==true
enterContainer(); // enter Folder2, getRowCount()==1
setRowIndex(0); // isContainer()==false
getRowData(); // To access a particular row in the list, first make that row current, and then call the getRowData() method on the Table

Or, more simply:
setRowKey("r1f2n1");
getRowData();

*** oracle.adf.view.faces.model.ChildPropertyTreeModel ***
It extends TreeModel

Creates a TreeModel from a List of beans. To use this class you must have a tree of beans (or Maps). The structure of your tree must be a List (or array) of root beans, and each bean must have a getter method (or Map property) that returns the children List. All elements of your tree must be the same type.

Tree VS TreeModel
The Tree component displays a multi-root hierarchy in a simple UI... the TreeTabel displays a single-root hierarchy

You may find the oracle.adf.view.faces.model.ChildPropertyTreeModel class useful when constructing a TreeModel

*** the ***
The "nodeStamp" facet of the Tree is used to display the data for each element in the tree. The Tree does not create components per element; instead, the "nodeStamp" is repeatedly rendered (stamped) once per element. Because of this stamping behavior, only certain types of components are supported as children inside a Tree. Supported components include all components with no behavior and most components that implement the EditableValueHolder or ActionSource interfaces.
The Tree renders expand/collapse icons that the user can click on to expand or collapse a subtree. When these icons are clicked, the Tree generates a DisclosureEvent

The immediate children of a Table component must all be < af:column > components.
Use the "header" facet on a Column to create the column header.
The child components of each Column display the data for each row in that column.... that means it may be a textbox , a label , a textArea etc ...
Column does not create child components per row; instead, each child is repeatedly rendered (stamped) once per row... that means if there are 10 rows then the column elemnt will not create 10 children insteand 10 times rows will be created and each time one element for the column is created

Because of this stamping behavior, some components many not work inside the table. Anything that is just pure output, with no behavior, will work without problems, as will components that don't "mutate" even as they deliver events

one can have column groups ...

Columns can be rendered as row headers by setting the "rowHeader" attribute on < column > to be true. Row header columns must be the first columns in a table.

Range Navigation
When the list being displayed by a Table is huge, you can enable the Table to break up the list into ranges and display a single range at a time. Range controls are provided on the Table to let the user scroll to the next range, or to go back to the previous range.
thi smay also generate RangeChangeEvent

Displaying Details
You can configure the Table to display or hide additional details of a particular row in response to a user gesture. When the details feature is enabled, a new column containing a toggle (per row) will render in the Table. When a toggle is activated, the details for that row are displayed. When a toggle is deactivated, the details for the row are hidden. The user can also display or hide the details for all rows at the same time (the controls for this feature are enabled by setting the "allDetailsEnabled" property to true.)

To enable the details feature set the "detailStamp" facet on the Table. Place the components that are used to show the details (of a row), inside this facet. In the following example, the Person's age is displayed in the details section:

Usually, the default behavior of the Table (with respect to displaying and hiding details) is sufficient. In some cases, however, it might be desirable to programmatically display or hide the details for a particular row. This can be done via the RowKeySet object obtained from the Table by calling the getDisclosureState() method. First, make the relevant row current by calling setRowIndex(...) or setRowKey(...) on the Table, and then call add() or remove() on the RowKeySet object. Adding the row to the set displays the details of the row. Removing the row hides them.

*** ***
The ADF Table component uses a model to access the data in the underlying list. The specific model class is oracle.adf.view.faces.model.CollectionModel . You may also use other model instances, e.g., java.util.List , array, and javax.faces.model.DataModel . The Table will automatically convert the instance into a CollectionModel ...??? not sure how will that happen as there is only one constructor for the CollectionModel and thats the default constructor ???

*** the ***
single-root hierarchy
TreeTable's children must be ADF Column components
the tree table has a "nodeStamp" and a "pathStamp" facet ... Like the Tree, the TreeTable has a "nodeStamp" facet which renders the "Object Name" Column. The TreeTable has a "pathStamp" facet for rendering the focus path.

*** obvious ***
ifmy af:table is inside af:panelcollection .. first panelcollection is made then the table

ANT and versioning

2007-12-11T21:11:00.000-08:00

http://www.josesandoval.com/2007/12/java-automatically-increment-build.html

Software Engineering

2007-12-11T20:58:00.000-08:00

hhhhhhhhmmmmmmmmmmmm
what THEY say ...
The idea is to create a language around the problem you're trying to solve in order to make it easier to solve the problem.
what I understood ...
yes i kind of agree to that ... as far as my experience with product development goes succesfull product development companies have made there own properiatory frameworks first and then used to it to solve the problem in hand ..
so what do they gain by making this framework ... ? wouldnt one save time by using existing framework .. ??
my take is they visualize a big problem break it down to small ones by making small components / classes / APIs and solve each of them individually
They even sav time .. how ?? if a bug comes in the framework they can solve it in less time rather than delegating it to some one else !

There's always a big difference between setting out to invent new solutions and setting out to invent new problems... confused ?? allow me to explain ... rather than solving a big problem first try to break it into new problems .. smaller and more specific ones .. then soolve each of them ... if new design or constraints come up then they too can be solved with similar approach ...
I wonder if its "Decorator Pattern" ;o)

Dont waste a lot of time and money in solving yesterdays problem ... i hope it makes sense .. and thats what JAVA is upto ...

cheerz !!

More JSF

2007-12-08T11:23:00.000-08:00

For a web application, all objects held in the application scope must be handled in a threadsafe manner; because all users and all requests have access to the objects in this scope, it's very likely that more than one thread will access the same object. Objects in the session scope must also be threadsafe, because they are shared by all requests from the same user. If the user makes parallel requests, e.g., by submitting the same form over and over without waiting for the response, making requests from multiple browsers tied to the same session, or requesting pages that contain references (e.g., frame references) to other pages that modify session scope objects, a session scope object's state can be corrupted.

When you use JSP as the presentation layer technology for JSF, you don't use the JSF API at all for creating and rendering components. Instead, you use the custom actions from the JSF custom tag libraries to say which components you need, and the tag handlers use the JSF API to create and render the corresponding component objects for you.

The first action element in the page, , is very important. The combination of the components that make up a specific user interface screen is called a view in JSF. A view contains an instance of the javax.faces.component.UIViewRoot class. This class is a nonvisual component type that acts as a container for all the other components in the view. Components representing UI widgets, such as input fields and buttons, are children of the UIViewRoot and can have children of their own. Together, the components form a tree, with the UIViewRoot at the top. The action element represents the UIViewRoot component and you must make sure it encloses all other JSF action elements in the page; otherwise, they aren't included in the view.

Note that there's a one-to-one relationship between a JSF view and an HTTP response. Hence, you must use only one element in the JSP page. A JSP page can, as you may know, include other JSP pages dynamically. Such included pages represent subviews in JSF, and are represented by an element.

The next JSF action element, , represents a form component, acting as a container for input components that hold values that should be processed together. Within the element

The element names for all these actions are composed from a component type name and renderer type name. The core JSF components represent pure behavior and know nothing about how they are represented on a screen. This task instead falls on renderers associated with each component, making it possible to represent the same type of component in different ways. Take < h : inputText >, for example. It represents an input field component, i.e., a component type that holds a value that can be changed by the user. Such a component can be rendered in different ways. The < h : inputText > action associates the input component with a text renderer, which renders the component as an HTML < input > element with the type attribute set to text. Another action element named < h : inputSecret > associates an input component with a renderer of type "secret," which renders the component as an HTML < input > element with the type attribute set to password.

< h : commandButton >
component Type : command
Renderer type : Button

< h : commandLink >
component Type : command
Renderer type : Link

< h : panelGroup >
component Type : panel
Renderer type : Group

< h : panelGrid >
component Type : panel
Renderer type : grid

< h : selectOneMenu >
component Type : selectOne
Renderer type : menu

Most component types can be combined with more than one renderer type, and each valid combination is supported by an action element following the naming convention.

So why doesn't the element name follow the same convention? Because the only renderer type for the form component type is the form renderer. To avoid action element names like , JSF uses an abbreviated element name when the component type and the renderer type have the same name