objectissues

ESB Key functions

2009-07-07T17:08:00.000-07:00

1) Route messages between different service providers
Example: A message arrives in oracle AQ and a Java service is called as a result

2) Convert the transport protocols
Example: Convert a PL/SQl to Java method call

3) Transform the message
Example: Oracle AQ payload could be a text message, the Java call will take an object parameter, so the ESB should do the transformation

4) Handle business events from different sources
Example: Same Java service can be invoked as a result of a message from oracle AQ or a call from another Java service

A simple index test using Oracle 10g free edition

2008-03-23T07:05:00.000-07:00

Background

I downloaded oracle 10g express edition from http://www.oracle.com/technology/products/database/xe/index.html.

I have a Pentium 4 winxp machine with 1gb ram and 320 gb hdd.

The download and install was a breeze.

It installs as a service and does start up with windows. However it can be stopped from starting up with windows, by using the services tool in the control panel.

When up and running the oracle 10g took around 250 mb ram on my pc.

I do not have toad, but the 10g express edition install comes with SQL command line and also a HTML based UI. The HTML UI though not comparable to Toad, does work alright with the basic tasks.

I wanted to test out a single column index and see if it mad any difference in searches.

The database and data setup

The test table and sequence is as below:-


Sequence details

CREATE SEQUENCE   "TASK_LIST_SEQ"  
MINVALUE 1 MAXVALUE 999999999999999999999999999 
INCREMENT BY 1 START WITH 1 CACHE 20 NOORDER  NOCYCLE
/

Table details

CREATE TABLE  "TASK_LIST" 
   (    "TASK_ID" NUMBER(18,0) NOT NULL ENABLE, 
        "TASK_NAME" VARCHAR2(100) NOT NULL ENABLE, 
        "TASK_STATUS" NUMBER(1,0) NOT NULL ENABLE, 
         CONSTRAINT "TASK_LIST_PK" PRIMARY KEY ("TASK_ID") ENABLE
   )
/
CREATE OR REPLACE TRIGGER  "BI_TASK_LIST" 
  before insert on "TASK_LIST"               
  for each row  
begin   
    select "TASK_LIST_SEQ".nextval into :NEW.TASK_ID from dual; 
end; 

/
ALTER TRIGGER  "BI_TASK_LIST" ENABLE
/

1) The table holds tasks with their id's, name and status.
2) The id is the primary key.
3) The sequence helps with the id generation automatically with the help of a trigger.
4) The column of interest is TASK_STATUS. I have decided to have status of 1 as complete and 0 as not complete.

Now we will do the following with the help of a pl/sql block.

1) Insert 200000 tasks with status 1(complete)
2) Insert 30000 tasks with status 0(not complete).

The code to do so is as below:-


--Insert 200000 tasks with status 1(complete)
declare
   task_name_var varchar2(100);
begin
   for i in 1..200000 loop
      task_name_var := 'Task ' || i;
      --DBMS_OUTPUT.PUT_LINE('task_name_var : ' || task_name_var);
      Insert into 
      task_list(task_name, task_status) 
      values(task_name_var,1);
   end loop;
end;

--Insert 30000 tasks with status 0(not complete)
declare
   task_name_var varchar2(100);
begin
   for i in 200001..230000 loop
      task_name_var := 'Task ' || i;
      --DBMS_OUTPUT.PUT_LINE('task_name_var : ' || task_name_var);
      Insert into 
      task_list(task_name, task_status) 
      values(task_name_var,1);
   end loop;
end;

The Tests without any index

Test not complete tasks

do a select count for all task not complete

select count(*) from task_list tl where tl.task_status = 0;

The explain plan (click on the image for greater resolution)

Test complete tasks

do a select count for all task complete

select count(*) from task_list tl where tl.task_status =1;

The explain plan (click on the image for greater resolution)

The Tests with index

Add the Index

create index "TASK_STATUS_IDX1"
on "TASK_LIST" ("TASK_STATUS")
/

Test not complete tasks

do a select count for all task not complete

select count(*) from task_list tl where tl.task_status = 0;

The explain plan (click on the image for greater resolution)

Test complete tasks

do a select count for all task complete

select count(*) from task_list tl where tl.task_status =1;

The explain plan (click on the image for greater resolution)

Conclusion

Note:- The number of rows for task complete(task_status - 1) was 200000 and for task not complete(task_status - 0) was 30000.

1) Without the index the time taken by both searches was 3 and cost was 234
2) With the index the time taken by the task complete(task_status - 1) search was 2 and cost was 131
3) With the index the time taken by the task not complete(task_status - 0) search was 1 and cost was 61.
4) The index on task_status column did improve performance.
5) The performance gain was greater for the task_status value with less number of rows i.e. task not complete(task_status - 0).

EJB3 local bean access in servlet using glassfish

2007-08-31T16:26:00.000-07:00

I was trying out Glassfish.

I made a separate ear with a stateless bean and a war with a servlet that accesses the stateless bean using @EJB injection. I deployed the ejb jar file and also the servlet war file. It did not work. The error was that the servlet did not find the ejb.

Reading the glassfish docs I came across this question in the glassfish faq.

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

Question: I have an EJB with a Local interface. Can I access it from a web component in a different application?

Answer: No, not in our implementation. The EJB spec only requires local ejb access from within the same application in the same JVM.
--------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------

Actually that makes a lot of sense.

All I needed to do was to have an ear file with both the war and ear as modules. That way the local EJB could be found by the servlet.

Since the servlet needed to access the local interface I also packaged the interface in WEB-INF/lib/ejbinterfaces.jar folder.

serialVersionUID from java 5

2007-08-31T16:21:00.000-07:00

I started using eclipse with java 5. I got this a compilation warning in one of the realizable class, which said something to the effect that it needs a 'serialVersionUID' field.

http://www.doc.ic.ac.uk/csg/java/1.5.0docs/api/java/io/Serializable.html

The 'serialVersionUID' field helps with making sure that the version of the class that has been serialized, is the same as the version of the class that is de-serialized and if it is not the a invalidClassException is thrown.

The field looks like 'private static final long serialVersionUID = 42L'.

Since it needs to be a static field, i guess each class and it's subclasses will need have one field per class declared if there is a heirarchy of classes that need to be serialized.

Some notes on the new java 1.5 concurrent api

2007-08-21T09:26:00.000-07:00

In the new java 1.5 Concurrent api, there is a lock.tryLock method, which returns false if the lock is already acquired by some other thread.

I have been in situations where I needed to know if an object lock(via synchronized(object a)) had already been acquired or not.

I guess it is simple now with the above 1.5 api.

However the other important thing to know is, if an object lock is in wait state or not before calling wait or notify on the lock. The 1.5 api has a Condition interface, but i did not see any kind of isWaiting method.

In java 1.4 i have achieved this by using volatile booleans, setting the boolean just before calling wait and then unsetting the boolean just after the notify.

Since wait and notify need to happen in synchronized blocks, this method has worked. However i would like to have an isWaiting api for locks.

Big 'O' notation and Java Constant time performance

2006-11-30T03:11:00.000-08:00

Big 'O' notation and Java Constant time performance

Collection Constant time performance, in a line is "The same amount of time taken for a certain operation(method) regardless of the number of elements in the collection"

Big 'O' notation

The Big O notation is used to indicate the time taken by algorithms to run :-

For example:-
(N is the number of elements)

O(N):- The time taken is linerarly dependent to the number of elements.

O(log N):- The time taken is logarithmic to the number of elements.

O(1):- The time taken is constant time, regardless of the number of elements.

Please read here to find out about the big O notation:-

http://en.wikipedia.org/wiki/Big_O_notation

In java collections

Sets

1) The HashSet offers constant time performance for basic operations (add, remove, contains and size).

2) The TreeSet provides guaranteed log(n) time cost for the basic operations (add, remove and contains).

3) Like HashSet, the LinkedHashSet provides constant-time performance for the basic operations (add, contains and remove)

Lists

4) The ArrayList offers constant time performance in the size, isEmpty, get, set, iterator, and listIterator operations. The add operation runs in linear time. All of the other operations run in linear time (roughly speaking).

Maps

5) The HashMap provides constant-time performance for the basic operations (get and put).

6) The TreeMap provides guaranteed log(n) time cost for the containsKey, get, put and remove operations.

7) Like HashMap, the LinkedHashMap provides constant-time performance for the basic operations (add, contains and remove), assuming the the hash function disperses elements properly among the buckets.

If you need a List you could use the ArrayList.

If you need a Set use the HashSet or for a sorted set use the TreeSet or an insertion ordered set use the LinkedHashSet.

If you need a Map use the HashMap or for a key sorted map use the TreeMap or a key insertion ordered map use the LinkedHashMap.

Sring 1.1 and map element

2006-11-27T09:30:00.000-08:00

Sring 1.1 and map element

In Spring 1.1 the map element has a key and value like this

<map>
<entry key="event">
<value>ss</value>
<ref>ref1</ref>
</entry>
</map>

In the above code there is no way to specify the "key" as an object, it must be a "String" object !

However from spring 1.2x onwards we can do do this

<map>
<entry>
<key-ref>ref1</key-ref>
<value-ref>ref2</value-ref>
</entry>
<map>

In many cases the above is what one would need of a java map.

Java 5, EJB 3 Persistence and Hibernate annotations

2006-10-17T14:31:00.000-07:00

Java 5, EJB 3 Persistence and Hibernate annotations

I finally decided to try out some code with Java 5 annonations. For this I chose to try hibernate annotations implementation, which implements EJB 3 persistence with some enhanced annotations of its own.

Pre -requisites
1) Java 5 SDK
2) Latest Hibernate jar with dependent libraries from the lib folder of the download.
3) Latest Hibernate annotation jar with dependent libraries from the lib folder of the download.
4) Ant

Domain Objects

The domain objects are Person and Child. The relationship is one-to-many from person to child and many-to-one from Child to person. The java POJO's are fairly straight forward for this, so I will share the xml here.

Person.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

<class name="test.suchak.hibernatetest.domainobjects.Person" table="Person">
<id
name="ID"
column="ID"
>
<generator class="sequence">
<param name="sequence">PERSONIDSEQUENCE</param>
</generator>
</id>
<property name="firstName">
<column name="FirstName"/>
</property>
<property name="lastName">
<column name="LastName"/>
</property>

<list name="children" cascade="all" inverse="true">
<key column="parent_id"/>
<index column="child_id"/>
<one-to-many class="test.suchak.hibernatetest.domainobjects.Child"/>
</list>

</class>

</hibernate-mapping>

Child.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

<class name="test.suchak.hibernatetest.domainobjects.Child" table="Child">
<id
name="child_id"
column="child_id"
>
<generator class="sequence">
<param name="sequence">CHILDIDSEQUENCE</param>
</generator>
</id>
<property name="name">
<column name="name"/>
</property>
<property name="age">
<column name="age"/>
</property>
<many-to-one name="person"
column="parent_id"
class="test.suchak.hibernatetest.domainobjects.Person"
cascade="all"
/>
</class>

</hibernate-mapping>

XML Session factory configuration
The session factry configuration here is prettty simple. Just read the hbm files and pass them to the hibernate configugation.

public class MyHibernateSessionFactory {
......
private void buildSessionFactory(String[] fileNames) {

Configuration config = new Configuration();

for(int i=0;i<filenames.length;i++){
config.addFile(hbmDir + File.separator + fileNames[i]);
}
sessionFactory = config.buildSessionFactory();
} ....
}

Now the sessionFactory.openSession() method will retun the sessions we need. Using the session we can now do CRUD on the child and person POJO's, in the traditional hibernate world.

Annotations

Now instead of the xml files we will use annotations for the same two POJO's person and child.

Person.java

package test.suchak.hibernatetest.domainobjects;

import java.util.List;
//import javax.persistence.*;
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.OneToMany;
import javax.persistence.Id;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;
import org.hibernate.annotations.MapKey;
import javax.persistence.CascadeType;

/**
* @author Suchak.Jani
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*
*/

@Entity
@Table(name="Person")
public class Person {
private Integer ID;
private String firstName;
private String lastName;
private List children;

public Person(){

}
/**
* @param firstName2
* @param lastName2
*
*/
public Person(String firstName, String lastName) {
this.firstName=firstName;
this.lastName=lastName;
}

/**
* @return Returns the firstName.
*/
@Column(name = "FirstName")
public String getFirstName() {
return firstName;
}
/**
* @return Returns the iD.
*/
@Id @GeneratedValue(generator="sequence")
@GenericGenerator(name="sequence", strategy = "sequence",
parameters = {
@Parameter(name="sequence", value="PERSONIDSEQUENCE")
}
)
public Integer getID() {
return ID;
}
/**
* @return Returns the lastName.
*/
@Column(name = "LastName")
public String getLastName() {
return lastName;
}
/**
* @param firstName The firstName to set.
*/
public void setFirstName(String firstName) {
this.firstName = firstName;
}
/**
* @param id The iD to set.
*/
public void setID(Integer id) {
ID = id;
}
/**
* @param lastName The lastName to set.
*/
public void setLastName(String lastName) {
this.lastName = lastName;
}

/**
* @return Returns the children.
*/
@OneToMany(mappedBy="person", cascade=CascadeType.ALL)
//@OneToMany(mappedBy="person")
@MapKey(columns=@Column(name="child_id"))
public List getChildren() {
return children;
}
/**
* @param children The children to set.
*/
public void setChildren(List children) {
this.children = children;
}
}

Child.java

package test.suchak.hibernatetest.domainobjects;

//import javax.persistence.*;
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.ManyToOne;
import javax.persistence.JoinColumn;
import javax.persistence.Id;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;

/**
* @author Suchak.Jani
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
@Entity
@Table(name="Child")
public class Child {

private Integer child_id; // ID
private String name;
private Integer age;
private Person person;

// need a default cosntructor for hibernate to be able to read for this object
public Child() {

}

/**
* @param parent_id2
* @param name2
* @param age2
*/
public Child(Person person,String name, Integer age) {

this.setPerson(person);
this.setName(name);
this.setAge(age);
}
/**
* @return Returns the age.
*/
@Column(name = "age")
public Integer getAge() {
return age;
}
/**
* @param age The age to set.
*/
public void setAge(Integer age) {
this.age = age;
}
/**
* @return Returns the child_id.
*/
@Id @GeneratedValue(generator="sequence")
@GenericGenerator(name="sequence", strategy = "sequence",
parameters = {
@Parameter(name="sequence", value="CHILDIDSEQUENCE")
}
)
public Integer getChild_id() {
return child_id;
}
/**
* @param child_id The child_id to set.
*/
public void setChild_id(Integer child_id) {
this.child_id = child_id;
}
/**
* @return Returns the name.
*/
@Column(name = "name")
public String getName() {
return name;
}
/**
* @param name The name to set.
*/
public void setName(String name) {
this.name = name;
}

/**
* @return Returns the person.
*/
@ManyToOne
@JoinColumn(name="parent_id",nullable=false)
public Person getPerson() {
return person;
}
/**
* @param person The person to set.
*/
public void setPerson(Person person) {
this.person = person;
}
}

Annotation Session factory configuration

The session factry configuration here is different than the xml session factory as shown below.

public class AnnotationHibernateSessionFactory {
....
/**
* @param files
*/
private void buildSessionFactory() {
try {
sessionFactory = new AnnotationConfiguration()
.addAnnotatedClass(Person.class)
.addAnnotatedClass(Child.class)
.buildSessionFactory();
} catch (Throwable ex) {
// Log exception!
throw new ExceptionInInitializerError(ex);
}
}

Key Points

1) XML files not needed.
2) An import per annotation used in the POJO.
3) (inverse="true") is now equivalent to mappedBy.
4) Most annotations are in javax.persistence package.
5) The new AnnotationConfiguration class is to be used instead of the Configuartion class.
6) The xml tags class and class name are not necessary.

Code

The working code is available for download below.

hibernatejdk5test....

Hosted by eSnips

Java and unsigned numbers

2006-10-17T12:16:00.000-07:00

Java and unsigned numbers

Recently there was a requirement for some binnary data read/write work. I started out with some java code. I used the nio ByteBuffer to read and write data.

Something was not right. Whenever i tried to read some sample data the values were right at times and wrong(negative) at other times.

Then a senior consultant colleague, reminded me that all java numbers are 2's complement. In short the MSB(most significant bit) is used to indicate positive or negative number. For further details on 2's complement, please read http://en.wikipedia.org/wiki/Two's_complement .

That sent me on a trail to firgure out how could i read/write an unsigned number using java.

The basic understanding is that you use a bigger number to store the smaller signed number. That way the bigger signed number becomes the unsigned smaller number.

For example a byte is 8 bits. Its range in java is +127 to -128. (Please read up on the 2's complement bit to understand how we get the negative number)

0111 1111 = 127
1000 0000 = - 128 (2's complement)

So in order to convert this byte to unsinged byte we will incease the byte to a short.

A short in java is 16 bits

0000 0000 0000 0000 0111 1111 = 127
0000 0000 0000 0000 1000 0000 = 128

Here is some code to test this

public class Test {
public static void main(String args[]) {
byte b = -128;
short s = (short)(0x00FF & b);
System.out.println("Byte b = " + b);
System.out.println("Short s = " + s);
}
}

The Result is
D:\>java Test
Byte b = -128
Short s = 128

Please note that i have not directly casted to a short, instead i have done a bit and operation with all 1's (F in hex is 1111 in binary). That way the number is preserved at the byte level. If i had just cast it to a short then java would have treated it as a neagtive number i.e. it still would be -128.

Here is a link that explains clearly how to use binary opreations to achieve this for all number types - http://www.darksleep.com/player/JavaAndUnsignedTypes.html and also Java's integer sizes - http://www.scism.sbu.ac.uk/jfl/Appa/appa1.html

Why does java have no unsigned numbers ?

Sean R. Owens at http://www.darksleep.com/player/JavaAndUnsignedTypes.html, digs up old emails and interviews about Java and Oak where James Gosling explains this :-

http://www.gotw.ca/publications/c_family_interview.htm

Gosling: For me as a language designer, which I don't really count myself as these days, what "simple" really ended up meaning was could I expect J. Random Developer to hold the spec in his head. That definition says that, for instance, Java isn't -- and in fact a lot of these languages end up with a lot of corner cases, things that nobody really understands. Quiz any C developer about unsigned, and pretty soon you discover that almost no C developers actually understand what goes on with unsigned, what unsigned arithmetic is. Things like that made C complex. The language part of Java is, I think, pretty simple. The libraries you have to look up.

Finally Java has no unsigned numbers and when dealing with binary data which might contain unsigned numbers, one has to keep this fact in mind.

EJB 3 Interceptors: Aspect orientation in EJB spec

2006-07-05T01:50:00.000-07:00

EJB 3 Interceptors: Aspect orientation in EJB spec

By now most people in the java community have heard about Spring, Dependency Injection, Aspect oriented programming and other such terms

For those who have not, if i were to put this in a single line it would say "An aspect is a common function that can be used across an application".

Examples of this would be things like Security, Auditing, Transactions, Logging, etc..

It is definitely useful to abstract out common aspects of an application in order that you do not have to write the same code in many places.

The Spring container is very popular in the java community as of now for this particular reason. Also the Spring container externalizes the configuration of the dependency injected aspect objects so that the behaviour, as well as implementations of the aspect objects, can be varied as needed without much code change.

EJB 2 also did some of this with regards to EJB Transactions, EJB Reference, Connection pools, etc.

However With EJB 3 and Annotations a new term has been added. It is called "EJB Interceptors". They apply only on session and message driven beans.

EJB3 Interceptors can act on a bean level like lifecycle callback interceptors or on a specific method level or on all methods or on certain number of methods. Also there could be multiple interceptors that also could have exclusion rules for certain methods.

We will try and see this in a bit more detail.

What are lifecycle callback interceptors?

EJB2 had an EJB Lifecycle for each of the EJB types i.e. Stateless Session bean, StateFull Session Bean, Entity Bean and MDBs. They are described in detail here: -

http://java.sun.com/j2ee/tutorial/1_3-fcs/doc/EJBConcepts9.html

The particular lifecycle state can be "Does Not exist", "Pooled", "Ready". Between these states there are methods that the container calls on the EJB such as create,
setSessionContext, ejbCreate etc..

Now In EJB3 since we have EJB's we also have EJB lifecycles and related methods. However for us to be bale to do anything at the time of a lifecycle method invocation we have to define it as a lifecycle call-back interceptor method.

For example: -

Session beans have the following interceptor methods

• PostConstruct
• PreDestroy
• PostActivate
• PrePassivate

So we could have a session bean like this

@Stateless public class BusinessServiceBean implements BusinessService {

public void doService(){...};
...

@PostActivate
initializeDB() {...};

}

What is a method interceptor?

Business method Interceptor for all methods

(-- this is from the EJB spec
Business method interceptor methods are denoted by the AroundInvoke annotation. Only one AroundInvoke method may be present on the bean class or on any given interceptor class. An
AroundInvoke method must not be a business method.

The business method invocation is intercepted by the AroundInvoke methods of the bean class and interceptor classes. AroundInvoke methods must always call InvocationContext.proceed() or neither the business method will be invoked nor any subsequent interceptor AroundInvoke methods.

InvocationContext

The InvocationContext object provides the metadata that is required for interceptor methods:

public interface InvocationContext {

public Object getBean();
public Method getMethod();
public Object[] getParameters();
public void setParameters(Object[]);
public java.util.Map getContextData();
public Object proceed() throws Exception;

}
--)

Now how do we use this?

Here is a sample code that uses a Business method Interceptor

@Stateless public class BusinessServiceBean implements BusinessService {

public void doService(){...};
...

@PostActivate
initializeDB() {...};

@AroundInvoke
doChecks() {
checkDBAccess;
checkSecurity;
.....
};

}

This would mean that when a user calls doService the call is intercepted and doChecks method is called first instead.

Business method Interceptor for specific methods

A business method interceptor method may be defined to apply to a specific business method invocation, rather than to all of the business methods of the bean class.

This is done by using interceptor annotations.

@Stateless public class BusinessServiceBean implements BusinessService {

@Interceptors(test.TestInterceptor.class)
public void doService(){...};
...

@PostActivate
initializeDB() {...};

@AroundInvoke
doChecks() {
checkDBAccess;
checkSecurity;
.....
};

}

As i understand, there can be more than one method level interceptor. If that is the case the interceptors are invoked in the order they are specified. Also method level interceptors are invoked in addition to any other interceptors defined at the bean level.

I need to get to an EJB 3 implementation to test out a few permutations and combinations of the above code.

To conclude, EJB3 now looks more and more like other popular java frameworks, for aspect oriented programming, like Spring. Also EJB 3 persistence now looks like OR tools namely Toplink, Hibernate, etc.

A sample sax parser

2006-05-15T01:56:00.000-07:00

I thought of writing a sax parser, just to see how it would work with the web.xml file for the ajaz example.

Here is the XML file.(This is the file that this line of code picks up 'm.parseXml("C:/temp/ajaxtest/web.xml");')

NOTE:- Blogger tries to render HTML tags in a blog. So where you see [] in tags, please read them as <>.

[?xml version="1.0" encoding="UTF-8"?]
[web-app testAttribute="test1"]
[servlet]
[servlet-name]SimpleTestServlet[/servlet-name]
[servlet-class]suchak.ajax.test.SimpleTestServlet[/servlet-class]
[/servlet]
[servlet]
[servlet-name]AnotherSimpleTestServlet[/servlet-name]
[servlet-class]suchak.ajax.test.AnotherSimpleTestServlet[/servlet-class]
[/servlet]
[servlet-mapping]
[servlet-name]SimpleTestServlet[/servlet-name]
[url-pattern]*.cmd[/url-pattern]
[/servlet-mapping]
[/web-app]

The ContentHandler interface is the key interface for sax parsing api. It has an implementation called DefaultHandler which can be used for simplicity. One can just choose to overide methods one wants. Just to add, I also thought of using the fully qualified names so that there would be clarity as to where the classes come from at a first glance rather than looking up the import.

I am using the apache xeres parser. So if you try this out you might want to include the apache xerces libraries in your classpath.

Here is the class. Please note the ContentHandler itself is an inner class called TestContentHandler.

import java.io.File;

public class Main {

public static void main(String [] args){
Main m = new Main();
m.parseXml("C:/temp/ajaxtest/web.xml");
}

private void parseXml(String file) {
try {
org.xml.sax.InputSource is = new org.xml.sax.InputSource(
new java.io.FileInputStream(file));
org.xml.sax.XMLReader reader =
org.xml.sax.helpers.XMLReaderFactory.createXMLReader(
"org.apache.xerces.parsers.SAXParser");
reader.setContentHandler(new Main.TestContentHandler());
log(" -- Staring XML Parsing ! --");
reader.parse(is);
log(" -- Finished XML Parsing ! --");
} catch (java.io.FileNotFoundException e) {
e.printStackTrace();
} catch (org.xml.sax.SAXException e) {
e.printStackTrace();
} catch (java.io.IOException e) {
e.printStackTrace();
}

}

public class TestContentHandler extends org.xml.sax.helpers.DefaultHandler {

String currentElement = null;
java.util.HashMap elementValues = new java.util.HashMap();

public void startElement(
String namespaceURI,
String localName,
String qName,
org.xml.sax.Attributes attributes)
throws org.xml.sax.SAXException {
log(
" Start element " +
" ---- qName :::: '" + qName + "'"
);
// Element is starting to be read, so name it as the current element and
currentElement = qName;
elementValues.put(currentElement, new StringBuffer());

int noofattributes = attributes.getLength();

for(int i=0;i(less than)noofattributes;i++){
log(
" Attribute found for element :: '" + qName + "'" +
" att qname :: " + attributes.getQName(i) +
" att type :: " + attributes.getType(i) +
" att value :: " + attributes.getValue(i));
}
}

public void characters(
char[] ch,
int start,
int length)
throws org.xml.sax.SAXException {
log( "Current element being processed in chars :: '" +
currentElement + "'");
String tempString = new String(ch,start,length);
//log( "Value of the above element is :: '" + tempString + "'");
if(tempString.trim().equals("")){
// if emply string just log it and do nothing
log( " -- White space -- ");
}else{

/* this part of the code add the strings to the current element.
* as per http://java.sun.com/j2se/1.4.2/docs/api/org/xml/sax/
* ContentHandler.html#characters(char[],%20int,%20int)
* The Parser will call this method to report each chunk of character
* data. SAX parsers may return all contiguous character data in a
* single chunk, or they may split it into several chunks; however,
* all of the characters in any single event must come from the same
* external entity so that the Locator provides useful information.
* The application must not attempt to read from the array outside of
* the specified range.
*/
((StringBuffer)(elementValues.get(currentElement))).append(tempString);
}
}

public void endElement(
String namespaceURI,
String localName,
String qName)
throws org.xml.sax.SAXException {
log(
"End element " +
" ---- qName :: '" + qName + "'"
);
/*
* Current element is fully read, so it is ok to
* remove the element value from the map
*
*/

String value = ((StringBuffer)(elementValues.get(qName))).toString();
// Print the value out of it is not am epty string
if(!value.equals("")){
log(" Value of the above current element :: " + qName +
" is :: "+ value);
}
elementValues.remove(qName);
/*
* We do not reset the current element here as the startElement
* method should do that at the start of an element
*
*/
}
}

private void log(String s){
System.out.println(s);
}
}

As seen above the characters method can span multiple calls depending on the buffer size for the same element.

Here is the output:-

-- Staring XML Parsing ! --

Start element ---- qName :::: 'web-app'
Attribute found for element :: 'web-app' att qname :: testAttribute att type :: CDATA att value :: test1
Current element being processed in chars :: 'web-app'
-- White space --

Start element ---- qName :::: 'servlet'
Current element being processed in chars :: 'servlet'
-- White space --

Start element ---- qName :::: 'servlet-name'
Current element being processed in chars :: 'servlet-name'
End element ---- qName :: 'servlet-name'
Value of the above current element :: servlet-name is :: SimpleTestServlet

Current element being processed in chars :: 'servlet-name'
-- White space --
Start element ---- qName :::: 'servlet-class'

Current element being processed in chars :: 'servlet-class'
End element ---- qName :: 'servlet-class'
Value of the above current element :: servlet-class is :: suchak.ajax.test.SimpleTestServlet

Current element being processed in chars :: 'servlet-class'
-- White space --

Current element being processed in chars :: 'servlet-class'
-- White space --

End element ---- qName :: 'servlet'
Current element being processed in chars :: 'servlet-class'
-- White space --

Start element ---- qName :::: 'servlet'
Current element being processed in chars :: 'servlet'
-- White space --

Start element ---- qName :::: 'servlet-name'
Current element being processed in chars :: 'servlet-name'
End element ---- qName :: 'servlet-name'
Value of the above current element :: servlet-name is :: AnotherSimpleTestServlet

Current element being processed in chars :: 'servlet-name'
-- White space --

Start element ---- qName :::: 'servlet-class'
Current element being processed in chars :: 'servlet-class'
End element ---- qName :: 'servlet-class'
Value of the above current element :: servlet-class is :: suchak.ajax.test.AnotherSimpleTestServlet

Current element being processed in chars :: 'servlet-class'
-- White space --

Current element being processed in chars :: 'servlet-class'
-- White space --

End element ---- qName :: 'servlet'
Current element being processed in chars :: 'servlet-class'
-- White space --

Current element being processed in chars :: 'servlet-class'
-- White space --

Start element ---- qName :::: 'servlet-mapping'
Current element being processed in chars :: 'servlet-mapping'
-- White space --

Start element ---- qName :::: 'servlet-name'
Current element being processed in chars :: 'servlet-name'
End element ---- qName :: 'servlet-name'
Value of the above current element :: servlet-name is :: SimpleTestServlet

Current element being processed in chars :: 'servlet-name'
-- White space --

Start element ---- qName :::: 'url-pattern'
Current element being processed in chars :: 'url-pattern'
End element ---- qName :: 'url-pattern'
Value of the above current element :: url-pattern is :: *.cmd

Current element being processed in chars :: 'url-pattern'
-- White space --

Current element being processed in chars :: 'url-pattern'
-- White space --

End element ---- qName :: 'servlet-mapping'

Current element being processed in chars :: 'url-pattern'
-- White space --

End element ---- qName :: 'web-app'-- Finished XML Parsing ! --

As seen, all white spaces, including CR's are also outputted by the characters method. I did not see a way to tell the apache xeres parser to not read the white spaces in the characters method.

However Oracle has a neat XML parser in which one can do this :-

SAXParser parser = new SAXParser();
parser.setPreserveWhitespace(false);

Here are more details :- http://www.oracle.com/technology/pub/articles/wang-whitespace.html

All in all it seems pretty simple to write up a custom sax parser whith current tools.

EJB 3 - a basic study

2006-05-02T02:30:00.000-07:00

EJB 3 is such a radical departure from EJB 2.

To begin with there is no need for the developer to define local or remote and localhome or remotehome interfaces.

All of the above is achieved by an intelliginet mix of default behaviour and annotations.

Here is an example

@Stateless
public class GreetingBean implements Greeting {
public String hello (String personName) {
return "Hello " + personName + "!";
}
}

public interface Greeting{
public String hello (String personName);
}

The above bean is a stateless bean with local accaess as the defualt. So no need to implement EJBLocalObject, EJBLocalHome, etc....

How do we make this a remote bean ?

@Stateless @Remote
public class GreetingBean implements Greeting {
public String hello (String personName) {
return "Hello " + personName + "!";
}
}

public interface Greeting{
public String hello (String personName);
}

How do we get access to this bean, if there is no Home Interface ?

Via "Dependency Injection" just like Spring.

The difference is, unlike Spring, EJB3 does not use an exteranl XML configuration file, what is used instead is, again an annotation !

@EJB Greeting greeting;
...
String helloString = greeting.hello("Krishna");

Webservices can be defined as annotations on session bean methods.

Also i hear that Entity bean persistence is much like an OR tool i.e. Hibernate et all.

STAX:The new Streaming API for XML

2006-04-21T07:14:00.000-07:00

I was reading up something on JAXB which was pretty long winded, when i came accross this "STAX" or "Streaming API for XML".

It is a bit unique in it's design from both SAX and DOM, but it still is closer to SAX.

It is a parser and hence can be used to read up xml documents but additionally like DOM can also be used to write up XML.

It is a streaming parser like SAX and like SAX it works from start to finish, and can not work backwards from a certain point in an xml file.

SAX uses push style of streaming i.e. it reads up the entire xml file from start to finish and logs events which the user can use.

STAX uses pull style of streaming i.e like an iterator which checks for hasNext() and the uses next() to get the next Object, STAX also checks for hasNext() and the uses next() to get the next Element.

Why do we need a new style of parser ?

I guess the main reason is performance.

1) Threads
With sax style parsers the application thread control is with the sax parser and thus one application thread can read one document at a time.

With stax style parsers that the application thread control is with the application code that calls the parser and thus one application thread can multiple document at a time.

2) Smaller libraries
Sun tutorial claims that pull parsing libraries, can be much smaller than push libraies

3) Filters
StAX supports building of filters and thus xml content not needed, can be ignored by the parser.

Here is a quote from the Sun Tutorial:-

"Why StAX?

The StAX project was spearheaded by BEA with support from Sun Microsystems, and the JSR 173 specification passed the Java Community Process final approval ballot in March, 2004 (http://jcp.org/en/jsr/detail?id=173). The primary goal of the StAX API is to give “parsing control to the programmer by exposing a simple iterator based API. This allows the programmer to ask for the next event (pull the event) and allows state to be stored in procedural fashion.”

StAX was created to address limitations in the two most prevalent parsing APIs, SAX and DOM."

Note that BEA and Sun are both involved in this. So I guess for the future of java xml in general and java web services in particular STAX parsers are here to stay.

There are two kinds of STAX api

Cursor API
This is a light weight and fast api, used for projects like J2ME and projects where performance is essential.

It is implemented by XMLStreamReader and XMLStreamWriter interfaces.

Iterator API
In this api the Events generated can be used by the application even after the parser has moved on to subsequent Events. It is much more flexible when you want to add or remove Events, extend Events, etc..

It is implemented by XMLEventReader and XMLEventWriter interfaces.

Please see these links for more information:-

http://www.oracle.com/technology/oramag/oracle/03-sep/o53devxml.html
http://java.sun.com/webservices/docs/2.0/tutorial/doc/StAX.html#wp69937

Now back to JAXB.....

AJAX JSP and Direct Web Remoting

2006-04-18T12:38:00.000-07:00

I wanted to try out Ajax with Java for some time now. I was clueless as to where to start. I came across this tool called "Direct Web Remoting" at http://getahead.ltd.uk/dwr/index .

I decided to give it a try with the assumtions:-

1) I should have a simeple java jsp/servlet which does some simple validation.
2) This JSP/Servlet will invariable go back to the server and reload the jsp Page.
3) The AJAX code must be able to perform the same simple validation.
4) The AJAX code must go back to the server but must not reload the jsp Page.

So i went ahead and first wrote a simple JSP/Servlet with Weblogic 8.1 and JDK 1.4.

NOTE:- Blogger tries to render HTML tags in a blog. So where you see [] in tags read them as <>.

The traditional Servlet/JSP code:-

package suchak.ajax.test;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

public class SimpleTestServlet extends HttpServlet {

// Initialize th log4j logger
private Logger log = Logger.getLogger(SimpleTestServlet.class);

// The default String in the all jsp form action attributes.
private final static String COMMANDENDSTRING = ".cmd";

/* Using service method so that the servlet will work with a get as
* well as a port
*/
public void service(HttpServletRequest req, HttpServletResponse res)
throws IOException, ServletException{

log.debug("the command asked for is : " +
req.getRequestURI() );

if(isCommand("processFullForm",req)){
try{
processFullForm(req,res);
req.setAttribute("iSANumber","iSANumber");
}catch(NumberFormatException e){
req.setAttribute("NotANumber","NotANumber");
}
}
req.getRequestDispatcher("jsp/welcome.jsp").forward(req,res);
}

/* The process method does the does the full form processing test.
*
*
*/
private void processFullForm(HttpServletRequest req, HttpServletResponse res)
throws NumberFormatException, ServletException {
//Set the done attribute for the screen
String number = req.getParameter("number");
Double.parseDouble(number);
req.setAttribute("done","done");
}

/* This method tests the URI to see which command was asked for.
* The command is the same as the action attribute of the form tag in the
* jsp. This way multiple JSP's can use the same servlet.
*
* @param command the string value of the command i.e the action attribute
* of the form tag in the jsp.
* @param req the http request object
*
* @return boolean returns true if the command is same as the req uri or
* false otherwise
*/
private boolean isCommand(String command, HttpServletRequest req){
log.debug("URI will be compared with :: " +
req.getContextPath()+ "/" + command + COMMANDENDSTRING);
return req.getRequestURI().
equals(req.getContextPath()+ "/" + command + COMMANDENDSTRING);
}}

Traditional JSP

[html]
[head]
[title]Welcome[/title]
[/head]
[body]
[h1]
Welcome to the AJAX Test
[/h1]
[br /]
[br /]
[!-- Start : Section for full form processing --]

[hr]

[h4]Full JSP reload test[h4]

[FORM name="JSPReload" action="/ajaxtest/processFullForm.cmd" method="post"]
[h4]Please enter a number here : [/h4]

[INPUT type="text" name="number" value="
[%if(request.getAttribute("number") !=null){
out.println(request.getAttribute("number"));
}else{
out.println("");
}%]
"]

[%if(request.getAttribute("NotANumber") != null){%]
[h4]Please Enter a Valid Number ![/h4]
[%}else if(request.getAttribute("iSANumber") != null) {%]
[h4]That was a valid Number ![/h4]
[%}%]

[INPUT type="submit" name="submit" value="Click to get check whether the value entered is a number"]

[/FORM]

[!-- Start : Section for output values --]
[%if(request.getAttribute("done") != null){%]
[h4]Done[/h4]
[%}%]
[!-- END : Section for output values --]

[!-- End : Section for full form processing --]

[/body]
[/html]

Traditional Web.xml

[?xml version="1.0" encoding="UTF-8"?]
[!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd"]

[web-app]
[servlet]
[servlet-name]SimpleTestServlet[/servlet-name]
[servlet-class]suchak.ajax.test.SimpleTestServlet[/servlet-class]
[/servlet]

[servlet-mapping]
[servlet-name]SimpleTestServlet[/servlet-name]
[url-pattern]*.cmd[/url-pattern]
[/servlet-mapping]

[/web-app]

The above code works in the traditional way, and outputs wether the user entered a number on the jsp or not. Also it does the traditional JSP reload as expected

The AJAX JSP code:-

The test bean code

package suchak.ajax.test;

public class TestAjx {

public boolean isNumber(String number){
System.out.println("In Server side Test Ajax");
try{
Double.parseDouble(number);
System.out.println("In Server side Test Ajax : Before return true");
return true;
}catch(NumberFormatException e){
System.out.println("In Server side Test Ajax NumberFormatException: " +
"Before return false");
return false;
}
}}

The Modified AJAX JSP

[html]
[head]
[title]Welcome[/title]
[script type='text/javascript' src='/ajaxtest/dwr/interface/TAjx.js'][/script]
[script type='text/javascript' src='/ajaxtest/dwr/engine.js'][/script]
[script type='text/javascript' src='/ajaxtest/dwr/util.js'][/script]
[/head]
[body]
[h1]
Welcome to the AJAX Test
[/h1]
[br /]
[br /]
[!-- Start : Section for full form processing --]

[hr]

[h4]Full JSP reload test[h4]

[FORM name="JSPReload" action="/ajaxtest/processFullForm.cmd" method="post"]
[h4]Please enter a number here : [/h4]

[INPUT type="text" name="number" value="
[%if(request.getAttribute("number") !=null){
out.println(request.getAttribute("number"));
}else{
out.println("");
}%]
"]

[%if(request.getAttribute("NotANumber") != null){%]
[h4]Please Enter a Valid Number ![/h4]
[%}else if(request.getAttribute("iSANumber") != null) {%]
[h4]That was a valid Number ![/h4]
[%}%]

[INPUT type="submit" name="submit" value="Click to get check whether the value entered is a number"]

[/FORM]

[!-- Start : Section for output values --]
[%if(request.getAttribute("done") != null){%]
[h4]Done[/h4]
[%}%]
[!-- END : Section for output values --]

[!-- End : Section for full form processing --]

[br][br][br][br][br]

[!-- Start : Section for ajax form processing --]

[hr]

[h4]Ajax test : Not full form Refresh[h4]

[h4]Please enter a number here : [/h4]

[FORM name="AJAXTest" onsubmit="showMessage()" method="post"]
[INPUT type="text" name="AjxNumber" value=""]
[INPUT type="submit" name="submit" value="Click to get check whether the value entered is a number"]
[/FORM]
[script language="javascript" type="text/javascript"]

var bool = false

var reply0 = function(data){
bool = data
}

function showMessage() {
TAjx.isNumber(document.AJAXTest.AjxNumber.value,reply0)

alert(bool)

if(
document.AJAXTest.AjxNumber.value != null
&& document.AJAXTest.AjxNumber.value != ''
&& bool
)
{
alert('That was a valid number!');
}
else{
alert('Please enter a Valid Number!');
}
}

[/script]

[!-- End : Section for ajax form processing --]

[/body]
[/html]

The Modified AJAX Web.xml

[?xml version="1.0" encoding="UTF-8"?]
[!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd"]

[web-app]
[servlet]
[servlet-name]SimpleTestServlet[/servlet-name]
[servlet-class]suchak.ajax.test.SimpleTestServlet[/servlet-class]
[/servlet]

[servlet]
[servlet-name]dwr-invoker[/servlet-name]
[display-name]DWR Servlet[/display-name]
[servlet-class]uk.ltd.getahead.dwr.DWRServlet[/servlet-class]
[init-param]
[param-name]debug[/param-name]
[param-value]true[/param-value]
[/init-param]
[/servlet]

[servlet-mapping]
[servlet-name]SimpleTestServlet[/servlet-name]
[url-pattern]*.cmd[/url-pattern]
[/servlet-mapping]

[servlet-mapping]
[servlet-name]dwr-invoker[/servlet-name]
[url-pattern]/dwr/*[/url-pattern]
[/servlet-mapping]

[/web-app]

The new AJAX DWR.xml

[!DOCTYPE dwr PUBLIC
"-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN"
"http://www.getahead.ltd.uk/dwr/dwr10.dtd"]

[dwr]
[allow]
[create creator="new" javascript="TAjx" scope="session"]
[param name="class" value="suchak.ajax.test.TestAjx"/]
[/create]
[create creator="new" javascript="JDate" scope="session"]
[param name="class" value="java.util.Date"/]
[/create]
[/allow]
[/dwr]

This works as assumed above with the output :-

In Server side Test Ajax
In Server side Test Ajax NumberFormatException: Before return false
In Server side Test Ajax
In Server side Test Ajax : Before return true

The Problems i faced were :-

1) The dwr.jar (http://getahead.ltd.uk/dwr/download) is needed to be in the web-inf/lib dir, along with the bean class suchak.ajax.test.TestAjx. I had place everthing in APP-inf/lib dir which was not working. I found out that this was a known issue with DWR in weblogic 8.1.
2) The javascript was a bit difficult to figure out initially, but looking at the code in the example war it came out to be pretty straightforward.

The issues i think are :-

1) There is a dependency on DWR for this to work.
2) The Ajax page sends gives alerts instead of messages on the page like the JSP/Servlet solution, which i think is better than alerts. There is a javascript document.write but that can not write to a portion of the page.

But all said and done the HTML Java AJAX solution does work, with little effort using DWR. Also it does server side validations without page refresh.

Java DateFormat is not threadsafe

2006-04-18T12:22:00.000-07:00

Java DateFormat and SimpleDate classes are not threadsafe.

When an application has a few common date formats it seems natural to have them in some common place like static variables or in some kind of singleton.

However as per this bug report last updated in 2001, date format is not thread safe :-

http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4228335

Also the sun java doc for 1.4 and 1.5 confirms the same :-

http://java.sun.com/j2se/1.4.2/docs/api/java/text/DateFormat.html
http://java.sun.com/j2se/1.5.0/docs/api/java/text/DateFormat.html

Synchronization

Date formats are not synchronized. It is recommended to create separate format instances for each thread. If multiple threads access a format concurrently, it must be synchronized externally.

What does that impact ?

Well if the methods of dateformat do not use instance variables like most servlets, i guess we should be ok, even if multiple threads access the dateformat, just like servlets.

However since the javadoc "recommends to create separate format instances for each thread" we might use thread local variables to store the DateFormats. That way instead of creating a new DateFormat each time it is needed, we will get only as many DateFormats as there are threads using them.

Java Timezone class

2006-04-18T12:01:00.000-07:00

I was looking at java.util.TimeZone class. I guessed this could be important in places like the USA where there are three or more timezones.

However in addition to being usefull for places with different timezones it also seems to cater to places with daylight savings time. For the uninformed, especially from places like india where there is no daylight savings this link gives a lot of information :-

http://en.wikipedia.org/wiki/Daylight_saving_time

The javadoc is at :-

http://java.sun.com/j2se/1.4.2/docs/api/java/util/TimeZone.html

The interesting methods to use are the getOffset Methods :-

public abstract int getOffset(int era,int year,int month,int day,int dayOfWeek,int milliseconds)

Gets the time zone offset, for current date, modified in case of daylight savings. This is the offset to add to UTC to get local time.
This method returns a historically correct offset if an underlying TimeZone implementation subclass supports historical Daylight Saving Time schedule and GMT offset changes.

One can use this method in this fashion :-

TimeZone tz = timeZone.getTimeZone("America/Los_Angeles");
long actualDate = (new Date().getTime() ) + timeZone.getOffset(new Date().getTime() )

java NIO allocate vs allocateDirect

2005-10-17T02:13:00.000-07:00

Java NIO (new IO) came up with JDK 1.4.

As of now there is only one book out there that deals with it :-
http://www.amazon.com/exec/obidos/tg/detail/-/0596002882/104-4162257-7590320?v=glance

I wanted to have a look at some of the new stuff, and looked at some material on the net.

Buffers are to pimitive types what collections are to Objects.

What interests me is that the new java nio ByteBuffer class has two ways to create a new ByteBuffer i.e the static methods allocate and allocateDirect.

As i understand allocateDirect, will allocate it directly in the OS memory space and not in the JVM space. It has the primary advantage of not using up too much JVM memory for large files or other hige primitive type data.

Here are the common method used for the code below:-
static void logTime(String seq){
System.out.println(seq + " : " + new Date(System.currentTimeMillis()));
}

static void showBufferProperties( Buffer buf,String name){

System.out.println( "Buffer Properties for " + name + "\n capacity=" + buf.capacity() + " limit=" + buf.limit() + " position=" + buf.position());

}

I tried out the following :-

logTime("1");
ByteBuffer buf5 = ByteBuffer.allocate(300000000);
logTime("1a");
for(int i = 0; i
buf5.putDouble(1.0/3.0).
putFloat((float)(1.0/6.0)).
putLong(Long.MAX_VALUE);
}
showBufferProperties(buf5,"buf5");
logTime("2");

And got this result.

1 : Mon Oct 17 10:20:19 BST 2005
java.lang.OutOfMemoryError
Exception in thread "main"

Then i tried this :-

logTime("3");
ByteBuffer buf6 = ByteBuffer.allocateDirect(300000000);
logTime("3a");
for(int i = 0; i
buf6.putDouble(1.0/3.0).
putFloat((float)(1.0/6.0)).
putLong(Long.MAX_VALUE);
}
showBufferProperties(buf6,"buf6");
logTime("4");

And got this result:-

3 : Mon Oct 17 10:22:53 BST 2005
3a : Mon Oct 17 10:23:00 BST 2005
Buffer Properties for buf6
capacity=300000000 limit=300000000 position=60000000
4 : Mon Oct 17 10:23:09 BST 2005

So clearly for huge files allocateDirect does work well as compared to allocate which give an out of memory error.

Here is what the java doc says :-

Direct vs. non-direct buffers

A byte buffer is either direct or non-direct. Given a direct byte buffer, the Java virtual machine will make a best effort to perform native I/O operations directly upon it. That is, it will attempt to avoid copying the buffer's content to (or from) an intermediate buffer before (or after) each invocation of one of the underlying operating system's native I/O operations.
A direct byte buffer may be created by invoking the allocateDirect factory method of this class. The buffers returned by this method typically have somewhat higher allocation and deallocation costs than non-direct buffers. It is therefore recommended that such buffers be used primarily for large, long-lived buffers that are subject to the underlying system's native
I/O operations.

A direct byte buffer may also be created by mapping a region of a file directly into memory. An implementation of the Java platform may optionally support the creation of direct byte buffers from native code via JNI. If an instance of one of these kinds of buffers refers to an inaccessible region of memory then an attempt to access that region will either return an arbitrary value, have no visible effect, or cause an unspecified exception to be thrown.

Whether a byte buffer is direct or non-direct may be determined by invoking its isDirect method.

So it is as good as reading or writing to system memory directy using JNI and then wrapping it with java code. The additional advantage is it does not use the JVM memory space.

I can also see the advantage of using this if there are many smaller files all open at the same time for a application. It could use up the jvm heap space very fast. JVM is a heap space meant for objects. To use it up for reading or writing files would not be so good.

Also i guess it is better if we use the OS for what it does best i.e handle files.

I can see that this new bytebuffer class will go a long way to help with the above.

Also the other advantage v/s doing the same with JNI is that this is platform neutral. Just say allocateDirect and the java code will use the OS memory. JNI code might have to be coded for each OS on which you will deploy the application.

Note:-

It seems that for direct buffers hasArray method returns true meaning that it does have a array behind it , and for non-direct buffers the hasArray method returns false that is it does not have a backing array. The array can be retrieved by invoking the the array() method on ByteBuffer class.

JDK 1.4 VS Log4J Logging

2005-10-13T08:16:00.000-07:00

JDK 1.4 has a java.util.logging package. It is based on JSR047.

http://www.swzoo.org/documents/miscellaneous/jsr047/

I just tried to have a look and see how it is different from Log4j that i have used over the years.

As per ..\j2sdk1.4.2_03\docs\api\java\util\logging\Level.html it has following levels :-

"
The levels in descending order are:
SEVERE (highest value)
WARNING
INFO
CONFIG
FINE
FINER
FINEST (lowest value) In addition there is a level OFF that can be used to turn off logging, and a level ALL that can be used to enable logging of all messages.
"

I guess ALL and OFF could be used as they are provided , but why would one logically use them is the question.

Also Fine, Finer and Finest seem a bit .... Odd i would say. What is wrong with log4j's - FATAL, ERROR, WARN, INFO and DEBUG.

What is CONFIG anyway ?

From the same API page

"
CONFIGpublic static final Level CONFIG
CONFIG is a message level for static configuration messages.
CONFIG messages are intended to provide a variety of static configuration information, to assist in debugging problems that may be associated with particular configurations. For example, CONFIG message might include the CPU type, the graphics depth, the GUI look-and-feel, etc. This level is initialized to 700.
"

So there is a level for just for configuration type log messages ? Interesting !

Then i found out what a developer of Log4j has to say here :-
http://www.ingrid.org/jajakarta/log4j/jakarta-log4j-1.1.3/docs/critique.html

and also a discussion on theserverside here
http://www.theserverside.com/news/thread.tss?thread_id=7177

What they seem to saying in gist is :-

At first glance, this might look like a mundane implementation detail but it is actually quite fundamental.

Configuration order matters
In JSR47, when you set the level of a logger, say wombat, JSR47 traverses the tree below wombat. In other words, the levels for all the loggers descending from wombat are overwritten. This can be a very expensive operation for large trees. In particular, for the most common case where one sets the level of the root logger. However, performance is not the point I am trying to make.

In log4j, changing the priority of a category involves the change of a single field. Children categories dynamically inherit the priority of their parent by traversing the hierarchy tree upwards.

It follows that with JSR47 if you configure the level for logger "foo.bar1" before configuring the level for "foo", then the latter instruction will overwrite the first exactly as if the first instruction for configuring "foo.bar1" had never existed. Configuration order dependence is not a show stopper but it is something that will bite you time and again.

In contrast, in log4j categories can be configured in any order. You never have to worry about configuration order.

Limited inheritance
In JSR47, a logger does not walk the hierarchy to inherit its level but possesses a copy of it.
Unfortunately, in the JSR47 API, handlers cannot be inherited because it would be prohibitively expensive to let each logger to contain a distinct Vector of all inherited handlers, especially in large trees.

To circumvent this problem by JSR47 defines global handlers. A logger logs to global handlers and to the handlers attached to itself directly. It does not inherit any handlers from the hierarchy.

In log4j, appenders are inherited additively from the hierarchy. A category will log to the appenders attached to itself as well as the appenders attached to its ancestors. This might not seem like much until the day you need handler inheritance; probably a week after you decide to adopt a logging API.

Similarly, in log4j resource bundles are inherited from the hierarchy. In JSR47, a resource bundle must be attached to each logger individually. There is no resource bundle inheritance in JSR47. In practice, this means that you have to choose between internationalization and the benefits of the named logger hierarchy. It's one or the other. This limitation is particularly surprising because support for internationalization is advocated as one of the primary advantages of the JSR47 API.

Limited functionality
Log4j has appenders capable of logging to the console, to files, to Unix Syslog daemons, to Microsoft NT EventLoggers, remote servers, to JMS channels, automatically generate email etc. It can roll log files by size or date and log asynchronously.

JSR47 can log to the console, to files, to sockets and to a memory buffer.

Log4j has an extensible and powerful layout called the PatternLayout. JSR47 offers the much weaker SimpleFormatter as an alternative.

Log4j supports configuration through property files as well as XML documents. JSR47 currently admits only property files. Moreover, the language of JSR47 configuration files is very weak. In particular, you can only configure one instance of a given handler class. This means that you can log to just one file at a time.

Error Handling
In JSR 47 when an error occurs then either a RunTimeException is thrown to the user or (in handlers only) an internal field is set. In the first case, the RunTimeException will cause your application to crash. In the latter case, you can retrieve the last caught exception in the handler by querying the getException method of that handler. The former is totally unacceptable while the latter is impractical.

In log4j, under no circumstances are exceptions thrown at the user. However, all appenders have an associated ErrorHandler. This ErrorHandler is invoked by the appender whenever a handler-specific error occurs. By default, log4j appenders are associated with an OnlyOnceErrorHandler which emits a message on the console for the first error in an appender and ignoring all following errors.

An ErrorHandler can implement an arbitrary error handling policy. For example, after a failure to write to a database a JDBCAppender can be redirected to fall back on a FileAppender. This functionality is supported in XML configuration files. You do not need to change a single line of client code.

But again who cares about errors, right?

Performance
Logging performance must be studied in three distinct cases: when logging is turned off, when turned on but due to priority comparison logic not enabled, and when actually logging. Please refer to the log4j manual for a more detailed discussion of logging performance.

When logging is turned on, log4j will be about three times slower to decide whether a log statement is enabled or not. This is due to the dynamic nature of log4j which requires it to walk the hierarchy. To give you an idea about the figures involved, we are talking about 90 nanoseconds instead of 30 nanoseconds on a 800Mhz Intel processor. In other words, one million disabled logging requests will cost under a second in both environments.

In a shipped binary, you can turn off logging entirely and both APIs will perform identically. Note that if one is not careful, the cost of parameter construction before invoking a disabled log statement will overwhelm any other performance consideration. Regardless of the API you decide to use, logging statements should never be placed in tight loops, for example, before or after an element swap instruction in a sort algorithm.

In log4j, caller localization information is optional whereas in JSR47 it is always extracted. Since
the extraction of caller localization is a very slow operation, in the common case where caller information is not needed, log4j will log the same information 4 to 100 times faster.

Lastly as of now the new logging mechanism will work only with JDK 1.4 and above.

Then i looked at 1.5 api here :-
http://java.sun.com/j2se/1.5.0/docs/api/index.html

The Logging levels at least seem to be the same. They seem to have added a interface "LoggingMXBean" http://java.sun.com/j2se/1.5.0/docs/api/java/util/logging/LoggingMXBean.html .

It is a
"The management interface for the logging facility.
There is a single global instance of the LoggingMXBean"

The LogManager class in java.uti.logging package now has a LogManager.getLoggingMXBean() method which returns this interface used for managing the logging facility.

Ansyway as of now i will stick with Log4j.

Hibernate 3 with Microsoft ms access 2000 odbc

2005-05-05T07:14:00.000-07:00

Hibernate 3 with Microsoft ms access 2000 odbc

MS access is a kind of low feature DB to be found on most windoz PC's today.

My view is that to check out a few features of hibernate one need not have oracle, db2 or other such high end db.

To know what is hibernate please visit www.hibernate.org .

Now for using Hibernate, one must set up certain mandatory properties in a file generally called hibernate.properties file.

One of such a property is dialect : hibernate.dialect

There are several out of the box dialects given by hibernate that support Oracle, Db2 , MySQL etc.

However there is no out of the box support for MS Access.

What hibernate has though is an exellent plugglabe architechture, that allows users to specify new dialects by subclassing from org.hibernate.dialect.Dialect class.

So i tried to write up a class called MSAccessDialect.

The main issues i faced were mostly with Inserts and identitiy columns.

To know what an identity column in hibernate means please see here:-
http://www.hibernate.org/hib_docs/reference/en/html/mapping.html

I have got it working with Hibernate with Microsoft ms access odbc, including inserts and reads with identity.
I am using hibernate 3.0 , JDK 1.4 and Microsoft ms access 200.

Here is the dialect class:-

package org.hibernate.dialect;

import java.sql.Types;

import org.hibernate.cfg.Environment;

/**
* @author Suchak.Jani
*/
public class MSAccessDialect extends Dialect {
public MSAccessDialect() {
super();
registerColumnType( Types.BIT, "BIT" );
registerColumnType( Types.BIGINT, "INTEGER" );
registerColumnType( Types.SMALLINT, "SMALLINT" );
registerColumnType( Types.TINYINT, "BYTE" );
registerColumnType( Types.INTEGER, "INTEGER" );
registerColumnType( Types.CHAR, "VARCHAR(1)" );
registerColumnType( Types.VARCHAR, "VARCHAR($l)" );
registerColumnType( Types.FLOAT, "DOUBLE" );
registerColumnType( Types.DOUBLE, "DOUBLE" );
registerColumnType( Types.DATE, "DATETIME" );
registerColumnType( Types.TIME, "DATETIME" );
registerColumnType( Types.TIMESTAMP, "DATETIME" );
registerColumnType( Types.VARBINARY, "VARBINARY($l)" );
registerColumnType( Types.NUMERIC, "NUMERIC" );

getDefaultProperties().setProperty(Environment.STATEMENT_BATCH_SIZE,NO_BATCH);
}

public String getIdentityColumnString() {
//return " counter ";
return "not null auto_number";
}

public String getIdentitySelectString() {
return "select @@IDENTITY";
}
}

Here is a test xml file which works :-

<hibernate-mapping>
<class name="com.suchak.hibernatetest.domainobjects.Person" table="Person">
<id name="ID" column="ID" >
<generator class="identity"/>
</id>
<property name="firstName">
<column name="FirstName"/>
</property>
<property name="lastName">
<column name="LastName"/>
</property>
</class>
</hibernate-mapping>

The above ID is an Interger in java and Autonumber in Microsoft ms access

Also it goes without saying that there is a person object. You can create it looking at the xml above.

Note:- There are problems of still not being able to use Long with the above but that is due to issues of the ms odbc driver. It has nothing to do with Hibernate.

Struts mapping recap

2005-01-04T02:41:00.000-08:00

Here is a sample stuts action mapping:-

<form-beans>
<form-bean name="TestForm" type="com.test.form.TestForm">
</form-bean>
<action-mappings>
<action path="/Test" parameter="action" type="com.test.action.TestAction" scope="request" validate="false" name="TestForm">
<forward name="list" path="/web/jsp/test.jsp" redirect="false">
</forward>
</action>

The name parameter is what tells what is the form.
In the above the parameter action is what defines where the execution of the struts dispatch action will go to.
For example /Test?list will go a method called list in the Test Dispatch action.
There is only one forward above with the same name list, so mapping.findforward("list"), will forward to "/web/jsp/test.jsp". The redirect false will make sure that it is not redirected.

If it were to be redirect=true, the conatiner would forward the "/web/jsp/test.jsp" to the browser and then again asks the bowser to submit the same back to the server. Whatever test,jsp renders on screen after the submit of that test.jsp(which might have some form) would be visible. after that.

In short instead of just a forward to test.jsp , it forwards to test.jsp and then forces the browser to submit test.jsp again.

Internally this is done using two diffetent serlet api methods.

The forward is done using the requestdispatcher forward method
http://java.sun.com/j2ee/sdk_1.3/techdocs/api/javax/servlet/RequestDispatcher.html#forward

The redirect is done using the sendRedirect method of the http response object.
http://java.sun.com/j2ee/sdk_1.3/techdocs/api/javax/servlet/http/HttpServletResponse.html#sendRedirect

Needless to say whatever was there in the first request scope will be lost.One way to not loose pervious request data is the use of hidden variables back and forth but this can be very cumbersome.

Understanding EJB transactions

2005-01-02T22:59:00.000-08:00

Transaction isolation

This is a property related to the database.

TRANSACTION_SERIALIZABLE—Simultaneously executing this transaction multiple times has the same effect as executing the transaction multiple times in a serial fashion. This is the most restrictive and should be avoided is most cases.This solves the problems of phantom reads by never letting any other transaction even read or update this data.
TRANSACTION_REPEATABLE_READ—Once the transaction reads a subset of data, repeated reads of the same data return the same values, even if other transactions have subsequently modified the data. This is the also restrictive but less than TRANSACTION_SERIALIZABLE and also should be avoided is most cases. This solves the problem of non repreatable reads.
TRANSACTION_READ_COMMITTED—The transaction can view only committed updates from other transactions. This is the default in servers like weblogic. This solves the problem of dirty reads.
TRANSACTION_READ_UNCOMMITTED—The transaction can view uncommitted updates from other transactions. This is least restrictive, but it is also makes dirty reads possible.

How does a transaction apply itslef to an EJB ?

How to declare what transaction scheme to use ?trans-attribute in ejb-jar.xml

Specifies how the container manages the transaction boundaries when delegating a method invocation to an enterprise bean's business method. Allowable value include:
* NotSupported
* Supports
* Required
* RequiresNew
* Mandatory
* Never

Note: Because clients do not provide a transaction context for calls to an MDB, MDBs that use container-managed transactions must have trans-attribute of Required.

If not specified, the EJB container issues a warning, and uses NotSupported for MDBs and Supports for other types of EJBs.

In a stateless session bean as well as an entity bean the transaction does not span method calls. In statefull session bean since there is a user session invloved the transaction can span various method call.

There is an interface called javax.ejb.SessionSynchronization which provides call back methods to the statefull session bean so as to know what is happening with the transaction:-
http://java.sun.com/products/ejb/javadoc-1.0/javax.ejb-javadoc/javax.ejb.SessionSynchronization.html

afterBegin

 public abstract void afterBegin() throws RemoteException

The afterBegin method notifies a session Bean instance that a new transaction has started, and that the subsequent business methods on the instance will be invoked in the context of the transaction.

The instance can use this method, for example, to read data from a database and cache the data in the instance fields.

This method executes in the proper transaction context.

Throws: RemoteException: Thrown if the instance could not perform the function requested by the container because of a system-level error.

beforeCompletion

 public abstract void beforeCompletion() throws RemoteException

The beforeCompletion method notifies a session Bean instance that a transaction is about to be committed. The instance can use this method, for example, to write any cached data to a database.

This method executes in the proper transaction context.

Note: The instance may still cause the container to rollback the transaction by invoking the setRollbackOnly() method on the instance context, or by throwing an exception.

Throws: RemoteException: Thrown if the instance could not perform the function requested by the container because of a system-level error.

afterCompletion

 public abstract void afterCompletion(boolean committed) throws RemoteException

The afterCompletion method notifies a session Bean instance that a transaction commit protocol has completed, and tells the instance whether the transaction has been committed or rolled back.

This method executes with no transaction context.

Parameters:: committed - True if the transaction has been committed, false if is has been rolled back.
Throws: RemoteException: Thrown if the instance could not perform the function requested by the container because of a system-level error.

However you can start a transaction in a method of a session bean and then call other some other bean's methods. This way you can propogate transactions.

Lets say you have a parent EJB and a child EJB.

All parent and child EJB methods have transaction as RequriesNew.
In this case it is suprising but true, that all unchecked and runtime exceptions in child mthods will cause the parent to roll back too. Checked application exceptions will have no effect on the parent. However here if the parent fails after the child has finished executing, the results of the child will not have any effect.

All parent and child EJB methods have transaction as Requries.
In this case too all unchecked and runtime exceptions in child methods will cause the parent to roll back too. Also they both have the same Transaction context as the parent here propogates the transaction to the child. Here if the parent fails after the child has finished executing, the results of the child will also roll back.

Nested transactions:
By default EJB's do not support nested transactions.
However one can simulate nested transactions by using a combination of the "parent and child EJB methods have transaction as Requries. " and "parent and child EJB methods have transaction as RequriesNew" or a combination of the above, type of architechture. You can not let parent rollback by using requiresNew on the child EJB and then you have two seperate transactions independent of each other.Also You can force a parent rollback by having all child EJB's that are called throw up an excpetion like " ForceRollbackParentException and make sure that the parent has not caught it.

Patterns 3 : Behavioral patterns

2004-12-29T23:25:00.000-08:00

Chain of Responsibility
The Chain of Responsibility pattern allows a number of classes to attempt to handle a request, without any of them knowing about the capabilities of the other classes. It provides a loose coupling between these classes; the only common link is the request that is passed between them. The request is passed along until one of the classes can handle it.

Applicability
We use the Chain of Responsibility when
· You have more than one handler that can handle a request and there is no way to know which handler to use. The handler must be determined automatically by the chain.
· You want to issue a request to one of several objects without specifying which one explicitly.
· You want to be able to modify the set of objects dynamically that can handle requests.

A Chain or a Tree?
Of course, a Chain of Responsibility does not have to be linear. The Smalltalk Companion suggests that it is more generally a tree structure with a number of specific entry points all pointing upward to the most general node.

Another way of handling a tree-like structure is to have a single entry point that branches to the specific button, menu or other widget types, and then “un-branches” as above to more general help cases. There is little reason for that complexity -- you could align the classes into a single chain, starting at the bottom, and going left to right and up a row at a time until the entire system had been traversed.

Consequences of the Chain of Responsibility
1. The main purpose for this pattern, like a number of others, is to reduce coupling between objects. An object only needs to know how to forward the request to other objects.
2. This approach also gives you added flexibility in distributing responsibilities between objects. Any object can satisfy some or all of the requests, and you can change both the chain and the responsibilities at run time.
3. An advantage is that there may not be any object that can handle the request, however, the last object in the chain may simply discard any requests it can’t handle.
4. Finally, since Java can not provide multiple inheritance, the basic Chain class needs to be an interface rather than an abstract class, so that the individual objects can inherit from another useful hierarchy, as we did here by deriving them all from JPanel. This disadvantage of this approach is that you often have to implement the linking, sending and forwarding code in each module separately.

Command pattern
The Chain of Responsibility forwards requests along a chain of classes, but the Command pattern forwards a request only to a specific module. It encloses a request for a specific action inside an object and gives it a known public interface. It lets you give the client the ability to make requests without knowing anything about the actual action that will be performed, and allows you to change that action without affecting the client program in any way.

One important purpose of the Command pattern is to keep the program and user interface objects completely separate from the actions that they initiate. In other words, these program objects should be completely separate from each other and should not have to know how other objects work. The user interface receives a command and tells a Command object to carry out whatever duties it has been instructed to do. The UI does not and should not need to know what tasks will be executed.

The Command object can also be used when you need to tell the program to execute the command when the resources are available rather than immediately. In such cases, you are queuing commands to be executed later. Finally, you can use Command objects to remember operations so that you can support Undo requests.

Consequences of the Command Pattern
The main disadvantage of the Command pattern is a proliferation of little classes that either clutters up the main class if they are inner or clutters up the program namespace if they are outer classes.
Now even in the case where we put all of our actionPerformed events in a single basket, we usually call little private methods to carry out the actual function. It turns out that these private methods are just about as long as our little inner classes, so there is frequently little difference in complexity between inner and outer class approaches.

Anonymous Inner Classes
We can reduce the clutter of our name space by creating unnamed inner classes by declaring an instance of a class on the spot where we need it. For example, we could create our Red button and the class for manipulating the background all at once

btnRed.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
p.setBackground(Color.red);
}
} );

This is not very readable, however, and does not really improve the number of run-time classes since the compiler generates a class file even for these unnamed classes.

In fact, there is very little difference in the compiled code size among these various methods, once you create classes in any form at all.

Byte code size of Command class implementations
Program type Byte code size
No command classes 1719
Named inner classes 4450
Unnamed inner classes 3683
External classes 3838

Providing Undo
Another of the main reasons for using Command design patterns is that they provide a convenient way to store and execute an Undo function. Each command object can remember what it just did and restore that state when requested to do so if the computational and memory requirements are not too overwhelming.

Interpreter pattern
Some programs benefit from having a language to describe operations they can perform. The Interpreter pattern generally describes defining a grammar for that language and using that grammar to interpret statements in that language.

Motivation
When a program presents a number of different, but somewhat similar cases it can deal with, it can be advantageous to use a simple language to describe these cases and then have the program interpret that language. Such cases can be as simple as the sort of Macro language recording facilities a number of office suite programs provide, or as complex as Visual Basic for
Applications (VBA). VBA is not only included in Microsoft Office products, but can be embedded in any number of third party products quite simply.

One of the problems we must deal with is how to recognize when a language can be helpful. The Macro language recorder simply records menu and keystroke operations for later playback and just barely qualifies as a language; it may not actually have a written form or grammar. Languages such as VBA, on the other hand, are quite complex, but are far beyond the
capabilities of the individual application developer. Further, embedding commercial languages such as VBA, Java or SmallTalk usually require substantial licensing fees, which make them less attractive to all but the largest developers.

Applicability
As the SmallTalk Companion notes, recognizing cases where an Interpreter can be helpful is much of the problem, and programmers without formal language/compiler training frequently overlook this approach. There are not large numbers of such cases, but there are two general places where languages are applicable:

1. When the program must parse an algebraic string. This case is fairly obvious. The program is asked to carry out its operations based on a computation where the user enters an equation of some sort. This frequently occurs in mathematical-graphics programs, where the program renders a curve or surface based on any equation it can evaluate.
Programs like Mathematica and graph drawing packages such as Origin work in this way.

2. When the program must produce varying kinds of output. This case is a little less obvious, but far more useful. Consider a program that can display columns of data in any order and sort them in various ways. These programs are frequently referred to as Report Generators, and
while the underlying data may be stored in a relational database, the user interface to the report program is usually much simpler then the SQL language which the database uses. In fact, in some cases, the simple report language may be interpreted by the report program and translated into SQL.

Consequences of the Interpreter Pattern
Whenever you introduce an interpreter into a program, you need to provide a simple way for the program user to enter commands in that language. It can be as simple as the Macro record button we noted earlier, or it can be an editable text field like the one in the program above.

However, introducing a language and its accompanying grammar also requires fairly extensive error checking for misspelled terms or misplaced grammatical elements. This can easily consume a great deal of programming effort unless some template code is available for implementing this checking. Further, effective methods for notifying the users of these errors are not easy to design and implement.

In the Interpreter example above, the only error handling is that keywords that are not recognized are not converted to ParseObjects and pushed onto the stack. Thus, nothing will happen, because the resulting stack sequence probably cannot be parsed successfully, or if it can, the item represented by the misspelled keyword will not be included.

You can also consider generating a language automatically from a user interface of radio and command buttons and list boxes. While it may seem that having such an interface obviates the necessity for a language at all, the same requirements of sequence and computation still apply. When you have to have a way to specify the order of sequential operations, a language is a good way to do so, even if the language is generated from the user interface.

The Interpreter pattern has the advantage that you can extend or revise the grammar fairly easily one you have built the general parsing and reduction tools. You can also add new verbs or variables quite easily once the foundation is constructed.

In the simple parsing scheme we show in the Parser class above, there are only 6 cases to consider, and they are shown as a series of simple if statements. If you have many more than that, Design Patterns suggests that you create a class for each one of them. This again makes language extension easier, but has the disadvantage of proliferating lots of similar little classes. Finally, as the syntax of the grammar becomes more complex, you run the risk of creating a hard to maintain program. While interpreters are not all that common in solving general programming problems, the Iterator pattern we take up next is one of the most common ones you’ll be using.

Iterator pattern
The Iterator is one of the simplest and most frequently used of the design patterns. The Iterator pattern allows you to move through a list or collection of data using a standard interface without having to know the details of the internal representations of that data. In addition you can also define special iterators that perform some special processing and return only specified elements of the data collection.

Mediator pattern
When a program is made up of a number of classes, the logic and computation is divided logically among these classes. However, as more of these isolated classes are developed in a program, the problem of communication between these classes become more complex. The more each class needs to know about the methods of another class, the more tangled the class structure can become. This makes the program harder to read and harder to maintain. Further, it can become difficult to change the program, since any change may affect code in several other classes. The Mediator pattern addresses this problem by promoting looser coupling between these classes. Mediators accomplish this by being the only class that has detailed knowledge of the methods of other classes. Classes send inform the mediator when changes occur and the Mediator passes them on to any other classes that need to be informed.

Consequences of the Mediator Pattern
1. The Mediator makes loose coupling possible between objects in a program. It also localizes the behavior that otherwise would be distributed among several objects.
2. You can change the behavior of the program by simply changing or subclassing the Mediator.
3. The Mediator approach makes it possible to add new Colleagues to a system without having to change any other part of the program.
4. The Mediator solves the problem of each Command object needing to know too much about the objects and methods in the rest of a user interface.
5. The Mediator can become monolithic in complexity, making it hard to change and maintain. Sometimes you can improve this situation by revising the responsibilities you have given the Mediator. Each object should carry out it’s own tasks and the Mediator should only manage the
interaction between objects.
6. Each Mediator is a custom-written class that has methods for each Colleague to call and knows what methods each Colleague has available. This makes it difficult to reuse Mediator code in different projects. On the other hand, most Mediators are quite simple and writing this code is far easier than managing the complex object interactions any other way.

Implementation Issues
The Mediator pattern we have described above acts as a kind of Observer pattern, observing changes in the Colleague elements. Another approach is to have a single interface to your Mediator, and pass that method various constants or objects which tell the Mediator which operations to perform. In the same fashion, you could have a single Colleague interface that each Colleague would implement, and each Colleague would then decide what operation it was to carry out.
Mediators are not limited to use in visual interface programs, however, it is their most common application. You can use them whenever you are faced with the problem of complex intercommunication between a number of objects.

Memento pattern
Suppose you would like to save the internal state of an object so you can restore it later. Ideally, it should be possible to save and restore this state without making the object itself take care of this task, and without violating encapsulation. This is the purpose of the Memento pattern.

Motivation
Objects frequently expose only some of their internal state using public methods, but you would still like to be able to save the entire state of an object because you might need to restore it later. In some cases, you could obtain enough information from the public interfaces (such as the drawing position of graphical objects) to save and restore that data. In other cases, the color, shading, angle and connection relationship to other graphical objects need to be saved and this information is not readily available. This sort of information saving and restoration is common in systems that need to support

Undo commands.
If all of the information describing an object is available in public variables, it is not that difficult to save them in some external store. However, making these data public makes the entire system vulnerable to change by external program code, when we usually expect data inside an object to be private and encapsulated from the outside world.

The Memento pattern attempts to solve this problem by having privileged access to the state of the object you want to save. Other objects have only a more restricted access to the object, thus preserving their encapsulation. This pattern defines three roles for objects:
1. The Originator is the object whose state we want to save.
2. The Memento is another object that saves the state of the Originator.
3. The Caretaker manages the timing of the saving of the state, saves the Memento and, if needed, uses the Memento to restore the state of the Originator.

Consequences of the Memento
The Memento provides a way to preserve the state of an object while preserving encapsulation, in languages where this is possible. Thus, data that only the Originator class should have access to effectively remains private. It also preserves the simplicity of the Originator class by delegating the saving and restoring of information to the Memento class. On the other hand, the amount of information that a Memento has to save might be quite large, thus taking up fair amounts of storage. This further has an effect on the Caretaker class (here the Mediator) which may have to design strategies to limit the number of objects for which it saves state. In our simple example, we impose no such limits. In cases where objects change in a predictable manner, each Memento may be able to get by with saving only incremental changes of an object’s state.

Other Kinds of Mementos
While supporting undo/redo operations in graphical interfaces is one significant use of the Memento pattern, you will also see Mementos used in database transactions. Here they save the state of data in a transaction where it is necessary to restore the data if the transaction fails or is incomplete.

Observer pattern
Consequences of the Observer Pattern
Observers promote abstract coupling to Subjects. A subject doesn’t know the details of any of its observers. However, this has the potential disadvantage of successive or repeated updates to the Observers when there are a series of incremental changes to the data. If the cost of these updates is high, it may be necessary to introduce some sort of change management, so that the Observers are not notified too soon or too frequently. When one client makes a change in the underlying data, you need to decide which object will initiate the notification of the change to the other observers. If the Subject notifies all the observers when it is changed, each client is not responsible for remembering to initiate the notification. On the other hand, this can result in a number of small successive updates being triggered. If the clients tell the Subject when to notify the other clients, this cascading notification can be avoided, but the clients are left with the responsibility of telling the Subject when to send the notifications. If one client “forgets,” the program simply won’t work properly. Finally, you can specify the kind of notification you choose to send by defining a number of update methods for the Observers to receive depending on the type or scope of change. In some cases, the clients will thus be able to ignore some of these notifications

State pattern
The State pattern is used when you want to have an enclosing class switch between a number of related contained classes, and pass method calls on to the current contained class. Design Patterns suggests that the State pattern switches between internal classes in such a way that the enclosing object appears to change its class. In Java, at least, this is a bit of an exaggeration, but the actual purpose to which the classes are put can change significantly.

Many programmers have had the experience of creating a class which performs slightly different computations or displays different information based on the arguments passed into the class. This frequently leads to some sort of switch or if-else statements inside the class that determine which behavior to carry out. It is this inelegance that the State pattern seeks to replace.

Consequences of the State Pattern
1. The State pattern localizes state-specific behavior in an individual class for each state, and puts all the behavior for that state in a single object.
2. It eliminates the necessity for a set of long, look-alike conditional statements scattered through the program’s code.
3. It makes transition explicit. Rather than having a constant that specifies which state the program is in, and that may not always be checked correctly, this makes the change explicit by copying one of the states to the state variable.
4. State objects can be shared if they have no instance variables. Here only the Fill object has instance variables, and that color could easily be made an argument instead.
5. This approach generates a number of small class objects, but in the process, simplifies and clarifies the program.
6. In Java, all of the States must inherit from a common base class, and they must all have common methods, although some of those methods can be empty. In other languages, the states can be implemented by function pointers with much less type checking, and, of course, greater chance of error.

Strategy pattern
The Strategy pattern is much like the State pattern in outline, but a little different in intent. The Strategy pattern consists of a number of related algorithms encapsulated in a driver class called the Context. Your client program can select one of these differing algorithms or in some cases the Context might select the best one for you. The intent, like the State pattern, is to switch easily between algorithms without any monolithic conditional statements. The difference between State and Strategy is that the user generally chooses which of several strategies to apply and that only one strategy at a time is likely to be instantiated and active within the Context class. By contrast, as we have seen, it is likely that all of the different States will be active at once and switching may occur frequently between them. In addition, Strategy encapsulates several algorithms that do more or less the same thing, while State encapsulates related classes that each do something somewhat different. Finally, the concept of transition between different states is completely missing in the Strategy pattern.

Motivation
A program which requires a particular service or function and which has several ways of carrying out that function is a candidate for the Strategy pattern. Programs choose between these algorithms based on computational efficiency or user choice. There can be any number of strategies and more can be added and any of them can be changed at any time.

There are a number of cases in programs where we’d like to do the same thing in several different ways. Some of these are listed in the Smalltalk Companion:
· Save files in different formats.
· Compress files using different algorithms
· Capture video data using different compression schemes
· Use different line-breaking strategies to display text data.
· Plot the same data in different formats: line graph, bar chart or pie chart.

In each case we could imagine the client program telling a driver module (Context) which of these strategies to use and then asking it to carry out the operation.
The idea behind Strategy is to encapsulate the various strategies in a single module and provide a simple interface to allow choice between these strategies. Each of them should have the same programming interface, although they need not all be members of the same class hierarchy. However, they do have to implement the same programming interface.

Consequences of the Strategy Pattern
Strategy allows you to select one of several algorithms dynamically. These algorithms can be related in an inheritance hierarchy or they can be unrelated as long as they implement a common interface. Since the Context switches between strategies at your request, you have more flexibility than if you simply called the desired derived class. This approach also avoids the sort of condition statements than can make code hard to read ad maintain. On the other hand, strategies don’t hide everything. The client code must be aware that there are a number of alternative strategies and have some criteria for choosing among them. This shifts an algorithmic decision to the client programmer or the user.
Since there are a number of different parameters that you might pass to different algorithms, you have to develop a Context interface and strategy methods that are broad enough to allow for passing in parameters that are not used by that particular algorithm.

Template pattern
Whenever you write a parent class where you leave one or more of the methods to be implemented by derived classes, you are in essence using the Template pattern. The Template pattern formalizes the idea of defining an algorithm in a class, but leaving some of the details to be implemented in subclasses. In other words, if your base class is an abstract class, as often happens in these design patterns, you are using a simple form of the Template pattern.

Motivation
Templates are so fundamental, you have probably used them dozens of times without even thinking about it. The idea behind the Template pattern is that some parts of an algorithm are well defined and can be implemented in the base class, while other parts may have several implementations and are best left to derived classes. Another main theme is recognizing that there are some basic parts of a class that can be factored out and put in a base class so that they do not need to be repeated in several subclasses.

Kinds of Methods in a Template Class
A Template has four kinds of methods that you can make use of in derive classes:
1. Complete methods that carry out some basic function that all the subclasses will want to use, such as calcx and calcy in the above example. These are called Concrete methods.
2. Methods that are not filled in at all and must be implemented in derived classes. In Java , you would declare these as abstract methods, and that is how they are referred to in the pattern description.
3. Methods that contain a default implementation of some operations, but which may be overridden in derived classes. These are called Hook methods. Of course this is somewhat
arbitrary, because in Java you can override any public or protected method in the derived class, but Hook methods are intended to be overridden, while Concrete methods are not.
4. Finally, a Template class may contain methods which themselves call any combination of abstract, hook and concrete methods. These methods are not intended to be overridden, but describe an algorithm without actually implementing its details. Design Patterns refers to these as Template methods.

Summary and Consequences
Template patterns occur all the time in OO software and are neither complex nor obscure in intent. They are normal part of OO programming and you shouldn’t try to make them more abstract than they actually are.
The first significant point is that your base class may only define some of the methods it will be using, leaving the rest to be implemented in the derived classes. The second major point is that there may be methods in the base class which call a sequence of methods, some implemented in the base class and some implemented in the derived class. This Template method defines a general algorithm, although the details may not be worked out completely in the base class.
Template classes will frequently have some abstract methods that you must override in the derived classes, and may also have some classes with a simple “place-holder” implementation that you are free to override where this is appropriate. If these place-holder classes are called from another method in the base class, then we refer to these overridable methods are “Hook” methods.

Visitor pattern
The Visitor pattern turns the tables on our object-oriented model and creates an external class to act on data in other classes. This is useful if there are a fair number of instances of a small number of classes and you want to perform some operation that involves all or most of them.

Motivation
While at first it may seem “unclean” to put operations that should be inside a class in another class instead, there are good reasons for doing it. Suppose each of a number of drawing object classes has similar code for drawing itself. The drawing methods may be different, but they probably all use underlying utility functions that we might have to duplicate in each class. Further, a set of closely related functions is scattered throughout a number of different classes

When to Use the Visitor Pattern
You should consider using a Visitor pattern when you want to perform an operation on the data contained in a number of objects that have different interfaces. Visitors are also valuable if you have to perform a number of unrelated operations on these classes. On the other hand, as we will see below, Visitors are a good choice only when you do not expect many new classes to be added to your program.

Sample Code
We have a simple Employee object which maintains a record of the employee’s name, salary, vacation taken and number of sick days taken. A simple version of this class is:

public class Employee
{
int sickDays, vacDays;
float Salary;
String Name;
public Employee(String name, float salary,
int vacdays, int sickdays)
{
vacDays = vacdays; sickDays = sickdays;
Salary = salary; Name = name;
}
public String getName() { return Name; }
public int getSickdays() { return sickDays; }
public int getVacDays() { return vacDays; }
public float getSalary() { return Salary; }
public void accept(Visitor v) { v.visit(this); }
}

Note that we have included the accept method in this class. Now let’s suppose that we want to prepare a report of the number of vacation days that all employees have taken so far this year. We could just write some code in the client to sum the results of calls to each Employee’s getVacDays function, or we could put this function into a Visitor.
Since Java is a strongly typed language, your base Visitor class needs to have a suitable abstract visit method for each kind of class in your program. In this first simple example, we only have Employees, so our basic abstract Visitor class is just

public abstract class Visitor
{
public abstract void visit(Employee emp);
}

Notice that there is no indication what the Visitor does with each class in either the client classes or the abstract Visitor class. We can in fact write a whole lot of visitors that do different things to the classes in our program. The Visitor we are going to write first just sums the vacation data
for all our employees:

public class VacationVisitor extends Visitor
{
protected int total_days;
public VacationVisitor() { total_days = 0; }
//-----------------------------
public void visit(Employee emp)
{
total_days += emp.getVacDays();
}
//-----------------------------
public int getTotalDays()
{
return total_days;
}
}

Visiting the Classes
Now, all we have to do to compute the total vacation taken is to go through a list of the employees and visit each of them, and then ask the Visitor for the total.

VacationVisitor vac = new VacationVisitor();
for (int i = 0; i < employees.length; i++)
{
employees[i].accept(vac);
}
System.out.println(vac.getTotalDays());

Let’s reiterate what happens for each visit:

1. We move through a loop of all the Employees.
2. The Visitor calls each Employee’s accept method.
3. That instance of Employee calls the Visitor’s visit method.
4. The Visitor fetches the vacation days and adds them into the total.
5. The main program prints out the total when the loop is complete.

Double Dispatching
No article on the Visitor pattern is complete without mentioning that you are really dispatching a method twice for the Visitor to work. The Visitor calls the polymorphic accept method of a given object, and the accept method calls the polymorphic visit method of the Visitor. It this bidirectional calling that allows you to add more operations on any class that has an accept method, since each new Visitor class we write can carry out whatever operations we might think of using the data available in these classes.

Traversing a Series of Classes
The calling program that passes the class instances to the Visitor must know about all the existing instances of classes to be visited and must keep them in a simple structure such as an array or Vector. Another possibility would be to create an Enumeration of these classes and pass it to the Visitor. Finally, the Visitor itself could keep the list of objects that it is to visit. In our simple example program, we used an array of objects, but any of the other methods would work equally well.

Consequence of the Visitor Pattern
The Visitor pattern is useful when you want to encapsulate fetching data from a number of instances of several classes. Design Patterns suggests that the Visitor can provide additional functionality to a class without changing it. We prefer to say that a Visitor can add functionality to a collection of classes and encapsulate the methods it uses. The Visitor is not magic, however, and cannot obtain private data from classes: it is limited to the data available from public methods. This might force you to provide public methods that you would otherwise not have provided. However, it can obtain data from a disparate collection of unrelated classes and utilize it to present the results of a global calculation to the user program.

It is easy to add new operations to a program using Visitors, since the Visitor contains the code instead of each of the individual classes. Further, Visitors can gather related operations into a single class rather than forcing you to change or derive classes to add these operations. This can make the program simpler to write and maintain.

Visitors are less helpful during a program’s growth stage, since each time you add new classes which must be visited, you have to add an abstract visit operation to the abstract Visitor class, and you must add an implementation for that class to each concrete Visitor you have written. Visitors can be powerful additions when the program reaches the point where many new classes are unlikely. Visitors can be used very effectively in Composite systems

Patterns 2 : Structural patterns

2004-12-27T23:18:00.000-08:00

Some of this material is from the java patterns book by James cooper.*

Adapter pattern
The Adapter pattern is used to convert the programming interface of one class into that of another. We use adapters whenever we want unrelated classes to work together in a single program. The concept of an adapter is thus pretty simple; we write a class that has the desired interface and then make it communicate with the class that has a different interface.

There are two ways to do this: by inheritance, and by object composition. In the first case, we derive a new class from the nonconforming one and add the methods we need to make the new derived class match the desired interface. The other way is to include the original class inside the new one and create the methods to translate calls within the new class. These two approaches, termed class adapters and object adapters are both fairly easy to implement in Java.

Bridge pattern
The Bridge pattern is used to separate the interface of class from its implementation, so that either can be varied separately. At first sight, the bridge pattern looks much like the Adapter pattern, in that a class is used to convert one kind of interface to another. However, the intent of the Adapter pattern is to make one or more classes’ interfaces look the same as that of a particular class. The Bridge pattern is designed to separate a class’s interface from its implementation, so that you can vary or replace the implementation without changing the client code.

Consequences of the Bridge Pattern
1. The Bridge pattern is intended to keep the interface to your client program constant while allowing you to change the actual kind of class you display or use. This can prevent you from recompiling a complicated set of user interface modules, and only require that you recompile the bridge itself and the actual end display class.

2. You can extend the implementation class and the bridge class separately, and usually without much interaction with each other.

3. You can hide implementation details from the client program much more easily.

Composite pattern.
Frequently programmers develop systems in which a component may be an individual object or it may represent a collection of objects. The Composite pattern is designed to accommodate both cases. You can use the Composite to build part-whole hierarchies or to construct data representations of trees. In summary, a composite is a collection of objects, any one of which may be either a composite, or just a primitive object. In tree nomenclature, some objects may be nodes with additional branches and some may be leaves.

The problem that develops is the dichotomy between having a single, simple interface to access all the objects in a composite, and the ability to distinguish between nodes and leaves. Nodes have children and can have children added to them, while leaves do not at the moment have children, and in some implementations may be prevented from having children added to them.

Some authors have suggested creating a separate interface for nodes
and leaves, where a leaf could have the methods

public String getName();
public String getValue();

and a node could have the additional methods:

public Enumeration elements();
public Node getChild(String nodeName);
public void add(Object obj);
public void remove(Object obj);

This then leaves us with the programming problem of deciding which elements will be which when we construct the composite.

However, Design Patterns suggests that each element should have the same interface, whether
it is a composite or a primitive element. This is easier to accomplish, but we are left with the question of what the getChild() operation should accomplish when the object is actually a leaf.

Java makes this quite easy for us, since every node or leaf can return an Enumeration of the contents of the Vector where the children are stored. If there are no children, the hasMoreElements() method returns false at once. Thus, if we simply obtain the Enumeration from each element, we can quickly determine whether it has any children by checking the
hasMoreElements() method.

Decorator Pattern
The Decorator pattern provides us with a way to modify the behavior of individual objects without having to create a new derived class. Suppose we have a program that uses eight objects, but three of them need an additional feature. You could create a derived class for each of these objects, and in many cases this would be a perfectly acceptable solution. However, if each of these three objects require different modifications, this would mean creating three derived classes. Further, if one of the classes has features of both of the other classes, you begin to create a complexity that is both confusing and unnecessary.

For example, suppose we wanted to draw a special border around some of the buttons in a toolbar. If we created a new derived button class, this means that all of the buttons in this new class would always have this same new border, when this might not be our intent. Instead, we create a Decorator class that decorates the buttons. Then we derive any number of specific Decorators from the main Decorator class, each of which performs a specific kind of decoration.

In order to decorate a button, the Decorator has to be an object derived from the visual environment, so it can receive paint method calls and forward calls to other useful graphic methods to the object that it is decorating. This is another case where object containment is favored over object inheritance. The decorator is a graphical object, but it contains the object it is decorating. It may intercept some graphical method calls, perform some additional computation and may pass them on to the underlying object it is decorating.

Non-Visual Decorators
Decorators, of course, are not limited to objects that enhance visual classes. You can add or modify the methods of any object in a similar fashion. In fact, non-visual objects are usually easier to decorate, because there are usually fewer methods to intercept and forward.

While coming up with a simple example is difficult, a series of Decorators do occur naturally in the java.io classes. Note the following in the Java documentation:

The class FilterInputStream itself simply overrides all methods of InputStream with versions that pass all requests to the underlying input stream. Subclasses of FilterInputStream may further override some of these methods as well as provide additional methods and fields.

The FilterInputStream class is thus a Decorator that can be wrapped around any input stream class. It is essentially an abstract class that doesn’t do any processing, but provides a layer where the relevant methods have been duplicated. It normally forwards these method calls to the enclosed parent stream class.

The interesting classes derived from FilterInputStream include:-

BufferedInputStream: Adds buffering to stream so that every call does not cause I/O to occur.

CheckedInputStream: Maintains a checksum of bytes as they are read

DataInputStream: Reads primitive types (Long, Boolean, Float, etc.) from the input stream.

DigestInputStream: Computes a MessageDigest of any input stream.

InflaterInputStream: Implements methods for uncompressing data.

PushbackInputStream: Provides a buffer where data can be “unread,” if during parsing you discover you need to back up.

These decorators can be nested, so that a pushback, buffered input stream is quite possible.

Decorators, Adapters and Composites
There is an essential similarity among these classes that you may have recognized.

Adapters also seem to “decorate” an existing class. However, their function is to change the interface of one or more classes to one that is more convenient for a particular program.

Decorators add methods to particular instances of classes, rather than to all of them. You could also imagine that a composite consisting of a single item is essentially a decorator.
Once again, however, the intent is different

Consequences of the Decorator Pattern
The Decorator pattern provides a more flexible way to add responsibilities to a class than by using inheritance, since it can add these responsibilities to selected instances of the class. It also allows you to customize a class without creating subclasses high in the inheritance hierarchy. Design Patterns points out two disadvantages of the Decorator pattern One is that a Decorator and its enclosed component are not identical. Thus tests for object type will fail. The second is that Decorators can lead to a system with “lots of little objects” that all look alike to the programmer trying to maintain the code. This can be a maintenance headache.

Decorator and Façade evoke similar images in building architecture,but in design pattern terminology, the Façade is a way of hiding a complex system inside a simpler interface, while Decorator adds function by wrapping a class.

Facade Pattern
The Façade pattern allows you to simplify complexity by providing a simplified interface to subsystems. This simplification may in some cases reduce the flexibility of the underlying classes, but usually provides all the function needed for all but the most sophisticated users. These users can still, of course, access the underlying classes and methods.

FlyWeight Pattern
There are cases in programming where it seems that you need to generate a very large number of small class instances to represent data. Sometimes you can greatly reduce the number of different classes that you need to instantiate if you can recognize that the instances are fundamentally the same except for a few parameters. If you can move those variables outside the class instance and pass them in as part of a method call, the number of separate instances can be greatly reduced.

The Flyweight design pattern provides an approach for handling such classes. It refers to the instance’s intrinsic data that makes the instance unique, and the extrinsic data which is passed in as arguments. The Flyweight is appropriate for small, fine-grained classes like individual characters or icons on the screen. For example, if you are drawing a series of icons on the screen in a folder window, where each represents a person or data file, it does not make sense to have an individual class instance for each of them that remembers the person’s name and the icon’s screen position. Typically these icons are one of a few similar images and the position where they are drawn is calculated dynamically based on the window’s size in any case.

In another example in Design Patterns, each character in a font is represented as a single instance of a character class, but the positions where the characters are drawn on the screen are kept as external data so that there needs to be only one instance of each character, rather than one for each appearance of that character.

Sharable Objects
The Smalltalk Companion points out that sharable objects are much like Flyweights, although the purpose is somewhat different. When you have a very large object containing a lot of complex data, such as tables or bitmaps, you would want to minimize the number of instances of that object. Instead, in such cases, you’d return one instance to every part of the program that asked for it and avoid creating other instances.

A problem with such sharable objects occurs when one part of a program wants to change some data in a shared object. You then must decide whether to change the object for all users, prevent any change, or create a new instance with the changed data. If you change the object for every instance, you may have to notify them that the object has changed.

Sharable objects are also useful when you are referring to large data systems outside of Java, such as databases.

Proxy Pattern
The Proxy pattern is used when you need to represent a complex object by a simpler one. If creating an object is expensive in time or computer resources, Proxy allows you to postpone this creation until you need the actual object. A Proxy usually has the same methods as the object it
represents, and once the object is loaded, it passes on the method calls from the Proxy to the actual object.

There are several cases where a Proxy can be useful:
1. If an object, such as a large image, takes a long time to load.
2. If the object is on a remote machine and loading it over the network may be slow, especially during peak network load periods.
3. If the object has limited access rights, the proxy can validate the access permissions for that user.

Proxies can also be used to distinguish between requesting an instance of an object and the actual need to access it. For example, program initialization may set up a number of objects which may not all be used right away. In that case, the proxy can load the real object only when it is needed.

Let’s consider the case of a large image that a program needs to load and display. When the program starts, there must be some indication that an image is to be displayed so that the screen lays out correctly, but the actual image display can be postponed until the image is completely loaded. This is particularly important in programs such as word processors and web browsers that lay out text around the images even before the images are available.

An image proxy can note the image and begin loading it in the background, while drawing a simple rectangle or other symbol to represent the image’s extent on the screen before it appears. The proxy can even delay loading the image at all until it receives a paint request, and only then begin the process.

Comparison with Related Patterns
Both the Adapter and the Proxy constitute a thin layer around an object. However, the Adapter provides a different interface for an object, while the Proxy provides the same interface for the object, but interposes itself where it can save processing effort.

A Decorator also has the same interface as the object it surrounds, but its purpose is to add additional (usually visual) function to the original object. A proxy, by contrast, controls access to the contained class.

Patterns 1 : Creational patterns

2004-12-26T23:04:00.000-08:00

Some of this material is from the java patterns book by James cooper.*

Factory Pattern
Factory patterns helps localizing the generation of certain obects to one place in code. That way we have control over how and what object is created.

Factory Method
It provides a simple decision making class that returns one of several possible subclasses of an abstract base class depending on the data that are provided.

When to Use a Factory Pattern
You should consider using a Factory pattern when
· A class can’t anticipate which kind of class of objects it must create.
· A class uses its subclasses to specify which objects it creates.
· You want to localize the knowledge of which class gets created.

There are several similar variations on the factory pattern to recognize.
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only subclassed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share the same method names but may do something quite different.

Abstract Factory Method
It provides an interface to create and return one of several families of related objects.

The Abstract Factory pattern is one level of abstraction higher than the factory pattern. You can use this pattern when you want to return one of several related classes of objects, each of which can return several different objects on request. In other words, the Abstract Factory is a factory object that returns one of several factories.

Consequences of Abstract Factory
One of the main purposes of the Abstract Factory is that it isolates the concrete classes that are generated. The actual class names of these classes are hidden in the factory and need not be known at the client level at all. Because of the isolation of classes, you can change or interchange these product class families freely. Further, since you generate only one kind of concrete class, this system keeps you for inadvertently using classes from different families of products. However, it is some effort to add new class families, since you need to define new, unambiguous conditions that cause such a new family of classes to be returned.

Builder Pattern
It separates the construction of a complex object from its representation, so that several different representations can be created depending on the needs of the program.

Prototype Pattern
It starts with an initialized and instantiated class and copies or clones it to make new instances rather than creating new instances.
The Protoype pattern is used when creating an instance of a class is very time-consuming or complex in some way. Then, rather than creating more instances, you make copies of the original instance, modifying them as appropriate.

Noramlly in java you use clone method to shallwo copy an object.

MyObject mNew = (MyObject)mOld.clone();

But to do a deepcopy you do this. Remember that the Object tobeDeepCloned has to have all of its child objects as serializable.

public Object deepClone(Object tobeDeepCloned)
{
try{
ByteArrayOutputStream b = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(b);
out.writeObject(
tobeDeepCloned);
ByteArrayInputStream bIn = new ByteArrayInputStream(b.toByteArray());
ObjectInputStream oi = new ObjectInputStream(bIn);
return (oi.readObject());
}
catch (Exception e)
{
System.out.println("exception:"+e.getMessage());
return null;
}
}

Singleton Pattern
It is a class of which there can be no more than one instance. It provides a single global point of access to that instance.

Aspect oriented programming with CGLIB

2004-12-21T05:28:00.000-08:00

1 Introduction and background
2 Purpose of this article
3 Prerequisites
4 Topic 1: Measure the time taken by method calls
4.1 SimpleClass class
4.2 TimeInterceptor class 4
4.3 MethodTimeGenerator class 4
4.4 Main class 5
4.5 Topic Conclusion 6
5 Topic 2: Dynamic connection allocation 6
5.1 DaoTagInterface 6
5.2 DAO class 6
5.3 DaoInterceptor class 7
5.4 DaoGenerator class 9
5.5 DaoFactory class 9
5.6 Main class 9
5.7 Topic Conclusion 10
6 Conclusion. 11
7 Drawbacks 11

1 Introduction and background

Aspect oriented programming has been talked about greatly recently. There are developers who think that it is a great idea and also an equal number who think that it is not as it breaks the principles of Object oriented programming.

2 Purpose of this article

During the last few years I faced some issues that were present across the entire code base.
I thought must have a clean/fast way of solving but I did not have an answer until I read what aspect oriented programming was.
I will present two such problems and their solutions.
I investigated CGLIB after reading this article http://www.onjava.com/lpt/a/5250 by Eugene Kuleshov at Onjava.com.
This paper is a result of that investigation.

3 Prerequisites

Cglib 2 jar file in the class path. It can be downloaded from here: http://sourceforge.net/project/showfiles.php?group_id=56933

4 Topic 1: Measure the time taken by method calls

One of the issues was measuring the exact time taken by each of my method calls, so as to better solve performance issues.
I wanted to do this in a way, so as to be able to switch it on/off as and when required.

Here are the classes

4.1 SimpleClass class

package com.test.methodtimetest;
/**
* @author suchakj
*/
public class SimpleClass {
public void simpleMethod() {
System.out.println("Hello In Simple Method");
}
}
This is just a class with a single method that prints hello.

4.2 TimeInterceptor class

package com.test.methodtimetest;
import java.lang.reflect.Method;
import java.sql.Timestamp;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
* @author suchakj
*/
public class TimeInterceptor implements MethodInterceptor {
/* This is the method that intecepts a method, it automatically adds the start and end time
* for a method.
* @see net.sf.cglib.proxy.MethodInterceptor#intercept
* (java.lang.Object, java.lang.reflect.Method, java.lang.Object[],
* net.sf.cglib.proxy.MethodProxy)
*/
public Object intercept(
Object obj,
Method method,
Object[] args,
MethodProxy proxy)
throws Throwable {
System.out.println("Before method : " + method + " Time : " + new Timestamp(System.currentTimeMillis()));
Object o = proxy.invokeSuper(obj,args);
System.out.println("After method : " + method + " Time : " + new Timestamp(System.currentTimeMillis()));
return o;
}
}
}

This is a class that implements the Cglib MethodInterceptor interface. The MethodInterceptor interface implements a single method called intercept(). The cglib framework calls this method when a particular Object method is intercepted.
As we can see that the intercept method , adds a Timestamp, before and after the method call. The method is called using proxy.invokeSuper(obj,args); . This takes care of the method timing in one central place.

4.3 MethodTimeGenerator class

package com.test.methodtimetest;
import net.sf.cglib.proxy.Enhancer;
/**
* @author suchakj
*/
public class MethodTimeGenerator {
public static Object getTimeEnhancedObject(Class clazz){
Enhancer e = new Enhancer();
e.setSuperclass(clazz);
e.setCallback(new TimeInterceptor());
return e.create();
}
}

This is the main generator. This class uses the cglib Enhancer class to join the method interceptor class with the any class(in our case it is SimpleClass).

4.4 Main class

package com.test;
import com.test.daoconntest.DAO;
import com.test.daoconntest.DaoFactory;
import com.test.daoconntest.DaoInterceptor;
import com.test.methodtimetest.MethodTimeGenerator;
import com.test.methodtimetest.SimpleClass;
/**
* @author suchakj
*/

public class Main {

public static void testMethodTimeTest(){
//this could come from a factory.
SimpleClass s = (SimpleClass)MethodTimeGenerator.getTimeEnhancedObject(SimpleClass.class);
s.simpleMethod();
}

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

}

This the test class. This class is testing our implementation.

Here is the output.
---------------------------------------------------------------------------------------------------------------
Before method : public void com.test.methodtimetest.SimpleClass.simpleMethod() Time : 2004-12-17 14:20:36.046
Hello In Simple Method
After method : public void com.test.methodtimetest.SimpleClass.simpleMethod() Time : 2004-12-17 14:20:36.14
---------------------------------------------------------------------------------------------------------------

4.5 Topic Conclusion

The above code shows how simple it is to add time delay interceptor to a class. It is not at all intrusive on the class that is being intercepted for recording the time delay.

5 Topic 2: Dynamic connection allocation

The importance of connection pools cannot be underestimated.
The main issue I faced in an environment was whether a method returned the connection back to the pool after it had finished using the same.
I wanted to do this in a way, so as to do this in a central place also.
This example will also modify the arguments passed to the method.

Here are the classes

5.1 DaoTagInterface

package com.test.daoconntest;
/**
* @author suchakj
*
* This is just a tag inteface
*/

public interface DaoTagInterface {
}

This is just a tagging interface for DAO classes.

5.2 DAO class

package com.test.daoconntest;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
* @author suchakj
*/

public class DAO implements DaoTagInterface{

public void daoMethod(String someParam,Object connection){
System.out.println("In Dao Method");
if(connection!=null){
System.out.println("Got a Valid connection that i can use");
}else{
System.out.println("No connection");
}

/* try {
Statement s = ((Connection)connection).createStatement();
ResultSet r = s.executeQuery("Select * from SomeTable");
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}*/
}
}

This is the Data access class. It does the call to the database.

5.3 DaoInterceptor class

package com.test.daoconntest;
import java.lang.reflect.Method;
import java.sql.Connection;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
* @author suchakj
*/

public class DaoInterceptor implements MethodInterceptor {

/* This is the method that intecepts dao methods, it automatically adds connection objects,
* to the method from a pool and also returns them back to the pool
* @see net.sf.cglib.proxy.MethodInterceptor#intercept(java.lang.Object, java.lang.reflect.Method, java.lang.Object[], net.sf.cglib.proxy.MethodProxy)
*/

public Object intercept(Object obj, Method method, Object[] args,

MethodProxy proxy) throws Throwable {

// Connection connection = getConnection();
Object connection = getConnection();
args[args.length -1] = connection;
proxy.invokeSuper(obj,args);
returnConnection(connection);
return null;
}

/**
* @return Connection
*/

private Object getConnection() {
// get the connection from some Connection pool
System.out.println("Getting connection from pool ...");
return new Object();// this is just for testing this should be a java.sql.connection object
}

/**
* @param Connection
*/

private void returnConnection(Object c) {
System.out.println("returning connection to pool ...");
// Return the connection back to the pool..
}
}

This is a class that implements the Cglib MethodInterceptor interface. The MethodInterceptor interface implements a single method called intercept(). The cglib framework calls this method when a particular Object method is intercepted.
The getConnection() and returnConnection() methods can get and return connections from a pool.
As we can see this class changes the arguments passed to the method as
“Object connection = getConnection();”
“args[args.length -1] = connection;”
“proxy.invokeSuper(obj,args);”
Thus a “connection object” should be passed to the method daoMethod(String someParam,Object connection). We shall see this in the test.

5.4 DaoGenerator class

package com.test.daoconntest;
import net.sf.cglib.proxy.Enhancer;
/**
* @author suchakj
*/

public class DaoGenerator {
public static Object getTimeEnhancedObject(Class clazz){
Enhancer e = new Enhancer();
e.setSuperclass(clazz);
e.setCallback(new DaoInterceptor());
return e.create();
}
}

This is the main generator for the DAO interceptor. This class uses the cglib Enhancer class to join the interceptor class DaoInterceptor with the any dao class(in our case it is DAO class).

5.5 DaoFactory class

package com.test.daoconntest;

/**
* @author suchakj
*/

public class DaoFactory {
public static DaoTagInterface getDao(Class clazz) throws InstantiationException, IllegalAccessException {
return (DaoTagInterface) DaoGenerator.getTimeEnhancedObject(clazz);
}
}

This is a factory for generating DAO classes. It uses the DaoGenerator for generating Dao classes.

5.6 Main class

This the same test class as in the previous topic. This class is testing our implementation.

package com.test;
import com.test.daoconntest.DAO;
import com.test.daoconntest.DaoFactory;
import com.test.daoconntest.DaoInterceptor;
import com.test.methodtimetest.MethodTimeGenerator;
import com.test.methodtimetest.SimpleClass;

/**
* @author suchakj
*/

public class Main {

public static void testMethodTimeTest(){
//this could come from a factory.
SimpleClass s = (SimpleClass)MethodTimeGenerator.getTimeEnhancedObject(SimpleClass.class);
s.simpleMethod();
}

public static void testDaoConn(){
DAO d;
try {
d = (DAO)DaoFactory.getDao(DAO.class);
d.daoMethod("test",null);
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public static void main(String[] args) {
//testMethodTimeTest();
testDaoConn();
}

}

Here is the output.
---------------------------------------------------------------------------------------------------------------
Getting connection from pool ...
In Dao Method
Got a Valid connection that I can use
Returning connection to pool ...
---------------------------------------------------------------------------------------------------------------

5.7 Topic Conclusion

The above code shows how simple it is for a dao to give and return a connection from/to the connection pool, without writing such code in all the dao methods.Also the code for this is in a central place and can be modified as needed.

6 Conclusion.

Aspects of a code base , a framework can be cleanly coded using Aspect oriented programming. It can be coded in a non intrusive way using Cglib. Thus the result is Aspect code of a similar type in one central place and still applied to the objects that need the Aspect. The two aspects we talked about were getting connection and returning them to a connection pool, and timing methods for querying performance.

7 Drawbacks

Some of the drawbacks of what is explained above are.

1) There could be two or more dao method calls that want to use the same connection object for the reason of transactions. For this the solution could be that we check if the user has sent a connection and if he has then do not apply the interception

2) For both the topics a new Enhancer is created at each method call, it would be better to have a cache of a Hashmap or a WeakHashMap so that the impact of new Enhancer creation at every method call is reduced.

3) The daointerceptor assumes that the method will have a Connection param, which will be the last param, and also which will be ignored even if sent by the user.

Implementing a Frequency date time generator in java

2004-12-21T03:40:00.000-08:00

The java calendar class does a lot of good things. As far as adding days to a date is concerened it has three methods.

set(f, value) : sets the field f which could be weekdday, month, year,etc. to the value specified.

add(f, delta) : adds detla to the field f which could be weekdday, month, year,etc.

roll(f, delta) : adds detla to the field f which could be weekdday, month, year,etc whichout changing the larger fields. For exmaple using roll to add 10 to the month value of Dec 31 2004 will roll to OCt 31 2004 as year being the larger will be the same.

For more details on these methods look at http://java.sun.com/j2se/1.4.2/docs/api/java/util/Calendar.html.

The objective of this post to to reconcile the calendar class with the computation of custom frequencies like daily, weekly,monthing, biweekly etc..

I have written a class that uses the calendar to compute custom frequencies in a manner that helps the user get the next date, if he just supplies his current date and the frequency.

Beware ! Reading this class is not easy at all, however it can be very usefull.



import java.sql.Timestamp;
import java.util.Calendar;

/**
 *  This class generates a date/time based on a frequency. 
 *  It accepts a range of frequencies, like Hourly, Monthy, Weekly,
 *  Yearly,BiWeekly, SemiMonthy,Quarterly and LastDayOfMonth and 
 *  based on the frequency generates the next run date.
 * 
 * @author suchakj
 */
public class RunFreqGenerator {

 /**
  *  This interface holds the string values for all frequencies. 
  *  The frequnecies are Hourly, Monthy, Weekly, Yearly,BiWeekly, SemiMonthy,
  *  Quarterly and LastDayOfMonth.
  *     
  */ 
 public interface RunFreqInterface {
  public static final String RUN_FREQ_HOURLY = "H";

  public static final String RUN_FREQ_DAILY = "D";

  public static final String RUN_FREQ_MONTHLY = "M";

  public static final String RUN_FREQ_WEEKLY = "W";

  public static final String RUN_FREQ_YEARLY = "Y";

  public static final String RUN_FREQ_BIWEEKLY = "B";

  public static final String RUN_FREQ_SEMIMONTHLY = "S";

  public static final String RUN_FREQ_QUARTERLY = "Q";

  public static final String RUN_FREQ_HALFYEARLY = "L";

  public static final String LAST_DAY_OF_MONTH = "LD";
 }

 /**
  *  Every frequency needs a certain set of parameters to determine the next 
  *  run date.
  *  
  *  This class holds the frequency related parameters based on the frequency
  *  type.     
  *     
  */
 public class DateFreqHolder {
  
  // The date for the next run.
  private Timestamp nextDate;
  
  // A frequency based on the RunFreqInterface attributes.
  private String freq;

  /* 
   * The day of the run i.e Monday, Wednesday etc. It is eighter the full 
   * name or the first three letters of the day name.
   */
  private String run_day;

  /* 
   * The numerical day of the month on which the the task is run for the
   * first time.
   */
  private String first_run_date;

  /* 
   * The month of the run i.e January,February etc. It is eighter the full 
   * name or the first three letters of the month name.
   */
  private String run_month;

  /* 
   * The numerical day of the month on which the task is run for a 
   * second time. 
   */
  private String second_run_date;

  public String getFirst_run_date() {
   return first_run_date;
  }

  public void setFirst_run_date(String first_run_date) {
   this.first_run_date = first_run_date;
  }

  public String getRun_month() {
   return run_month;
  }

  public void setRun_month(String run_month) {
   this.run_month = run_month;
  }

  public String getRun_day() {
   return run_day;
  }

  public void setRun_day(String run_day) {
   this.run_day = run_day;
  }

  public String getSecond_run_date() {
   return second_run_date;
  }

  public void setSecond_run_date(String second_run_date) {
   this.second_run_date = second_run_date;
  }

  public String getFreq() {
   return freq;
  }

  public Timestamp getNextDate() {
   return nextDate;
  }

  public void setFreq(String freq) {
   this.freq = freq;
  }

  public void setNextDate(Timestamp nextDate) {
   this.nextDate = nextDate;
  }
 }

 /* 
  * Gets the next date based on the data in the DateFreqHolder
  *  
  */
 public static Timestamp getNextDate(DateFreqHolder holder) throws Exception {

  Timestamp previousRunDate = holder.getNextDate();
  if (previousRunDate == null) {
   throwNullVarException("nextRundate");
  }
  String runFreq = holder.getFreq();
  if (runFreq == null) {
   throwNullVarException("run freq");
  }
  Calendar cal = Calendar.getInstance();
  cal.setTime(previousRunDate);

  if (RunFreqInterface.RUN_FREQ_HOURLY.equals(runFreq)) {
   return addHours(cal, 1);
  }

  if (RunFreqInterface.RUN_FREQ_DAILY.equals(runFreq)) {
   return addHours(cal, 24);
  }

  if (RunFreqInterface.RUN_FREQ_WEEKLY.equals(runFreq)) {
   String runDay = holder.getRun_day();
   if (runDay == null) {
    throwNullVarForFreqException("run day", RunFreqInterface.RUN_FREQ_WEEKLY);
   }

   return addWeeks(cal, cal.get(Calendar.DAY_OF_WEEK),
     getWeekday(runDay), 1);
  }

  if (RunFreqInterface.RUN_FREQ_MONTHLY.equals(runFreq)) {
   String runDate = holder.getFirst_run_date();
   if (runDate == null) {
    throwNullVarForFreqException("run date", RunFreqInterface.RUN_FREQ_MONTHLY);
   }
   return addMonth(cal, runDate);
  }

  if (RunFreqInterface.RUN_FREQ_QUARTERLY.equals(runFreq)) {
   String runDate = holder.getFirst_run_date();
   if (runDate == null) {
    throwNullVarForFreqException("run date", RunFreqInterface.RUN_FREQ_QUARTERLY);
   }
   return addQuarter(cal, cal.get(Calendar.MONTH), runDate);
  }

  if (RunFreqInterface.RUN_FREQ_YEARLY.equals(runFreq)) {
   String runDate = holder.getFirst_run_date();
   String runMonth = holder.getRun_month();
   if (runDate == null) {
    throwNullVarForFreqException("run date", RunFreqInterface.RUN_FREQ_YEARLY);
   }
   if (runMonth == null) {
    throwNullVarForFreqException("run month", RunFreqInterface.RUN_FREQ_YEARLY);
   }
   return addMonths(cal, cal.get(Calendar.MONTH), getMonth(runMonth),
     runDate, 12);
  }

  if (RunFreqInterface.RUN_FREQ_BIWEEKLY.equals(runFreq)) {
   String runDay = holder.getRun_day();
   if (runDay == null) {
    throwNullVarForFreqException("run day", RunFreqInterface.RUN_FREQ_BIWEEKLY);
   }
   return addWeeks(cal, cal.get(Calendar.DAY_OF_WEEK),
     getWeekday(runDay), 2);
  }

  if (RunFreqInterface.RUN_FREQ_SEMIMONTHLY.equals(runFreq)) {
   String runDateString = holder.getFirst_run_date();
   String secondRunDateString = holder.getSecond_run_date();
   if (runDateString == null) {
    throwNullVarForFreqException("run date",
      RunFreqInterface.RUN_FREQ_SEMIMONTHLY);
   }
   if (secondRunDateString == null) {
    throwNullVarForFreqException("second run date",
      RunFreqInterface.RUN_FREQ_SEMIMONTHLY);
   }
   if (RunFreqInterface.LAST_DAY_OF_MONTH.equals(runDateString)) {
    throw new Exception("DateFreqHolder cannot have "
      + "first rundate as last day of the month ::"
      + RunFreqInterface.RUN_FREQ_SEMIMONTHLY);
   }
   int runDate = (new Integer(runDateString)).intValue();
   int secondRunDate = 0;

   if (RunFreqInterface.LAST_DAY_OF_MONTH.equals(secondRunDateString)) {
    secondRunDate = 31;
   } else {
    secondRunDate = (new Integer(secondRunDateString)).intValue();
   }
   if (secondRunDate > runDate) {
    throw new Exception("DateFreqHolder cannot have "
      + "first rundate less than the second run date "
      + "for task type ::: "
      + RunFreqInterface.RUN_FREQ_SEMIMONTHLY);
   }

   int previousRunDateInt = cal.get(Calendar.DAY_OF_MONTH);

   if (previousRunDateInt < runDate) {
    cal.set(Calendar.DAY_OF_MONTH, runDate);
    return new Timestamp(cal.getTime().getTime());
   } else if ((previousRunDateInt >= runDate)
     & (previousRunDateInt > secondRunDate)) {
    cal.set(Calendar.DAY_OF_MONTH, secondRunDate);
    return new Timestamp(cal.getTime().getTime());
   } else if (previousRunDateInt >= secondRunDate) {
    return addMonth(cal, runDateString);
   }
  }

  throw new Exception("DateFreqHolder does not have a proper fequency ::");
 }

 /*
  * This method returns the int value of the month based on the string 
  * supplied. Please note valid month strings are the full month name or the 
  * first three letters of the month name. For example January, February or 
  * Jan, Feb. 
  * 
  * This method is not case sensitive.
  * 
  */
 private static int getMonth(String month) throws Exception {
  if ("JAN".equalsIgnoreCase(month) || "JANUARY".equalsIgnoreCase(month)) {
   return Calendar.JANUARY;
  }
  if ("FEB".equalsIgnoreCase(month) || "FEBRUARY".equalsIgnoreCase(month)) {
   return Calendar.FEBRUARY;
  }
  if ("MAR".equalsIgnoreCase(month) || "MARCH".equalsIgnoreCase(month)) {
   return Calendar.MARCH;
  }
  if ("APR".equalsIgnoreCase(month) || "APRIL".equalsIgnoreCase(month)) {
   return Calendar.APRIL;
  }
  if ("MAY".equalsIgnoreCase(month)) {
   return Calendar.MAY;
  }
  if ("JUN".equalsIgnoreCase(month) || "JUNE".equalsIgnoreCase(month)) {
   return Calendar.JUNE;
  }
  if ("JUL".equalsIgnoreCase(month) || "JULY".equalsIgnoreCase(month)) {
   return Calendar.JULY;
  }
  if ("AUG".equalsIgnoreCase(month) || "AUGUST".equalsIgnoreCase(month)) {
   return Calendar.AUGUST;
  }
  if ("SEP".equalsIgnoreCase(month)
    || "SEPTEMBER".equalsIgnoreCase(month)) {
   return Calendar.SEPTEMBER;
  }
  if ("OCT".equalsIgnoreCase(month) || "OCTOBER".equalsIgnoreCase(month)) {
   return Calendar.OCTOBER;
  }
  if ("NOV".equalsIgnoreCase(month) || "NOVEMBER".equalsIgnoreCase(month)) {
   return Calendar.NOVEMBER;
  }
  if ("DEC".equalsIgnoreCase(month) || "DECEMBER".equalsIgnoreCase(month)) {
   return Calendar.DECEMBER;
  }
  throw new Exception("Month cannot be :: " + month);
 }

 /*
  * This method returns the int value of the week day based on the string 
  * supplied. Please note valid week day strings are the full week day name 
  * or the first three letters of the week day name. For example Mondya, 
  * Tuesday or Mon, Tue. 
  * 
  * This method is not case sensitive.
  * 
  */
 private static int getWeekday(String weekday) throws Exception {
  if ("SUN".equalsIgnoreCase(weekday)
    || "SUNDAY".equalsIgnoreCase(weekday)) {
   return Calendar.SUNDAY;
  }
  if ("MON".equalsIgnoreCase(weekday)
    || "MONDAY".equalsIgnoreCase(weekday)) {
   return Calendar.MONDAY;
  }
  if ("TUE".equalsIgnoreCase(weekday)
    || "TUESDAY".equalsIgnoreCase(weekday)) {
   return Calendar.TUESDAY;
  }
  if ("WED".equalsIgnoreCase(weekday)
    || "WEDNESDAY".equalsIgnoreCase(weekday)) {
   return Calendar.WEDNESDAY;
  }
  if ("THU".equalsIgnoreCase(weekday)
    || "THURSDAY".equalsIgnoreCase(weekday)) {
   return Calendar.THURSDAY;
  }
  if ("FRI".equalsIgnoreCase(weekday)
    || "FRIDAY".equalsIgnoreCase(weekday)) {
   return Calendar.FRIDAY;
  }
  if ("SAT".equalsIgnoreCase(weekday)
    || "SATURDAY".equalsIgnoreCase(weekday)) {
   return Calendar.SATURDAY;
  }
  throw new Exception("Day of the week cannot be :: " + weekday);
 }

 /* 
  * Throws exception stating that a particular DateFreqHolder variable cannot
  * be null for a particular frequency
  * 
  */ 
 private static void throwNullVarForFreqException(String var, String freq)
   throws Exception {
  throw new Exception("DateFreqHolder cannot have a null :: " + var
    + " when freq is :: " + freq);

 }

 /* 
  * Throws exception stating that a particular variable cannot be null.
  * 
  */ 
 private static void throwNullVarException(String var) throws Exception {
  throw new Exception("DateFreqHolder cannot have a null :: " + var);
 }

 /* 
  * Add a month to the supplied calender. After that set the date to the 
  * runDate(day of the month) supplied. 
  * 
  */ 
 private static Timestamp addMonth(Calendar cal, String runDate)
   throws Exception {
  return addMonths(cal, 1, runDate);
 }

 /* 
  * Add months to the supplied calender as per noOfMonths. After that set 
  * the date to the runDate(day of the month) supplied. 
  * 
  */  
 private static Timestamp addMonths(Calendar cal, int noOfMonths,
   String runDate) {
  cal.add(Calendar.MONTH, noOfMonths);
  if (RunFreqInterface.LAST_DAY_OF_MONTH.equals(runDate)
    || ((new Integer(runDate)).intValue() > cal
      .getActualMaximum(Calendar.DAY_OF_MONTH))) {
   cal.set(Calendar.DAY_OF_MONTH, cal
     .getActualMaximum(Calendar.DAY_OF_MONTH));
  } else {
   cal.set(Calendar.DAY_OF_MONTH, (new Integer(runDate)).intValue());
  }
  return new Timestamp(cal.getTime().getTime());
 }
 
 /* 
  * This method is used for yearly tasks.
  * 
  * It add months to the supplied calender as per noOfMonths which will be 12 
  * for a yearly task. After that it sets the month to the runMonth(month of 
  * the year) supplied and the runDate(day of the month) to the supplied 
  * runDate.
  *  
  */ 
 private static Timestamp addMonths(Calendar cal, int previousRunMonth,
   int runMonth, String runDate, int noOfMonths) throws Exception {
  if (previousRunMonth == runMonth) {
   cal.add(Calendar.MONTH, noOfMonths);
   return new Timestamp(cal.getTime().getTime());
  } else {
   if (runMonth > previousRunMonth) {
    return addMonths(cal, runMonth - previousRunMonth, runDate);
   } else {
    return addMonths(cal, noOfMonths
      - (previousRunMonth - runMonth), runDate);
   }
  }
 }
 
 /* 
  * This method is used for quarterly tasks.
  * 
  * It add 3 months to the supplied calender. After that it sets the 
  * the runDate(day of the month) to the supplied runDate.
  *  
  */ 
 private static Timestamp addQuarter(Calendar cal, int previousRunMonth,
   String runDate) throws Exception {
  if (isQuarterMonth(previousRunMonth)) {
   return addMonths(cal, 3, runDate);
  } else {
   return addMonths(cal,
     getNoOFMonthsToNextQuarterMonth(previousRunMonth), runDate);
  }
 }

 /* 
  * This method is used for quarterly tasks.
  * 
  * It returns an int value that is used to add up the months 
  * for a quarter. 
  * 
  * The reason this method is needed is that all quarters are
  * fixed i.e. March, June, September and December
  *  
  * For example a date is in october, so the number of months for it 
  * to reach the next quarter is 2 months. How ever if a date is in november 
  * the number of months for it to reach the next quarter is 1 month.  
  *   
  */ 
 private static int getNoOFMonthsToNextQuarterMonth(int previousRunMonth)
   throws Exception {
  if (previousRunMonth > 12) {
   throw new Exception("Month cannot be :: " + previousRunMonth);
  }
  if (Calendar.MARCH >= previousRunMonth) {
   return Calendar.MARCH - previousRunMonth;
  } else if (Calendar.JUNE >= previousRunMonth) {
   return Calendar.JUNE - previousRunMonth;
  } else if (Calendar.SEPTEMBER >= previousRunMonth) {
   return Calendar.SEPTEMBER - previousRunMonth;
  } else if (Calendar.DECEMBER >= previousRunMonth) {
   return Calendar.DECEMBER - previousRunMonth;
  }
  return 0;
 }

 /*
  * This method checks wether the previousRunMonth supplied is a quarter 
  * month.
  */
 private static boolean isQuarterMonth(int previousRunMonth) {
  if (Calendar.MARCH == previousRunMonth
    || Calendar.JUNE == previousRunMonth
    || Calendar.SEPTEMBER == previousRunMonth
    || Calendar.DECEMBER == previousRunMonth) {
   return true;
  }
  return false;
 }

 /*
  * This method adds weeks to a given calendar. Also it sets the run 
  * day(day of the month) as per the supplied run day.
  * 
  */
 private static Timestamp addWeeks(Calendar cal,
   int previousRunDateDayOfTheWeek, int runDay, int noOfWeeks) {
  if (previousRunDateDayOfTheWeek == runDay) {
   cal.add(Calendar.WEEK_OF_YEAR, noOfWeeks);
  } else {
   if (runDay > previousRunDateDayOfTheWeek) {
    cal.add(Calendar.DAY_OF_WEEK, runDay
      - previousRunDateDayOfTheWeek);
   } else {
    cal.add(Calendar.DAY_OF_WEEK,
      7 - (previousRunDateDayOfTheWeek - runDay));
   }
  }
  return new Timestamp(cal.getTime().getTime());
 }

 /*
  * This method adds hours to a given calendar based on the integer value 
  * supplied.
  * 
  */
 private static Timestamp addHours(Calendar cal, int i) {
  cal.add(Calendar.HOUR_OF_DAY, 1);
  return new Timestamp(cal.getTime().getTime());
 }

 /*
  * This is the main test controller method
  */ 
 public static void main(String[] s) {
  try {
   RunFreqGenerator.DateFreqHolder holder = (new RunFreqGenerator()).new DateFreqHolder();
   holder.setNextDate(new Timestamp(System.currentTimeMillis()));
   testHourAdd(holder);
   testDayAdd(holder);
   testWeekAdd(holder);
   holder.setFirst_run_date("28");
   holder.setSecond_run_date("29");
   testMonthAdd(holder);
   testSemiMonthlyAdd(holder);
   testQuarterAdd(holder);
   testYearAdd(holder);

   // test for the last day of the month.
   Calendar c = Calendar.getInstance();
   c.set(Calendar.MONTH, Calendar.JANUARY);
   c.set(Calendar.DAY_OF_MONTH, 31);
   holder.setFirst_run_date("1");
   holder.setNextDate(new Timestamp(c.getTime().getTime()));

   testMonthAdd(holder);
   testSemiMonthlyAdd(holder);
   testQuarterAdd(holder);
   testYearAdd(holder);

   Calendar c1 = Calendar.getInstance();
   c1.set(Calendar.MONTH, Calendar.FEBRUARY);
   c1.set(Calendar.DAY_OF_MONTH, 29);
   holder.setFirst_run_date("31");
   holder.setNextDate(new Timestamp(c1.getTime().getTime()));

   testMonthAdd(holder);
   testSemiMonthlyAdd(holder);
   testQuarterAdd(holder);
   testYearAdd(holder);

   Calendar c3 = Calendar.getInstance();
   c3.set(Calendar.MONTH, Calendar.APRIL);
   c3.set(Calendar.DAY_OF_MONTH, 30);
   holder.setFirst_run_date("LD");
   holder.setNextDate(new Timestamp(c3.getTime().getTime()));

   testMonthAdd(holder);
   testSemiMonthlyAdd(holder);
   testQuarterAdd(holder);
   testYearAdd(holder);

   Calendar c4 = Calendar.getInstance();
   c4.set(Calendar.MONTH, Calendar.FEBRUARY);
   c4.set(Calendar.DAY_OF_MONTH, 29);
   holder.setFirst_run_date("29");
   holder.setNextDate(new Timestamp(c4.getTime().getTime()));
   testMonthAdd(holder);
   testSemiMonthlyAdd(holder);
   testQuarterAdd(holder);
   testYearAdd(holder);
  } catch (Exception e) {
   e.printStackTrace();
  }

 }

 // the mothod names below are are self explanatory.
 private static void testYear(DateFreqHolder holder, String month)
   throws Exception {
  System.out.println("testing Year add ::::: month :: " + month
    + " runday :: " + holder.getFirst_run_date());
  holder.setFreq(RunFreqInterface.RUN_FREQ_YEARLY);
  holder.setRun_month(month);
  System.out.println("Previous Run date :: " + holder.getNextDate());
  System.out.println("Next Run date " + month + " :: "
    + getNextDate(holder));

 }

 private static void testHourAdd(DateFreqHolder holder) throws Exception {
  System.out.println("Testing hour add");
  holder.setFreq(RunFreqInterface.RUN_FREQ_HOURLY);
  System.out.println("Previous Run date :: " + holder.getNextDate());
  System.out.println("Next Run date :: " + getNextDate(holder));
 }

 private static void testDayAdd(DateFreqHolder holder) throws Exception {
  System.out.println("Testing Day add");
  holder.setFreq(RunFreqInterface.RUN_FREQ_DAILY);
  System.out.println("Previous Run date :: " + holder.getNextDate());
  System.out.println("Next Run date :: " + getNextDate(holder));
 }

 private static void testWeekAdd(DateFreqHolder holder) throws Exception {

  testWeekDay(holder, "SUN");
  testWeekDay(holder, "MON");
  testWeekDay(holder, "TUE");
  testWeekDay(holder, "WED");
  testWeekDay(holder, "THU");
  testWeekDay(holder, "FRI");
  testWeekDay(holder, "SAT");
 }

 private static void testWeekDay(DateFreqHolder holder, String weekDay)
   throws Exception {
  System.out.println("Testing Week add ::::: " + weekDay);
  holder.setFreq(RunFreqInterface.RUN_FREQ_WEEKLY);
  holder.setRun_day(weekDay);
  System.out.println("Previous Run date :: " + holder.getNextDate());
  System.out.println("Next Run date " + weekDay + " :: "
    + getNextDate(holder));
 }

 private static void testMonthAdd(DateFreqHolder holder) throws Exception {
  System.out.println("testing month add ::::: month :: " + " runday :: "
    + holder.getFirst_run_date());
  holder.setFreq(RunFreqInterface.RUN_FREQ_MONTHLY);
  // holder.setRun_month(month);
  System.out.println("Previous Run date :: " + holder.getNextDate());
  System.out.println("Next Run date " + " :: " + getNextDate(holder));

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

 private static void testQuarterAdd(DateFreqHolder holder) throws Exception {
  System.out.println("testing Quarter add ::::: " + " runday :: "
    + holder.getFirst_run_date());
  holder.setFreq(RunFreqInterface.RUN_FREQ_QUARTERLY);
  // holder.setRun_month(month);
  System.out.println("Previous Run date :: " + holder.getNextDate());
  System.out.println("Next Run date " + " :: " + getNextDate(holder));

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

 private static void testSemiMonthlyAdd(DateFreqHolder holder)
   throws Exception {
  System.out.println("testing Semi Monthly add ::::: "
    + " first runday :: " + holder.getFirst_run_date());
  System.out.println("testing Semi Monthly add ::::: "
    + " second runday :: " + holder.getSecond_run_date());
  holder.setFreq(RunFreqInterface.RUN_FREQ_SEMIMONTHLY);
  // holder.setRun_month(month);
  System.out.println("Previous Run date :: " + holder.getNextDate());
  System.out.println("Next Run date " + " :: " + getNextDate(holder));

 }

 private static void testYearAdd(DateFreqHolder holder) throws Exception {
  testYear(holder, "JAN");
  testYear(holder, "FEB");
  testYear(holder, "MAR");
  testYear(holder, "APR");
  testYear(holder, "MAY");
  testYear(holder, "JUN");
  testYear(holder, "JUL");
  testYear(holder, "AUG");
  testYear(holder, "SEP");
  testYear(holder, "OCT");
  testYear(holder, "NOV");
  testYear(holder, "DEC");
  System.out.println();
  System.out.println();
  System.out.println();
 }

}

PDF template creation using iText

2004-12-21T02:42:00.000-08:00

This will sound exiting to those who know that , one can use the Adobe Arcobat writer toll to create templates. These templates can use used to fill up data programatically using iText api.

How would you do so ?.

Lets assume that you already have the itext.jar in class path and let's say you have create a template using adobe acrobat.

Then you call that template in your code like this :-

File template = new File(templatePDFFile);
byte[] templateByteArray = getBytesFromFile(template); // somehow get the bytes out of the file.
Document document - new Document();
FileOutputStream fos = new FileOutputStream(outputFileName);
PdfWriter writer = PdfWriter.getInstance(document, fos);
document.open();
PdfContentByte cb = writer.getDirectContent();

PDFReader = new PdfReader(templateByteArray);
HashMap fieldBoxes = getFieldBoxes(reader);// get all the fields of the template and then use them via stamper.
// now we use the stamper to do the template majic
stamp = new PdfStamper(reader, outputStream);
cbStamper = stamp.getOverContent(1);
form = stamp.getAcroFields();

rect = (Rectangle) fieldBoxes.get("mytestimage");
addSpecialImage(
cbStamper,
testImage,
rect.left(),
rect.bottom(),
rect.right(),
rect.top()
);

Here is what the addspecial image method in our code does

private void addSpecialImage(
PdfContentByte cb,
Image img,
float x1,
float y1,
float x2,
float y2)
{
float h = y2 - y1;
float w = x2 - x1;

try{
img.scaleToFit(x2 - x1, y2 - y1);
img.setAbsolutePosition(x1, y1);
cb.addImage(img);
}
catch (Exception e)
{
log(e.getMessage());
timeLog(e.getMessage());
e.printStackTrace();

}
}

However now you can create the template we used above also programatically on the fly using iText.

Here is some random code that does this:-

// llx - lower left x
// lly - lower left y
PdfWriter writer = PdfWriter.getInstance(document, new FileOutputStream(somepdfname));
document.open();
BaseFont helv = BaseFont.createFont("Helvetica", "winansi", false);
PdfContentByte cb = writer.getDirectContent();
cb.moveTo(0, 0);
float fontSize = DEFAULT_FONT_SIZE;
Color textColor = new GrayColor(0f);
PdfFormField field = PdfFormField.createTextField(writer, false, false, 0);
field.setWidget(new Rectangle(llx, lly, llx + DEFAULT_UPPER_X_DIFFERENCE, lly + DEFAULT_UPPER_Y_DIFFERENCE), PdfAnnotation.HIGHLIGHT_INVERT);
field.setFlags(PdfAnnotation.FLAGS_PRINT);
field.setFieldName(DEFAULT_FIELDNAME_STARTSTRING + j + "_" + i);
field.setBorderStyle(new PdfBorderDictionary(2, PdfBorderDictionary.STYLE_SOLID));
field.setPage();
PdfAppearance tp = cb.createAppearance(170, 30);
PdfAppearance da = (PdfAppearance)tp.getDuplicate();
da.setFontAndSize(helv, fontSize);
da.setColorFill(textColor);
field.setDefaultAppearanceString(da);
writer.addAnnotation(field);
document.close();

So this is the power of iText, it does so many nice things with PDF, some of them are undocumented.

Modify poolit FixedPooler class to not give null objects on resize

2004-12-21T01:30:00.000-08:00

Pool it from acent phase http://www.ascent-phase.org/projects/poolit/ had a good object pooling library. I wanted to use the library for on of my projects, specifically i wanted to use the FixedPooler class http://www.ascent-phase.org/projects/poolit/api/org/ascentphase/poolit/poolers/FixedPooler.html.

FixedPooler has a resize method that i desired to use.

resize

public void resize(int newsize)

Changes the size of the pool. If the new size is smaller than the current, the number of objects exceeding the new size will be discarded. If the new size is greater than the current, the objects currently pooled will be moved over to the new pool, but no new objects will be created to fill in the new space.

Parameters:: newsize - the new size of the poo

So as seen above it does resize the pool as i wanted. But it did not add any new objects to the resized pool.

It uses an array to store objects internally and also there is a pointer called availablepos which is an int, that keeps track of which is the next object to fetch.

Please keep in mind that an array of size one, means that there can be a value at position 0. In other words Array positions start at 0.

For example. consider this pool(Array intenally)
Lets say the pool consists of string values of "A"
{"A","A","A"}
So here the pool size is 3 and the availablepos is 2.

A call to the fetch method will do this.
{"A","A",null}
So now the pool size is 2 and the availablepos is 1.

one more call to fetch will do this
{"A",null,null}
So now the pool size is 1 and the availablepos is 0.

one more call to fetch will do this
{null,null,null}
So now the pool size is 0 and the availablepos is -1.

How does this affect resize.

Lets say we are in this position:
{"A",null,null}
The pool size is 1 and the availablepos is 0.

Now someone issues a resize to be 6 by calling pool.resize(6)
So what will happen is
{"A",null,null, null,null,null}

The logical uestion is why can it not be
{"A",null,null, "A","A","A"}, that is the new Array gets the default objects in the pool ?

Look at the value of availablepos, it is 0, how ill that move to the new values as still at position 0 there is a value. Also the way to copy arrays in java is System.arraycopy(), and that does the copy exactly as descibed above, copies the values from the old array to the new array.

How do we solve this ?

I wrote a class that i called ModifiedFixedPooler which operates just like the Fixed pooler by pool it. But it handles the availablepos pointer differently.

Let's consider the same example
Lets say the pool consists of string values of "A"
{"A","A","A"}
So now here the pool size is 3 and the availablepos is O.

A call to the fetch method will do this.
{null,"A","A"}
So now the pool size is 2 and the availablepos is 1.

one more call to fetch will do this
{null,null,"A"}
So now the pool size is 1 and the availablepos is 2.

one more call to fetch will do this
{null,null,null}
So now the pool size is 0 and the availablepos is 3.

How does help the resize.

Lets say we are in this position:
{null,null,"A"}
So now the pool size is 1 and the availablepos is 2.

Now someone issues a resize to be 6 by calling pool.resize(6)
So what will in my method is this
{null,null,"A", "A","A","A"}
So now the pool size is 4 and the availablepos is still 2 which is right and does not need to change.

You can get the source code for fixed pooler at http://www.ascent-phase.org/downloads.ph p.

I am typing in the source code for the modified fixed pooler here.

/*
* Created on March 21, 2004
*/
package com.test.poolit;

/*
* @author suchakj
*/
import org.ascentphase.poolit.CreateException;
import org.ascentphase.poolit.FetchException;
import org.ascentphase.poolit.PoolHandler;
import org.ascentphase.poolit.Pooler;
import org.ascentphase.poolit.handlers.NoArgHandler;
import org.ascentphase.poolit.poolers.FixedPooler;

public class ModifiedFixedPooler implements Pooler {
protected Object pool[];
protected PoolHandler handler;
/**
* Points to the index in the pool array where the next available object
* can be retrieved from.
*/
protected int availPos;

/**
* Creates a pool with the specified class and size.
*
* @param name class to be pooled
* @param size size of pool to be created
*/
public ModifiedFixedPooler(Class name, int size) throws CreateException {
this(new NoArgHandler(name), size);
}

/**
* Creates a pool using the specified handler and size.
*
* @param handler PoolHandler to be used by this pool
* @param size size of pool to be created
*/
public ModifiedFixedPooler(PoolHandler handler, int size) throws CreateException {
this.handler = handler;
this.pool = new Object[size];
this.availPos = size;
fillPool();
}

public synchronized Object fetch() throws FetchException {
Object objret = null;

do {
if (availPos <>
objret = pool[availPos];
// remove reference in case object is not returned to pool
// so it can be garbage collected
pool[availPos++] = null;
if (!handler.verify(objret)) {
handler.destroy(objret);
objret = null;
}
} else { // no more objects available in pool
try {
objret = handler.create();
} catch (CreateException e) {
throw new FetchException(e.toString());
}
}
} while (objret == null);
//logx.info("availPos :: " + availPos);
return objret;
}

public synchronized void release(Object o) {
if (o == null) {
throw new NullPointerException();
} else if (availPos!=0 && availPos <= pool.length) {
pool[--availPos] = o;
} else { // pool full, so prepare object to be garbage collected
handler.destroy(o);
}
}

/**
* Reports the number of objects currently in the pool.
*
* @return the number of objects in the pool
*/
public int size() {
return pool.length - availPos;
}

/**
* Reports the maximum number of objects this pool can contain.
*
* @return the capacity of the pool
*/
public int capacity() {
return pool.length;
}

/**
* Changes the size of the pool.
* If the new size is smaller than the current, the number of objects
* exceeding the new size will be discarded.
* If the new size is greater than the current, the objects currently
* pooled will be moved over to the new pool, and new objects will be
* created to fill in the new space.
*
* @param newsize the new size of the pool
*/
public synchronized void resize(int newsize) {
if (newsize != capacity()) {
Object newpool[] = new Object[newsize];
// if newsize is smaller than # of current available objects, then
// copy upto newsize
int tempsize = pool.length;
if (newsize <>
System.arraycopy(pool, 0, newpool, 0, newsize);
// any objects not moved over to new pool are to be destroyed
// Which is ok as the size has to be shrunk or reduced
while (tempsize!=newsize){
handler.destroy(pool[--tempsize]);
}
// set next available object to first element in array
//availPos = newsize - 1;
} else { // copy up to available # of objects
int filllength=newpool.length-pool.length;
int currentfillpos = pool.length;
System.arraycopy(pool, 0, newpool, 0, currentfillpos);
// no need to change availPos value

for (int i=0; i
try {
newpool[currentfillpos] = handler.create();
} catch (CreateException e) {

e.printStackTrace();
}
++currentfillpos;
}
}

pool = newpool;
}
}

/**
* Called by constructor to fill up the pool.
*/
protected void fillPool() throws CreateException {
for (int i=0; i
availPos--;
pool[availPos] = handler.create();
//--availPos;
}
}

/**
* Destroys all objects in the pool.
* Implicitly, the next call to the fetch() will force a call to the
* handler's create() method.
*
* @see org.ascentphase.poolit.Pooler#close()
*/
public synchronized void close() {
while (availPos <>
handler.destroy(pool[availPos]);
pool[availPos] = null;
++availPos;
}
}

public static void main(String[] args) {

try {
ModifiedFixedPooler this_ = new ModifiedFixedPooler(String.class, 10);
this_.fetch();
this_.resize(20);

FixedPooler this_original = new FixedPooler(String.class,10);
this_original.fetch();
this_original.resize(20);
} catch (CreateException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (FetchException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

New struts actionform ,creation and reset() method

2004-12-20T05:24:00.000-08:00

This is an issue that i faced while using struts.

Struts has ActionForm classes, and they have a defined scope in the mapping file. Scope could be page, request or session.

Now , there are two issues.

1) Do not rely on the constructor of the from bean

The reason is that struts is implemented such that it first checks in the appropriate scope for the form bean, and if it finds the bean it uses the same bean after calling reset(). This means that there could be times when your form bean constructor is not even called!!!

http://struts.apache.org/userGuide/building_model.html#actionform

2) Be aware of how the reset() method works.

If you have form beans stored in session scope make sure that you implement the reset() method. The reason is the that reset() method is called when the continer takes the bean from that scope and uses it after it calls the reset() method to clean up the bean. The default implementation is to do nothing in the Actionform superclass's reset() method.

Also since you cannot thus rely on the constructor, you might as well have a reset() method to initialize code.

http://struts.apache.org/userGuide/building_controller.html#action_form_classes

Java Generics collection add performance

2004-12-20T04:46:00.000-08:00

I wanted to test the raw performance of using java generics with collections. So i wrote up the following code to add a similar nomber of objects to a collection.

public class Test {

private void testGenericsAddPerformance(){

long startTime = System.currentTimeMillis();
long endTime = 0;

System.out.println("STARTTime without generics ::: " + startTime);
ArrayList l = new ArrayList();

for(long i = 0;i<4000001>

l.add("SSSSSSSSSSSSSSSSSSSSSSSSSsss");

}
endTime = System.currentTimeMillis();
System.out.println("ENDTime without generics ::: " + endTime);
System.out.println("Diff without generics ::: " + (endTime-startTime) + " milliseconds");
l=null;
System.gc();

startTime = System.currentTimeMillis();
endTime = 0;

System.out.println("STARTTime with generics ::: " + startTime);
ArrayList l1 = new ArrayList();

for(long i = 0;i<4000001>

l1.add("SSSSSSSSSSSSSSSSSSSSSSSSSsss");

}
endTime = System.currentTimeMillis();
System.out.println("ENDTime with generics :::" + endTime);
System.out.println("Diffith generics ::: " + (endTime-startTime) + " milliseconds");
l=null;
System.gc();
}

public static void main(String[] args) {

Test this_ = new Test();
this_.testGenericsAddPerformance();

}
}

Here are the results.

STARTTime without generics ::: 1103546585484
ENDTime without generics ::: 1103546586921
Diff without generics ::: 1437 milliseconds

STARTTime with generics ::: 1103546586953
ENDTime with generics :::1103546587468
Diffith generics ::: 515 milliseconds

At least the initial raw performance seems to be better using Generics.

I have used JDK 1.5 version 1.5.0-beta2

Hibernate Mapping issue !

2004-12-20T03:42:00.000-08:00

I led a team of developers implementing Hibernate for a project. There was this developer who always managed to get stuck in something very silly.

So one day he comes to me declaring , "Hibernate does not work at all", i have doen everthing as per the spec and still it does notw work.

I saw his code and mapping and it seemed very fine! , i spent 4 hours debugging what he had done. In the process i opened up the hibernate source code (release 1.4) .

What i found was indeed silly.

This developer had done the following Hibernate mapping:-
.....
....

Looks innocent does it not ? Well look again, there is a space column="CORPORATION_ID " , and this is what hibernate did not like and gave the error will get the error that "JDBC error , column name not found...".

Here is the code for the Integer value Type from hibernate.

public class IntegerType extends PrimitiveType implements DiscriminatorType, VersionType {

private static final Integer ZERO = new Integer(0);

public Object get(ResultSet rs, String name) throws SQLException {
return new Integer(rs.getInt(name));
}
....

The error would not exist if the method was returning like this:-

return new Integer(rs.getInt(name.trim()));

I did post this some time ago on the hibernate forum :-

http://forum.hibernate.org/viewtopic.php?t=926430

I got a resonse that trim is not needed. I sort of agree that a developer should not be stupid to put spaces in the hibernate mapping files, but also i think having a trim(), does no harm.
At least that way i could have saved some time debugging.

Lastly i love open source code, as that way i know exactly what the issue is, rather than having to imagine what the problem maybe, or waiting for technical support.

Understanding Hibernate Transaction rollbacks.

2004-12-20T03:01:00.000-08:00

Hibernate does not have object level rollbacks. This means that the rollbacks and commits are always at the sql level.

method{
do{t = session.transaction;
try{
t.begintransaction
----code----
VO p = new VO();
session.save(p); // db insert not yet called
---code---
t.comit;
}catch{
t.rollback;
}
}
}//method end

Assume that an ID is generated by a custom class that i have built which basically reads a database table for id and updates the same at the same time.
Lets say there is an exception before the commit is called, then the above does not work as the t.rollback does not rollback the saved object in memory. There is no way to rollback that saved object in memory. I repeat roll back is always SQL level roll back, meaning that any sql fired between a transaction will be rolled back.

Moreover the next call to session.flush() still inserts the Object as the tx.rollback is just a sql level rollback and not object level.

To correct that i did this.

method{
do{t = session.transaction;
try{
t.begintransaction
----code----
VO p = new VO();
session.save(p); // db insert not yet called
session.flush(); // db insert forced, Hence sql query fired.
---code---
t.comit;
}catch{
t.rollback;
}
}
}//method end

Here the object was not inserted when session.flush was called next time at some other place in the code. The above code did the real rollback as needed.

Conclusion from Hibernate team in the forum.

The Hibernate Session is a unit of work. After you have committed or rolled back, you should close the session and get a new one for the next unit of work.
Sherman

In short there must be a new session (session.close()), after every commit or rollback and the old session must be discarded.

Please refer here :

http://forum.hibernate.org/viewtopic.php?t=932970

Ant default debug level

2004-12-20T02:52:00.000-08:00

The javac compiler generates the line numbers while compiling so that in case of an exception the stack trace can tell what line number the error happened.

Example

java.lang.NullPointerException
at ThreadCallB.run(ThreadCallB.java:7)

java.lang.NullPointerException
at ThreadCallA.run(ThreadCallA.java:7)

So I know I should look at line 7 of ThreadCallA.java and ThreadCallB.java .

However if I say "javac –g:none" while compiling then I will not get the above line numbers. Not so helpful, right ?

But that is what ant defaults to. Look at this doc: http://ant.apache.org/manual/CoreTasks/javac.html.

“Debug: Indicates whether source should be compiled with debug information; defaults to off. If set to off, -g:none will be passed on the command line for compilers that support it (for other compilers, no command line argument will be used). If set to true, the value of the debuglevel attribute determines the command line argument.”

Maybe there is solid reason for this, but it sure beats me if there is one!

Understanding what is locked when using the synchronized keyword.

2004-12-20T02:32:00.000-08:00

I wanted to put on paper, the exact meaning of what is locked when the synchronized keyword is used.

What I had read and heard discussed was that the Object is locked when a thread enters a synchronized method in a class. Now that will lead one to believe that the entire Object is locked.

Let us see.

Here is a class with a synchronized method “a”and a non synchronized method “b”.

public class Methods {

public synchronized void a(){

while(true){

System.err.println("a");

System.out.println("Thread.currentThread()" + Thread.currentThread());

}

public void b(){

while(true){

System.err.println("b");

System.out.println("Thread.currentThread()" + Thread.currentThread());

}

Here is class that gives singletons of the above class

public class MethodsFactory {

public static Methods m = null;

public static synchronized Methods getMethodsInstance(){

if(m == null){

m = new Methods();

}

return m;

}

Here are two Threads classes A and B that call the above factory and get the same instance of the Methods class, but call method a and b respectively. remember a is synchronized and b is not.

import java.util.List;

public class ThreadCallA extends Thread {

public void run() {

Methods m = MethodsFactory.getMethodsInstance();

m.a();

}

import java.util.List;

public class ThreadCallB extends Thread {

public void run() {

Methods m = MethodsFactory.getMethodsInstance();

m.b();

}

Now here is the main Test class.

public class Threadtest {

public static void main(String[] args) {

Thread TA = new ThreadCallA();

TA.setName("TA");

TA.start();

Thread TB = new ThreadCallB();

TB.setName("TB");

TB.start();

}

Here is the result.

Thread.currentThread()Thread[TA,5,main]

Thread.currentThread()Thread[TB,5,main]

Thread.currentThread()Thread[TA,5,main]

So even though method a() locks the object another thread can call method b() !.

This is because b() is not synchronized.

So what is a lock ? The lock just locks all synchronized code in an Object. On the static side any class is an instance of "Class", so the same applies there too.

Now if you synchronize b(), then b() will also be locked when a() is called.

And in our case due to us having “while(true)”, whichever thread gets to one of the methods first will be the only thread executing and the other thread will never get to the other synchronized method. Try it !,

Now if you have a static method, that method can still be called when there is a lock due to an instance method

Java Tiger and Me !

2004-12-19T22:58:00.000-08:00

I had come to java from a smalltalk background. I found a few things very strange.

And now I can see that the there are solutions to what I found strange, back in mar-apr of 2000, in the new Java Tiger release.

Need to cast classes in and out of collections.

I had posted on the java newsgroup. The heading was Casting Classes . Of course the credit for this goes to smalltalk. It is such a superb language.

All that I was saying there is that objects should know who they are when are put in or taken out of collections.

Using Generics for java collections does this very nicely.

But of course my complaint and another aspect , that that was that in totality “Objects should know who they are” . But that issue is one of language itself, being type safe or not, and I have learned to live with java being type safe.

Need to have to use two different artifacts for the same type of thing

Why should there be an int and an Integer at all. I had posted about this as Why the difference between Integer and int ?? in the java newsgroups.

It still seems so illogical to me. Why have primitives at all in an object oriented language. Again this had come from knowing smalltalk.

Now we have something called autoboxing in both java and C#, which helps with just that.

A good article for new features in java is at

http://www.javaworld.com/javaworld/jw-04-2004/jw-0426-tiger1.html

http://www.javaworld.com/javaworld/jw-06-2004/jw-0607-tiger2.html

I will try and post some performance metrics, which will show whether collections are faster with or without generics.