XStream!

If you ever wanted to use XML with Java for whatever be the reason, first check this out.

http://xstream.codehaus.org/tutorial.html

Continuous Integration Tools - Cruise Control

More:
http://www.javaranch.com/journal/200409/Journal200409.jsp

http://confluence.public.thoughtworks.org/display/CC/Getting+Started+With+CruiseControl

NaN in Double!

From source code, the definition of NaN is

/**
* A constant holding a Not-a-Number (NaN) value of type
* double. It is equivalent to the value returned by
* Double.longBitsToDouble(0x7ff8000000000000L).
*/
public static final double NaN = 0.0d / 0.0;


From JLS & API doc:

Note that in most cases, for two instances of class Double, d1 and d2,
the value of d1.equals(d2) is true if and only if
d1.doubleValue() == d2.doubleValue()also has the value true.

However, there are two exceptions:

If d1 and d2 both represent Double.NaN, then the equals method returns true, even though Double.NaN==Double.NaN has the value false.

If d1 represents +0.0 while d2 represents -0.0, or vice versa, the equal test has the value false, even though +0.0==-0.0 has the value true.

This definition allows hash tables to operate properly.

Why static methods can't be abstract?

An abstract method requires implementation per instance. Static methods pertain to an overall class. A static method in an abstract class belongs to the abstract class, not potential implementations. It therefore doesn't make any sense to allow abstract static methods. Furthermore, static methods cannot be overridden, so again, abstract static methods would be an anomaly.

EHCache - Where to cache other than Http Session?

Whats it?

Ehcache is a widely used java distributed cache for general purpose caching, Java EE and light-weight containers.

It features memory and disk stores, replicate by copy and invalidate, listeners, cache loaders, cache extensions, cache exception handlers, a gzip caching servlet filter and much more.

Ehcache is available under an Apache open source licence and is actively developed, maintained and supported.

Who is using?

Alfresco An Enterprise Content Management system
Cocoon. A web development framework.
Hibernate. An O/R mapping tool.
Spring. An IOC framework from Rod Johnson.
JPOX. A Java Persistent Objects frameworkd and JDO implementation.
Jofti. A cached object indexing and searching system.
Acegi. A security system for Spring.
Kosmos. Kosmos stands for Komposite Open Source Monitoring Suite..
Tudu Lists. Online list management.
Lutece. Lutece is an Open Source Java/ XML portal.

How to use?

//Get CacheManager through config
URL url = getClass().getResource("/anotherconfigurationname.xml");
CacheManager manager = new CacheManager(url);

CacheManager manager = new CacheManager("src/config/ehcache.xml");

//GetSingleton CacheManager
CacheManager singletonManager = CacheManager.create();

//Add Cache
singletonManager.addCache("testCache");
Cache test = singletonManager.getCache("testCache");

//Add Elements
Element element = new Element("key1", "value1");
test.put(element);

//Remove Cache
singletonManager.removeCache("testCache");

//Shutdown
CacheManager.getInstance().shutdown();
manager.shutdown();



More Info :

http://ehcache.sourceforge.net/

Spring Transaction Management Example!

The service layer handles the business logic & DML actions on Entities.

The service methods are executed through Transaction proxies in order to manage the transaction.In other words,the Transaction Proxy wraps the execution of each transactional[which inserts/updates/deletes] service methods.


The Transaction Proxy is configured with TransactionInterceptor,TransactionManager and TransactionAttributes.

Transaction Attributes [REQUIRED,REQUIRED_NEW,SUPPORTS etc] tells us how the transaction to be handled.

The actual transaction[manage DB connection, execute actual JDBC, commit/rollback] is handled by Transaction Manager which is configured with Datasource.

The transaction proxy is in turn wrapped with Transaction Interceptor. This interceptor uses the Transaction Attributes and Transaction Manager to fulfill the transaction.

The Transaction Interceptor can be accompanied by one or more Pre and/or Post Interceptors.

The PreInterceptors wraps the TransactionInterceptor and therefore they are outside of transaction boundry.There can be one or more preInterceptors and they are executed in sequence as configured in chain.

The PostInterceptors are inside the TransactionInterceptor and they are executed one by one as configured in list.

After execution of all Post interceptors, the actual method implementation of the target object is execcuted.

Example Illustration:
The client[web layer] invokes service methods[which are transactional] as below.

//Find service bean through BeanFactory
IUserMaintService userService=ServiceFactory.getUserMaintService();
userService.insertUser(new User());

Here the service methods of IUserMaintService is configured on top of TransactionProxy [org.springframework.transaction.interceptor.TransactionProxyFactoryBean],
When a service method 'insertUser' is called, it executes the pre Interceptors if anything configured and then the transactionInterceptor.invoke method which in turn verifies the transaction attributes and create a transaction if required. This is the starting point of transaction boundary.After this, the sequence of post interceptors are getting executed and finally folowed by the 'TARGET implementation' method execution.


org.springframework.transaction.interceptor.TransactionProxyFactoryBean is configured with

-PreInterceptors org.springframework.transaction.interceptor.TransactionInterceptor --uses---->org.springframework.jdbc.datasource.DataSourceTransactionManager and org.springframework.transaction.interceptor.TransactionAttribute -PostInterceptors
-Actual Method Execution

Dynamic Proxy!

The Proxy pattern is one of the most important design patterns because it provides an alternative to extending functionality with inheritance. That alternative is object composition, where an object (proxy) forwards method calls to an enclosed object (real subject).

Object composition is preferable to inheritance because, with composition, enclosing objects can only manipulate their enclosed object through the enclosed object's interface, which results in loose coupling between objects. In contrast, with inheritance, classes are tightly coupled to their base class because the internals of a base class are visible to its extensions.

Because of that visibility, inheritance is often referred to as white-box reuse. On the other hand, with composition, the internals of the enclosing object are not visible to the enclosed object (and vice-versa); therefore, composition is often referred to as black-box reuse. All things being equal, black-box reuse (composition) is preferable to white-box reuse (inheritance) because loose coupling results in more malleable and flexible systems.

Because the Proxy pattern is so important, J2SE 1.3 (Java 2 Platform, Standard Edition) and beyond directly supports it. That support involves three classes from the java.lang.reflect package: Proxy, Method, and InvocationHandler.

Some basic concepts of Proxy class
> Proxy classes are public, final, and not abstract.
> The unqualified name of a proxy class is unspecified. The space of class names that begin with the string "$Proxy" should be, however, reserved for proxy classes.
> A proxy class extends java.lang.reflect.Proxy.
> A proxy class implements exactly the interfaces specified at its creation, in the same order.
> If a proxy class implements a non-public interface, then it will be defined in the same package as that interface. Otherwise, the package of a proxy class is also unspecified. Note that package sealing will not prevent a proxy class from being successfully defined in a particular package at runtime, and neither will classes already defined in the same class loader and the same package with particular signers.
> Since a proxy class implements all of the interfaces specified at its creation, invoking getInterfaces on its Class object will return an array containing the same list of interfaces (in the order specified at its creation), invoking getMethods on its Class object will return an array of Method objects that include all of the methods in those interfaces, and invoking getMethod will find methods in the proxy interfaces as would be expected.
> The Proxy.isProxyClass method will return true if it is passed a proxy class-- a class returned by Proxy.getProxyClass or the class of an object returned by Proxy.newProxyInstance-- and false otherwise.
> The java.security.ProtectionDomain of a proxy class is the same as that of system classes loaded by the bootstrap class loader, such as java.lang.Object, because the code for a proxy class is generated by trusted system code. This protection domain will typically be granted java.security.AllPermission.
> Each proxy class has one public constructor that takes one argument, an implementation of the interface InvocationHandler, to set the invocation handler for a proxy instance. Rather than having to use the reflection API to access the public constructor, a proxy instance can be also be created by calling the Proxy.newInstance method, which combines the actions of calling Proxy.getProxyClass with invoking the constructor with an invocation handler.
> A proxy instance has the following properties:
Given a proxy instance proxy and one of the interfaces implemented by its proxy class Foo, the following expression will return true:
proxy instanceof Foo
and the following cast operation will succeed (rather than throwing a ClassCastException):
(Foo) proxy
>Each proxy instance has an associated invocation handler, the one that was passed to its constructor. The static Proxy.getInvocationHandler method will return the invocation handler associated with the proxy instance passed as its argument.
>An interface method invocation on a proxy instance will be encoded and dispatched to the invocation handler's invoke method as described in the documentation for that method.
>An invocation of the hashCode, equals, or toString methods declared in java.lang.Object on a proxy instance will be encoded and dispatched to the invocation handler's invoke method in the same manner as interface method invocations are encoded and dispatched, as described above. The declaring class of the Method object passed to invoke will be java.lang.Object. Other public methods of a proxy instance inherited from java.lang.Object are not overridden by a proxy class, so invocations of those methods behave like they do for instances of java.lang.Object.


Below example shows a simple example that utilizes the JDK support for the Proxy pattern:

JDK proxies

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface AnInterface {
public void doSomething();
}

class AClass implements AnInterface {

public void doSomething() {
System.out.println("Inside Method AClass.doSomething()");
}
}
public class Test {

public static void main(String args[]) {
AnInterface realSubject = new AClass();
AnInterface proxy = (AnInterface)Proxy.newProxyInstance(
realSubject.getClass().getClassLoader(),realSubject.getClass().getInterfaces(),
new SimpleInvocationHandler(realSubject));

passMeAProxy(proxy);

}

private static void passMeAProxy(AnInterface anInterface) {
anInterface.doSomething();
}
}

class SimpleInvocationHandler implements InvocationHandler {

public SimpleInvocationHandler(Object realSubject) {
this.realSubject = realSubject;
}

public Object invoke(Object proxy, Method m, Object[] args){

Object result = null;
System.out.println("Before Calling " + m.getName());

try {
result = m.invoke(realSubject, args);
}

catch(Exception ex) {
System.exit(1);
}

System.out.println("After Calling " + m.getName());
return result;
}
private Object realSubject = null;
}


In the preceding example, the static Proxy.newProxyInstance() method creates a proxy for a real subject. Real subjects must implement one or more interfaces, and a reference to a proxy can be passed to any method that expects a reference to one of those interfaces. The main() method passes the proxy to a method that takes a reference to AnInterface, just to prove it can be done. In the preceding example, our simple proxy implements only one interface.

Proxy.newProxyInstance() takes three arguments: the class loader that loaded the real subject, a list of interfaces implemented by the real subject, and a reference to an invocation handler.

Every time you invoke a proxy's method, the proxy calls its invocation handler's invoke() method. The proxy passes itself to the invoke() method, along with a reference to the proxy's method and its list of arguments. In the preceding code, SimpleInvocationHandler.invoke() invokes the specified method on the real subject. Here's the output of the application listed in
Example

Before Calling doSomething
Inside Method AClass.doSomething()
After Calling doSomething

Proxy applicability
The Proxy pattern applies whenever you need to control access to an object. The most common situations include:

1.Remote proxies
2.Virtual proxies
3.Protection proxies - Security Authentication/Authorization

Remote proxies control access to remote objects, such as the Web service proxy.

Virtual proxies - control access to resources that are expensive to create, such as large images.

Protection proxies control what functionality specific users can access.

Classes that implement stable interfaces with few methods are the best candidates for a proxy's real subject because their proxies are easy to implement and maintain.TheJDK's built-in Proxy pattern support makes it much easier to implement proxies whose real subjects have a large number of methods.

Then whats the difference between the Decorator and Proxy patterns. Although you implement both patterns in an almost identical fashion, it's the intent of those patterns that differs. The Decorator pattern constructs objects at runtime by recursively enclosing an object within one or more decorators. The Proxy pattern acts as a stand-in for a real subject, which is set at compile time.

Dynamic Proxies with Spring

Dynamic proxies are extensively supported in Spring framework for following things

Spring AOP [Aspect Oriented Programming] - Interceptors - MethodInvocation is based on Dynamic Proxy
Spring Transaction Management [through TransactionProxyFactoryBean]


Easy Mock with Dynamic Proxy

Easy Mock - Creating mock objects for interfaces & classes for unit testing - creates mock objects using dynamic proxies


lot more .....

another custom example...

package org.nava.jfive.reflect;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Calendar;

/**
* Client for testing
*/
public class Dec27 {

public static void main(String[] args) {

ITest realSubject = new TestImpl();

ITest proxy = (ITest)Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),
realSubject.getClass().getInterfaces(),new TestHandler(realSubject));
proxy.setMe((proxy instanceof Proxy)?"is Proxy instance":"is not proxy instance");
System.out.println("The Result of 'me':"+proxy.getMe());
}

}

/**
* Inteface for Test
*/
interface ITest {
String getMe();
void setMe(String s);
}
/**
* Concreate Implementation for Inteface ITest
*/
class TestImpl implements ITest{

private String me_;

public String getMe() {
return me_;
}
public void setMe(String s) {
me_="The "+ s+" and the real object is :"+this.getClass().getSimpleName();
}
}

/**
* InvocationHandler for Test Proxy
*
*/
class TestHandler implements InvocationHandler{

private Object realSubject = null;

public TestHandler() {
super();
}
public TestHandler(Object real) {
this.realSubject=real;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
System.out.println("---------------------------------------------");
System.out.println("Is Proxy instance of TestImpl:"+(proxy instanceof TestImpl));
System.out.println("Is Proxy instance of ITest:"+(proxy instanceof ITest));
System.out.println("Is Proxy instance of Object:"+(proxy instanceof Object));
System.out.println("Is Proxy instance of Proxy:"+(proxy instanceof Proxy));
System.out.println(Calendar.getInstance().getTime()+" Before Calling " + method.getName());
try {
result = method.invoke(realSubject, args);
}catch(Exception ex) {
System.exit(1);
}
System.out.println(Calendar.getInstance().getTime()+"After Calling " + method.getName());
return result;
}

}


Why identifiers have naming restrictions ?

As per Java Language Specification Lexical Structure .....

An identifier is an unlimited-length sequence of Java letters and Java digits, the first of which must be a Java letter. An identifier cannot have the same spelling (Unicode character sequence) as a keyword (§3.9), boolean literal (§3.10.3), or the null literal (§3.10.7).

Identifier:
IdentifierChars but not a Keyword or BooleanLiteral or NullLiteral

IdentifierChars:
JavaLetter
IdentifierChars JavaLetterOrDigit

JavaLetter:
any Unicode character that is a Java letter (see below)

JavaLetterOrDigit:
any Unicode character that is a Java letter-or-digit (see below)

Letters and digits may be drawn from the entire Unicode character set, which supports most writing scripts in use in the world today, including the large sets for Chinese, Japanese, and Korean. This allows programmers to use identifiers in their programs that are written in their native languages.
A "Java letter" is a character for which the method Character.isJavaIdentifierStart(int) returns true. A "Java letter-or-digit" is a character for which the method Character.isJavaIdentifierPart(int) returns true.

The Java letters include uppercase and lowercase ASCII Latin letters A-Z (\u0041-\u005a), and a-z (\u0061-\u007a), and, for historical reasons, the ASCII underscore (_, or \u005f) and dollar sign ($, or \u0024). The $ character should be used only in mechanically generated source code or, rarely, to access preexisting names on legacy systems.

The "Java digits" include the ASCII digits 0-9 (\u0030-\u0039).

Two identifiers are the same only if they are identical, that is, have the same Unicode character for each letter or digit.

Identifiers that have the same external appearance may yet be different. For example, the identifiers consisting of the single letters LATIN CAPITAL LETTER A (A, \u0041), LATIN SMALL LETTER A (a, \u0061), GREEK CAPITAL LETTER ALPHA (A, \u0391), CYRILLIC SMALL LETTER A (a, \u0430) and MATHEMATICAL BOLD ITALIC SMALL A (a, \ud835\udc82) are all different.

Unicode composite characters are different from the decomposed characters. For example, a LATIN CAPITAL LETTER A ACUTE (Á, \u00c1) could be considered to be the same as a LATIN CAPITAL LETTER A (A, \u0041) immediately followed by a NON-SPACING ACUTE (´, \u0301) when sorting, but these are different in identifiers. See The Unicode Standard, Volume 1, pages 412ff for details about decomposition, and see pages 626-627 of that work for details about sorting.

Examples of identifiers are:

String,i3,MAX_VALUE,isLetterOrDigit

Is String a keyword ?

Following program works great! know the basics


public class Dec26 {
public static void main(String[] args) {
String String="nambi";
System.out.println(String);
}

}



Nutch - Java Search Engine

What is Nutch?

Nutch is an effort to build a Free and Open Source search engine. It uses Lucene for the search and index component. The fetcher (robot) has been written from scratch solely for this project.

Nutch has a highly modular architecture allowing developers to create plug-ins for activities such as media-type parsing, data retrieval, querying and clustering.

Doug Cutting is the lead developer of Nutch.

What is Lucene?

Lucene is a Free and Open Source search and index API released by the Apache Software Foundation. It is written in Java and is released under the Apache Software License.

Lucene is just the core of a search engine. As such, it does not include things like a web spider or parsers for different document formats. Instead these things need to be added by a developer who uses Lucene.

Lucene does not care about the source of the data, its format, or even its language, as long as you can convert it to text. This means you can use Lucene to index and search data stored in files: web pages on remote web servers, documents stored in local file systems, simple text files, Microsoft Word documents, HTML or PDF files, or any other format from which you can extract textual information.

Lucene has been ported or is in the process of being ported to various programming languages other than Java:

Lucene4c - C
CLucene - C++
MUTIS - Delphi
NLucene - .NET
DotLucene - .NET
Plucene - Perl
Pylucene - Python
Ferret and RubyLucene – Ruby

More ....
http://wiki.apache.org/nutch/Nutch_-_The_Java_Search_Engine

Unix Simulators in Windows - Cygwin

Cygwin is a Linux-like environment for Windows. It consists of two parts:

1. A DLL (cygwin1.dll) which acts as a Linux API emulation layer providing substantial Linux API functionality.

2. A collection of tools which provide Linux look and feel.


More....
http://www.cygwin.com/

Unix - List File & Parse File name

Requirement:

Find list of files in current directory and parse the file names to decipher which program to execute

#!/usr/bin/ksh

echo 'Nambi'

#To find files with "text" in all sub directories from current
#find . -type f -name "text" -print| while read obj
#To find ALL files in all sub directories from current
#find . -type f -print| while read obj

#Just files in current directory
ls -1 | while read fname
do
echo 'File name:'$fname
#Parse file name to get specific output
#echo $fname | cut -c-3
l=`echo $fname | cut -c2-4`
echo $l

done

echo 'End'



Rich Domain || Fat Service?

THIS is been discussed in almost all multi-layered application architectures where to put most of the business logic, whether its in domain or in service. More than 80%of the time you can expect it should be a service layers due to various advocations.

This post try to throw some basic questions that everyone should consider ...

1.Is domain just a entity? Or it accompanies the domain service & value objects?
2.Can domain access other service layers? If so, hwo much can you perform unit testing?
3.How much DAO can co-hesive with domain?
4.Where to perform domain validation...is it a domain behaviour or domain service job?
5.Can you instantiate any other domains directly from domain behaviours?
6.How far we can use static in domain? Is it a good practice from unit test perspective?
7.Can a domain have additional behaviours apart from getters/setters of its state?
...of course lot more ... .

Avoid your IP stolen through Java Decompilers!

How to protect you Intellectual Property of java source code[even in compiled format] in a way that cannot be deompiled fully and stolen

As an example, do not provide your build compiled with debug options. Class files compiled with debug options provides more info on bytecode which facilitates easy decompilation

Test Coverage Tools for Java

http://java-source.net/open-source/code-coverage

What is Acegi Security?

http://acegisecurity.org/

Apache Lucene - Search Engine

Java Caching Services!

JavaSpaces, including Gigaspaces and Blitz.



Declarative caching services including EHCache, JCS, OSCache, GigaSpaces

Spring Mock!

Part of Spring Dynamic Modules for OSGi

HttpUnit - For Web App Testing

Effective AOP for enterprise applications!

Easy Mock for Unit Testing

http://sourceforge.net/projects/easymock

Jasper Reports!

Reporting is always been a necessary feature of any Enterprise organization. Around 20-30% of software applications certainly include basic to advanced reporting.

There are plenty of utilities available to make reporting easy to integrate with any enterprise architecture.

The default choice of reporting tech has been the 'Crystal Reports' especially when microsoft bundled the product with Visual Studio. The Crystal Reports are marked by Business Objects[now acquired by SAP] and costs around $500 per license.

Jasper Reports comes as a Savior of OPEN source equally comprising all features of commerial products and well integrates with Java with good community participation.

JasperReports provides the necessary features to generate dynamic reports, including data retrieval using JDBC (Java Database Connectivity), as well as support for parameters, expressions, variables, and groups. JasperReports also includes advanced features, such as custom data sources, scriptlets, and subreports.

There have been plenty of releases and the current version is 2.0

Lets look at basic architecture and how to generate a simple report with Jasper.

Basic Objects of Jasper:

JasperDesign: Represents a report's definition. In most cases, you create a JasperDesign from an XML report template, though you can also create it programmatically.

JasperReport: Represents a compiled JasperDesign. The compilation process verifies the report design and compiles the design into a JasperReport object.

JasperPrint: Represents a generated report. You create a JasperPrint from a JasperReport through the fill process in which a report is populated with data from a data source.

JasperManager:
The JasperReports API's flexibility lets you load JasperDesign, JasperReport, and JasperPrint objects from a file or a stream, and also lets you create these objects programmatically. You can print reports to a printer, an image, or a PDF file. The JasperReports library includes a facade class, dori.jasper.engine.JasperManager, with methods that facilitate loading, compiling, filling, and printing reports.

Generating basic Report:


// First, load JasperDesign from XML and compile it into JasperReport

JasperDesign jasperDesign = JasperManager.loadXmlDesign("BasicReport.xml");

JasperReport jasperReport = JasperManager.compileReport(jasperDesign);

// Second, create a map of parameters to pass to the report.
Map parameters = new HashMap();
parameters.put("ReportTitle", "Basic JasperReport");
parameters.put("MaxSalary", new Double(25000.00));

// Third, get a database connection
Connection conn = Database.getConnection();

// Fourth, create JasperPrint using fillReport() method
JasperPrint jasperPrint = JasperManager.fillReport(jasperReport,
parameters, conn);
// You can use JasperPrint to create PDF
JasperManager.printReportToPdfFile(jasperPrint, "BasicReport.pdf");
// Or to view report in the JasperViewer
JasperViewer.viewReport(jasperPrint);


Another way to build report..


//Get the JRXML file
String fileName = lookUp(module);
InputStream templatesAsStream = loadTemplateAsStream(fileName);
JasperReport jasperReport = JasperCompileManager.compileReport(templatesAsStream);
JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport,
builder.build(object), new JREmptyDataSource());

byte[] bytes = JasperExportManager.exportReportToPdf(jasperPrint);


Sample JRML file

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jasperReport PUBLIC "-//JasperReports//DTD Report Design//EN"
 "http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">
<jasperReport name="BasicReport" >
  <parameter name="Title" class="java.lang.String"/>
  <queryString><![CDATA[select name, cost from product]]></queryString>
  <field name="NAME" class="java.lang.String"/>
  <field name="COST" class="java.lang.Double"/>
  <title>
    <band height="50">
      <textField>
        <reportElement x="0" y="0" width="200" height="50" />      
        <textFieldExpression class="java.lang.String">$P{Title}</textFieldExpression>
      </textField>
    </band>
  </title>
  <pageHeader>
    <band>
    </band>
  </pageHeader>
  <columnHeader>
    <band height="20">
      <staticText>
        <reportElement x="180" y="0" width="180" height="20"/>
        <textElement>
          <font isUnderline="true"/>
        </textElement>
        <text><![CDATA[NAME]]></text>
      </staticText>
      <staticText>
        <reportElement x="360" y="0" width="180" height="20"/>
        <textElement>
          <font isUnderline="true"/>
        </textElement>
        <text><![CDATA[COST]]></text>
      </staticText>
    </band>
  </columnHeader>
  <detail>
    <band height="20">
      <textField>
        <reportElement x="180" y="0" width="180" height="20"/>                 
        <textFieldExpression class="java.lang.String"><![CDATA[$F{NAME}]]></textFieldExpression>
      </textField>
      <textField pattern="0.00">
        <reportElement x="360" y="0" width="180" height="20"/>                 
        <textFieldExpression class="java.lang.Double"><![CDATA[$F{COST}]]></textFieldExpression>
      </textField>
    </band>
  </detail>
  <columnFooter>
    <band>
    </band>
  </columnFooter>
  <pageFooter>
    <band height="15">
      <staticText>
        <reportElement x="0" y="0" width="40" height="15"/>
        <textElement/>
        <text><![CDATA[Page:]]></text>
      </staticText>
      <textField>
        <reportElement x="40" y="0" width="100" height="15"/>
        <textElement/>
        <textFieldExpression class="java.lang.Integer"><![CDATA[$V{PAGE_NUMBER}]]></textFieldExpression>
      </textField>
    </band>
  </pageFooter>
  <summary>
    <band>
    </band>
  </summary>
</jasperReport>












More intro...
http://www.jasperforge.org/jaspersoft/opensource/business_intelligence/jasperreports/

JPA with Hibernat

http://www.developer.com/java/ent/article.php/10933_3577101_1

http://www.onjava.com/pub/a/onjava/2007/02/08/an-introduction-to-hibernate-3-annotations.html

more on

http://www.i-proving.ca/space/Technologies/Hibernate/Hibernate+Annotation+Examples/Collection+of+Elements


http://www.javakaffee.de/blog/2006/11/28/hibernate-annotation-for-a-map-of-some-enum-type-to-some-primitive-type/

Java Script Engine in JSDK6

Whats it?
The scripting API consists of interfaces and classes that define Java TM Scripting Engines and provides a framework for their use in Java applications. This API is intended for use by application programmers who wish to execute programs written in scripting languages in their Java applications. The scripting language programs are usually provided by the end-users of the applications.

The main areas of functionality of javax.script package include

Script execution: Scripts are streams of characters used as sources for programs executed by script engines. Script execution uses eval methods of ScriptEngine and methods of the Invocable interface.

Binding: This facility allows Java objects to be exposed to script programs as named variables. Bindings and ScriptContext classes are used for this purpose.

Compilation: This functionality allows the intermediate code generated by the front-end of a script engine to be stored and executed repeatedly. This benefits applications that execute the same script multiple times. These applications can gain efficiency since the engines' front-ends only need to execute once per script rather than once per script execution. Note that this functionality is optional and script engines may choose not to implement it. Callers need to check for availability of the Compilable interface using an instanceof check.

Invocation: This functionality allows the reuse of intermediate code generated by a script engine's front-end. Whereas Compilation allows entire scripts represented by intermediate code to be re-executed, Invocation functionality allows individual procedures/methods in the scripts to be re-executed. As in the case with compilation, not all script engines are required to provide this facility. Caller has to check for Invocable availability.

Script engine discovery and Metadata: Applications written to the Scripting API might have specific requirements on script engines. Some may require a specific scripting language and/or version while others may require a specific implementation engine and/or version. Script engines are packaged in a specified way so that engines can be discovered at runtime and queried for attributes. The Engine discovery mechanism is based on the Service discovery mechanism described in the Jar File Specification. Script engine implementing classes are packaged in jar files that include a text resource named META-INF/services/javax.script.ScriptEngineFactory. This resource must include a line for each ScriptEngineFactory that is packaged in the jar file. ScriptEngineManager includes getEngineFactories method to get all ScriptEngineFactory instances discovered using this mechanism. ScriptEngineFactory has methods to query attributes about script engine.

Generics

Abstract Over Types especially for Collection

Bit Shifting!

To shift a number one bit to the right, remove the rightmost bit and add a bit on the left. If the leftmost bit before the shift is 0, add a 0; if it is 1, add a 1.

So looking at your example 32 >> 3:

32 == 0010 0000

Shift this to the right three times, using the method described above. This gives:

0001 0000
0000 1000
0000 0100

So the answer is 0000 0100 == 4.

Note, you always have to take all the bits in the number into account. If your are shifting an int, which is 32 bits, you should look at all 32 bits:

0000 0000 0000 0000 0000 0000 0010 0000

The "NULL" Type

There is also a special null type, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.


class NameClass
{
static String name="xyz";
static NameClass getClass1()
{
System.out.println("inside method");
return null;
}
public static void main(String[] args)
{
System.out.println(getClass1().name);
}
}

the above code prints : inside method xyz

The variable name is declared as static. static variables and methods are not depends on the object instance

Power of Velocity!

Velocity is known as just another open source product from ASF and used Template Engine. But Velocity is much more than that. It can be effectivly used as
1. Template Render
2. Code Generator
3. Rule Engine
etc

Lets have closer look at each of these capabilities

Contemporary technologies for web template engines are Freemarker, Groovy, Velocity, WebMacro and XSLT.

TODO: Comparative study of how these frameworkds work with Java

Also compare with Rules Engines such as Drools and Jess

THIS & SUPER in Static Context

You cannot call "super" from a static context. Just like you can't use "this" or call any non-static methods in a static context.

Diff - Array of Objects & Collections

Array of Objects - Stores object references.i.e, when you change object value anywhere , the changes are reflected in arrays

Collections - stores object copies. - once object is added to the collection, any changes on the object will not reflect in collection. Applicable to all collection - List/Vector/Set/Map etc

Java Mandatory Package Struture!

Can you import a class/interface of a default package from any specific packages.

For example, if you have class DefInterface defined without a package and if you want to use this interface in a class org.nava.DefImpl, can below code will work?

package org.nava;
import DefInterface;
class DefImpl implements DefInterface{

}

This doesnot work! Either you have complete package structure or no packages.

Just curious was it ever possible in java?

How to Serialize Transient variables?

Transient variables are not automatically serialized.

However, we can externally make these variables available in serialized object in following way.


class Animal implements Serializable {

transient int legs, wings;

private void writeObject(ObjectOutputStream os) {

try {
os.defaultWriteObject();
os.writeInt(legs);
os.writeInt(wings);
} catch (IOException e) {
e.printStackTrace();
}
}

private void readObject(ObjectInputStream is) {
try {
is.defaultReadObject();
// swapped:
this.wings = is.readInt();
this.legs = is.readInt();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}

}

}
------------------
public class AnimalSerializer { public static void main(String[] args) {
List list = new ArrayList();
Animal bird = new Animal("Bird", 2, 2);
Animal fly = new Animal("Fly", 6, 2);
list.add(bird);
list.add(fly);
try {
FileOutputStream fos = new FileOutputStream("anis.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(list);
oos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(list);
list = null;
System.out.println(list);
try {
FileInputStream fis = new FileInputStream("anis.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
list = (List) ois.readObject();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println(list);
}
}



Canoo WebTest!

Pros:
Simple
Fast
Excellent Reporting
Very low TCO
Runs everywhere
No display needed
Easy to extend
Straightforward integration
Doesn't accept (too) badly formed html
Cons:
Javascript support not as good as in "normal" browser
Doesn't accept (too) badly formed html


Tried with LCN application with around 90% of the form elements were not recognized. Either we develop bad way or Canoo is so strict.

Looks like may not be suitable for usual web applications whereas bad html is almost unavoidable since Rich browsers doesn;t complains them

Also, java scripts are not heavily supported and with WEB 2.0 developments, its becoming difficult to program within restricted tags. Needs to develop lot of custom steps for any Enterprise applications

True North!

Discover your Authentic Leadership - Bill George[Harvard) with Peter Sims(Stanford)

Authentic Leadership

Leading your professional/personal/family/community life as INTEGRATED single life following your TRUE NORTH!

What is True North!

True North is the internal compass that guides you successfully through your life.It represents who you are as a human being at your deepest level.It is your orienting point-your fixed point in spinning world-that helps you stay on track in life.

Your True North is based on what is most important to you, your most cherished values,your passion and motivations, the sources of satisfaction in your life.

Discovering your True North takes a lifetime of commitment and learning!

Five Dimensions of Authentic Leader
1. Pursuing purpose with passion
2. Practicing solid values
3. Leading with heart
4. Establishing enduring relationships
5. Demonstrating self-discipline


Leadership is a Journey

Three phases of life with leadership:

1. Preparing for Leadership [Age 0-30]
2. Leading [31-60]
3. Giving Back [61-90]

Losing Sight of Your True North

1. Imposters - lacking self awareness & self esteem due to cunning & aggression
2. Rationalizers - deviating from values
3. Glory seekers - motivated by seeking world's acclaim.
4. Loners - fail to build personal support with whom you can always be yourself truly.
5. Shooting Stars - lacking the grounding of an integrated life

Moving from [0-30] to [31-60] - Transformation from "I" to "WE"

The is the first step towards authentic leadership is to discard the myth that leadership means having legions of supporters following our direction as we ascend to the pinnacles of power. Authentic leadership is about empowering others on their journeys.

Only when leaders stop focussing on their personal ego needs are they able to develop other leaders.They feel less competitive with talented peers and subordinates and are more open to other points of view, enabling them to make better decisions.As they overcome their need to control everything, they learn that people are more interested in working with them. A lightbulb goes on as they recognize the unlimited potential of empowered leaders working together toward a shared purpose.

This tranformation from "I" to "WE" is crucial to step on actual "LEADING" phase of life.

Discovering Your Authentic leadership
Guided by following directions

1. Self Awareness

What is my life story? At the end of my life how would I like see my life journey? What are my current Strengths& Weeknesses? What are my developmental needs ?

2. Values and Principles

What are my most deeply held values?

Values: The relative importance of things that matter in your life.
Principles: A Set of standards used in leading others, derived from your values.Principles are values translated into action

3. Motivations

What motivates me? How do I balance external[money/fame/glory/status] with my internal [satisfaction/sense of acheivement] motivations?

Find out what you are good at and what you like to do.

4. Support Team

Who are the people I can count on to guide and support me along the way?

5. Integrated Life

How can I integrate all aspects of my life and find fulfillment?

Make conscious choices & trade-offs to balance all parts of your life-infact its single Integrated life. This is essential in order to excel in all aspects as integrated.

Ruby from Java Programmer's perspective!

One liners:

-Created by Yukihiro “matz” Matsumoto [Japan] around late 90s.
-Scripting language ; hence interpreted
-Memory is managed for you via a garbage collector.
-Objects are strongly typed.
-There are public, private, and protected methods.
-There are embedded doc tools (Ruby’s is called RDoc).
The docs generated by rdoc look very similar to those generated by javadoc.
-You don’t need to compile your code. You just run it directly.
-There are different GUI toolkits. Ruby users can try WxRuby, FXRuby,Ruby-GNOME2, or the bundled-in Ruby Tk for example.
-You use the end keyword after defining things like classes, instead of having to put braces around blocks of code.
-You have require instead of import.
-All member variables are private. From the outside, you access everything via methods.
-Parentheses in method calls are usually optional and often omitted.
-Everything is an object, including numbers like 2 and 3.14159.
-There’s no static type checking.
-Variable names are just labels. They don’t have a type associated with them.
-There are no type declarations. You just assign to new variable names as-needed and they just “spring up” (i.e. a = [1,2,3] rather than int[] a = {1,2,3};).
-There’s no casting. Just call the methods. Your unit tests should tell you before you even run the code if you’re going to see an exception.
-It’s foo = Foo.new( "hi") instead of Foo foo = new Foo( "hi" ).
-The constructor is always named “initialize” instead of the name of the class.
-You have “mixin’s” instead of interfaces.
-YAML tends to be favored over XML.
-It’s nil instead of null. == and equals() are handled differently in Ruby. Use == when you want to test equivalence in Ruby (equals() is Java). Use equal?() when you want to know if two objects are the same (== in Java).

JRuby:
- Java implementation of Ruby
- Runs on JVM
http://jruby.codehaus.org/Getting+Started

Eclipse Plugin
- Ruby Development Tool - RDT
http://rubyeclipse.sourceforge.net/download.rdt.html
http://www.ibm.com/developerworks/opensource/library/os-rubyeclipse/


Web Development:
- Ruby on Rails is a framework facilitates web applications development using Ruby.

Who uses Ruby?
- Not for generic enterprise applications- so no bigges use this now!
- Startups/companies with specific system powerful requirements[search etc] can use this
-

Job Market/Opportunities
- Competes with php,python,perl market
- Currently certainly not a replacement for Java/.Net for web development

Refer:
http://www.ruby-lang.org

Heart Of Change!

This long weekend [Nov 22-25,2007] had a great opportunity to read [completed:-)] - The Heart of Change by John P. Kotter - [Harvard Biz School prof]. Infact, the book, lying on my manager's desk got my attention at a last minute on eve of long weekend when we were about to leave the office.

Atleast one minimum guarantee of reading management books is - just a feel of optimism -

How "change" (anything,anywhere,anytime) can successfully happen?

1. Increase urgency
2. Build the guiding team
3. Get the vision right
4. Communicate for commitment
5. Empower Action
6. Create Short Term wins
7. Don't Let up
8. Make Change stick

Step 1 -- Increase Urgency
Raising a feeling of urgency is the first and most critical step in a successful change effort. Reports and spreadsheets are not enough, you need to demonstrate actions that shock people into understanding the need for change. An example from the book was a supply chain project where the group leader collected all of the 424 different types of rubber gloves that the company regularly purchased and marked their various prices. They were then prominently displayed throughout the company. This created a buzz and had people saying, "We must do something!"


Core Challenge: Get people out of the bunker and ready to move.

What Works: Create dramatic presentations with compelling objects that people can actually see, touch, and feel; provide evidence from outside the organization that change is required; find cheap and easy ways to reduce complacency

Example: Show employees a videotape of an angry customer rather than handing out a two-page memo filled with negative "customer data"

Desired New Behavior: People start telling each other, "Let's go, we need to change things!"

Step 2 -- Build the Guiding Team
In the past, change was smaller in size and moved slowly. Today, a single individual cannot effectively handle large scale, fast-paced change alone. Step 2 explains how every good change initiative needs a group of influential, effective leaders. It is important to get the right people in place who are fully committed to the change initiative, well-respected within the organization, and have power and influence to drive the change effort at their levels.


Core Challenge: Get the right people in place with the trust, emotional commitment, and teamwork to guide a very difficult change process

What Works: Attract key change leaders by showing enthusiasm and commitment; model the trust and teamwork needed in the group; structure meeting formats that minimize frustration and increase trust

Example: Draft a large, diverse team made up of individuals at all levels and with different skills-rather than bowing to political pressures to leave the task of change in the hands of a small, like-minded "executive group"

Desired New Behavior: A group powerful enough to guide a big change is formed and they start to work together well.

Step 3 -- Get the Vision Right
Urgency is up and leaders are ready to lead…but in what direction? People often have the mistaken perception that a vision is not related to business realities, and is a waste of time. While creating a shared need and urgency for change may push people into action, it is the vision that will steer them into the new direction. Step 3 is all about demonstrating how to provide a relevant vision, and making it work for your change effort.


Core Challenge: Get the guiding team to create the right vision and strategies to guide action in all of the remaining stages of change. This requires moving beyond number-crunching to address the creative and emotional components of vision.

What Works: Literally seeing/visualizing possible futures; visions that are moving; visions that are so clear they can be articulated in one minute or written up on one page; bold strategies that can be executed quickly enough to make the vision a reality.

Example: Marshal people around a compelling service vision that can only be realized by drastically streamlining costs-rather than delivering emotionally depressing and anxiety-producing mandates about slashing expenses.

Desired New Behavior: The guiding team develops the right vision and strategy for the change effort.

Step 4 -- Communicate for Buy-In
It has been said before -- communicate, communicate, communicate! Step 4 is all about communication. Once a vision and strategy have been developed, they must be communicated to the organization in order to gain understanding and buy-in. Sending clear, credible, and heartfelt messages about the direction of change establishes genuine gut-level buy-in, which sets the stage for the following step: getting people to act. This step should be revisited throughout the change effort.


Core Challenge: Get as many people as possible acting to make the vision a reality.

What Works: Keep communication simple and heartfelt; find out what people are really feeling and speak to anxieties, confusion, anger and distrust; rid communication channels of junk so important messages can get through; use new technologies to help people see the vision

Example: Create tools that help people tailor information to their specific needs-rather than forcing more generic memos and reports into over-stuffed email and in-boxes

Desired New Behavior: People begin to buy into the change, and this shows in their behavior.

Step 5 -- Empower Action
Step 5 is all about empowering a broad base of people to take action. Rather than viewing empowerment as handing out power, it should be seen as removing barriers to those whom we want to assist in pushing the change effort. This removing of obstacles should inspire, promote optimism and build confidence around the change effort. Change is not just about the motive, but also the opportunities to achieve change.


Core Challenge: Remove key obstacles that stop people from acting on the vision.

What Works: Bring in experienced change leaders to bolster confidence that the job can be done; create recognition and reward systems that inspire, promote, optimism, and build self-confidence; give constructive feedback; help disempowering managers to powerfully experience the need for change.

Example: To recognize and reward excellence, stage an emotion-filled competition in Hawaii rather than a dry, cerebral event in a New York conference room.

Desired New Behavior: More people feel able to act, and do act, on the vision.

Step 6 -- Create Short-Term Wins

Short-term wins nourish faith in the change effort, emotionally reward the hard workers, keep the critics at bay, and build momentum. Companies often tackle large-scale projects with a view to a big final payoff. Progress is communicated to stakeholders, but a disparity develops between the wins reported and the stakeholder's perception of progress, which undermines the credibility of the communication. By creating short-term wins, and being honest with feedback, progress is achieved and people are inspired.


Core Challenge: Produce enough short-term wins fast enough to energize the change helpers, enlighten the pessimists, defuse the cynics, and build momentum for the effort.

What Works: "Cheap and easy" wins that are visible, timely, unambiguous, and meaningful to others.

Example: Focus publicly on four goals instead of fifty-and make sure no new initiatives are added until one of those goals is achieved and celebrated.

Desired New Behavior: Momentum builds as people try to fulfill the vision, while fewer and fewer resist change.

Step 7 -- Don't Let Up

Don't let up! You're not done until the change has been entrenched in the very fiber of the organization. You need to make wave after wave of change until the vision is a reality. In successful efforts, people build on this momentum to make the vision a reality by keeping urgency up, and a feeling of false pride down; by eliminating unnecessary, exhausting work and by not declaring victory prematurely.


Core Challenge: Continue with wave after wave of change, not stopping until the vision is a reality-no matter how big the obstacles.

What Works: Eliminate or delegate non-priority work; show people powerful reasons to keep urgency up; use new situations opportunistically to launch the next wave of change

Example: Replace a time-consuming and painstakingly detailed monthly activity report with a one-page summary that highlights only major milestones and key financial metrics

Desired New Behavior: People remain energized and motivated to push change forward until the vision is fulfilled.

Step 8 -- Make Change Stick
Now you feel as if you're at the end of the change process. The urgency was there, the vision was met, the short-term wins celebrated and the changes consolidated…now what? Frequently, leaps into the future slide back into the past when the new behavior does not become tradition, the typical way 'things get done around here.' By creating a new, supportive, and sufficiently strong organizational culture, the change should remain. A supportive culture provides roots for the new ways of operating.


Core Challenge: Create a supporting structure that provides roots for the new ways of operating.

What Works: Refuse to declare victory too soon; use new employee orientation, the promotions process, and vivid stories to visibly and compellingly reinforce the vision.

Example: When introducing new hires to the organization, use videos that contain heartfelt messages from customers whose lives the company has changed and touched-rather than the usual dry speeches and boring handbooks

Desired New Behavior: New and winning behavior continues despite the pull of tradition, turnover of change leaders, etc.

Refer:
http://www.theheartofchange.com/home.html

Object Immutability

- Do not provide public setters
- java.util.Collections.unmodifiableCollection(c)

Unix HowTo

To Keep commonly used unix commands ..

1.extract-tar-files-to-stdout

tar -xOf freedb-complete-20040908.tar|grep DTITLE|less

2.To Send mail with attachment

Only mail:
mailx -s[Subject] to_address [space seperated] -f[from address]

Then type in messages and when finished - enter EOF - [Ctrl+d]

For attachments:
You can encode the source file which can piped to mailx
uuencode sourceFile outputFile

E.g
uuencode attach.txt attach.txt| mailx -s "mail from unix" e026784@mc.com

---

How to get Host name/ machine implementation
uname -a # to get host name,implementation, release etc
hostname # equivalent to uname -n; just gives the hostname

Java Pointers

We know object references are implemented via pointers,then why we don't have access of pointers in java...


There are many reasons, but the two big ones are probably....

Security:
You can't implementment the security model needed for applets. Or even needed in a shared model used in application servers, if an application can do pointer arithmetic to access portions of memory that they are not allowed to touch.

Garbage Collection.
It would be impossible to detect whether something has been dereferenced, if the program can convert a pointer to an integer, so that it can calculate the reference later.


Since References are pointers, the JVM uses pointers and developers have access to them and can do pointer arithmatic on them.

TinyURL

Make ur long url references with shorter link which redirects to actual url.

Example

The following URL:

http://nambi-adhimoolam.blogspot.com/

has a length of 37 characters and resulted in the following TinyURL which has a length of 25 characters:
http://tinyurl.com/2zu38k


It never expires....

Javascript - call() and apply()

In JavaScript 1.2 you could construct an object only within a single method. JavaScript 1.3 extends object construction to any number of methods.Object being built consecutively by two different methods is a real advantage.

The call() and apply() methods helps in multi-method object construction.

The apply() method lets you pass the parameters from one method to the other whereasthe call() method requires the full list of parameters.



outer = function(a){
this.player=a;

this.kick = function(){
alert('This is outer:'+this.player);
inner.call(this,this.player);
};
};

inner = function(b){
alert('This is inner:'+b);
ininner.apply(this,arguments);
};

ininner = function (c){
alert('This is inner of inner:'+c);
};
var outin=new outer('B');
outin.kick();




Output
This is outer:B
This is inner:B
This is inner of inner:B

Reference:

Learn, implement and share

http://www.webreference.com/js/column26/call.html

JMS - Ideal SOA !

JMS - Java Messaging service First published in 1998 and current version 1.1 in April 2002

Its is an asynchronous communication between software components/applications

Sender sends to/receives the messages from messaging client. hence NO need to know about the other side of the communicator - who is receiving/sending.

It enables loosely coupled distributed communication

Ensures 100% reliability - Message is delivered to the client[acknowledgement] only once [accuracy]

Platform independent interface for Existing - Message Oriented Middleware System [MOM] like MQSeries from IBM.

It can be implemented through -EJB - Message driven beans, web components , application clients ....Or infact through simple POJOs.

Supports Distributed Transactions and allows concurrent consumption of messages as per EJB 3.0 specification

Through Java EE Connector Architecture [Resource Adapters - rsadapter], multiple JMS providers can be integrated with single Java EE application server.

Architecture:

A JMS application is composed of the following parts.

■ A JMS provider is a messaging system that implements the JMS interfaces and provides
administrative and control features. An implementation of the Java EE platform includes a
JMS provider.

■ JMS clients are the programs or components, written in the Java programming language,
that produce and consume messages. Any Java EE application component can act as a JMS
client.

■ Messages are the objects that communicate information between JMS clients.

■ Administered objects are preconfigured JMS objects created by an administrator for the use
of clients. The two kinds of JMS administered objects are destinations and connection factories. Administrative tools allow you to bind destinations and connection factories into a JNDI namespace. A JMS client can then use resource injection to access the administered objects in the namespace and then establish a logical connection to the same objects through the JMS provider.

Admin Tool ---- Bind -->JNDI Namespace [Connection Factory & Destination]----inject Resouce---> JMS Client

JMS Client ---- Logical Connection ---> JMS Provider

Messaging Domains

Point to Point [PTP] - Messaging Domain[Queue]

A point-to-point (PTP) product or application is built on the concept of message queues,
senders, and receivers. Each message is addressed to a specific queue, and receiving clients
extract messages from the queues established to hold their messages. Queues retain all messages sent to them until the messages are consumed or until the messages expire.

Each message has only one consumer.
■ A sender and a receiver of a message have no timing dependencies. The receiver can fetch
the message whether or not it was running when the client sent the message.
■ The receiver acknowledges the successful processing of a message.
Use PTP messaging when every message you send must be processed successfully by one
consumer.

Client A --Msg-->Queue <--->Consumes & Acknowledges <--->Client B

Publish/Subscribe Messaging Domain [Topic]

In a publish/subscribe (pub/sub) product or application, clients address messages to a topic,
which functions somewhat like a bulletin board. Publishers and subscribers are generally
anonymous and can dynamically publish or subscribe to the content hierarchy. The system
takes care of distributing the messages arriving from a topic’s multiple publishers to its multiple
subscribers. Topics retain messages only as long as it takes to distribute them to current
subscribers.

Pub/sub messaging has the following characteristics.
■ Each message can have multiple consumers.
■ Publishers and subscribers have a timing dependency. A client that subscribes to a topic can
consume only messages published after the client has created a subscription, and the
subscriber must continue to be active in order for it to consume messages.

The JMS API relaxes this timing dependency to some extent by allowing subscribers to create
durable subscriptions, which receive messages sent while the subscribers are not active. Durable subscriptions provide the flexibility and reliability of queues but still allow clients to send messages to many recipients. Use pub/sub messaging when each message can be processed by zero, one, or many consumers.

Client A --->Publishers -->Topic <----- Subscribers A , B, C etc


JMS API Programming Model

1. Admininistered Objects
Destination and Connection Factories are maintained by JMS Provider.

These objects can be located through JNDI

@Resource(mappedName="jms/ConnectionFactory")
private static ConnectionFactory connectionFactory;

@Resource(mappedName="jms/Queue")
private static Queue queue;

@Resource(mappedName="jms/Topic")
private static Topic topic;

2.Connections

A connection encapsulates a virtual connection with a JMS provider. A connection could
represent an open TCP/IP socket between a client and a provider service daemon. You use a
connection to create one or more sessions.


Connection connection = connectionFactory.createConnection();

3.Sessions

Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
A session is a single-threaded context for producing and consuming messages. You use sessions
to create the following:
■ Message producers -created by a session and used for sending messages to adestination

MessageProducer producer = session.createProducer(dest);
producer.send(message);

■ Message consumers - created by a session and used for receiving messages sent
to a destination

MessageConsumer consumer = session.createConsumer(dest);
connection.start();
Message m = consumer.receive();

■ JMS Message Listener

A message listener is an object that acts as an asynchronous event handler for messages. Thisobject implements the MessageListener interface, which contains one method, onMessage. Inthe onMessage method, you define the actions to be taken when a message arrives.You register the message listener with a specific MessageConsumer by using thesetMessageListener method. For example, if you define a class named Listener thatimplements the MessageListener interface, you can register the message listener as follows:

Listener myListener = new Listener();
consumer.setMessageListener(myListener);

After you register the message listener, you call the start method on the Connection to beginmessage delivery

■ Messages
Message has three parts - Message Headers, Message Properties and Message Bodies

Headers contains number of predefined fields that contain values that both clients and providers use to identify and to route messages like JMSMessagID, JMSDestination, JMSPriority etc

Message Properties are used to provide compatibility with other messaging systems.

Following message body formats are defined

Text Message -String message
MapMessage - A set of name value pairs with names as String and value as primitive
BytesMessage - a stream of uninterpreted bytes
StreamMessage- Primitives processed sequentially
ObjectMessage - Java Serialized object
Message - Message with just header and properties

Ex :
Sender

TextMessage message = session.createTextMessage();
message.setText(msg_text); // msg_text is a String
producer.send(message);

Receiver:

Message m = consumer.receive();
if (m instanceof TextMessage) {
TextMessage message = (TextMessage) m;
System.out.println("Reading message: " + message.getText());
} else {
// Handle error
}


8.JMS Message Selectors
To filter the messages
9.JMS Queue Browsers
To browse queue to chk specific message
10.JMS Exception
Root level checked exception JMSException

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

JBoss - Seam

What is JBoss Seam

EJB 3.0 and JSF are perhaps the most exciting new developments in the Java EE 5 platform. Seam is an innovative new application framework that integrates the EJB 3.0 component model with JSF as a presentation tier. Seam builds upon the standard extension points provided by both specifications and provides a set of Java annotations that extends the standard annotations defined by the EJB specification. In addition, Seam introduces several innovative new ideas: managed conversations, declarative and contextual application state management, bijection and integrated business process management.

Traditional web applications are incredibly vulnerable to bugs and performance problems relating to state management. Developers are forced to handle issues like back button navigation, multi-window browsing, session size management in an utterly ad-hoc fashion. Access to transactional components from the web tier has also been problematic. J2EE provided no way to have simultaneous access to state held in contexts associated with the web request, and state held in transactional resources accessed via EJB. Finally, J2EE had no first-class construct for representing state associated with a long-running business process. Seam tackles all these problems, and provides a uniform model for stateful components in Java EE 5.
Like all JBoss software, this entire software stack is free. The full source code of this sample application is available in the examples/booking directory of the Seam distribution. There is even a 10-minute flash demo showing how to build a Seam web application from ground up.


The first application framework for EJB 3.0

EJB 3.0 has changed the notion of EJB components as coarse-grained, heavy-weight objects to EJBs as lightweight POJOs with fine-grained annotations. In Seam, any class may be an EJB - Seam eliminates the distinction between presentation tier components and business logic components and brings a uniform component model to the EE platform.

Backward compatible with J2EE

But Seam is not limited to environments that support EJB 3.0. Seam may be used in any J2EE environment, or even in plain Tomcat.

The easy way to do AJAX

Seam 1.1 integrates open source JSF-based AJAX solutions like ICEfaces and Ajax4JSF with Seam's unique state and concurrency management engine. You can add AJAX to your applications with ease, without the need to learn JavaScript, and you will be protected from potential bugs and performance problems associated with the switch to AJAX.

A revolutionary approach to state management

Before Seam, the HTTP session was the only way to manage Web application state. Seam provides multiple stateful contexts of different granularity from the conversation scope to the business process scope, liberating developers from the limitation of HTTP sessions. For example, developers can write Web applications with multiple workspaces that behave like a multi-window rich client.

Manage "flow"

Seam integrates transparent business process management via JBoss jBPM, making it easier than ever to model, implement and optimize complex collaborations (workflow) and complex user interactions (pageflow).

Easy integration testing

Seam components, being POJOs, are by nature unit testable. But for complex applications, unit testing alone is insufficient. Therefore, Seam provides for easy testability of Seam applications as a core feature of the framework. You can write JUnit or TestNG tests that reproduce a whole interaction with a user, exercising all components of the system, and run them inside your IDE.

References
http://www.jboss.com/products/seam

http://www.oreillynet.com/onjava/blog/2007/10/after_struts_what.html

http://labs.jboss.com/jbossseam/gettingstarted

JavaFx - New RIA[Rich Interactive Applications] for content Driven web!

The JavaFX Script programming language (hereinafter referred to as JavaFX) is a declarative, statically typed scripting language from Sun Microsystems, Inc. As mentioned on the Open JavaFX (OpenJFX) web site, JavaFX technology has a wealth of features, including the ability to make direct calls to Java technology APIs. Because JavaFX Script is statically typed, it also has the same code structuring, reuse, and encapsulation features -- such as packages, classes, inheritance, and separate compilation and deployment units -- that make it possible for your to create and maintain very large programs using Java technology.

Open Source
https://openjfx.dev.java.net/

- The JavaFX Pad Application
- References
http://java.sun.com/developer/technicalArticles/scripting/javafxpart1/

More from experts:

JavaFX Script, is an open-source scripting language designed to facilitate rapid content authoring. JavaFX Script provides a highly-expressive syntax for declarative construction of 2D graphics and dynamic user interfaces. Although JavaFX Script is statically typed, the language is heavily inspired by popular dynamic programming languages like Python and incorporates compelling syntactic features like support for list comprehensions and first-class functions.
JavaFX isn't a completely independent runtime; it is essentially designed as a layer that sits on top of Java in order to make Java better-suited for rich application development. There are advantages and disadvantages to this approach. Sun clearly went to great lengths to make sure that JavaFX uses as much existing Java infrastructure as possible in order to simplify the process of integration. As a result, JavaFX feels like a very natural extension of the Java ecosystem. Developers can use Java libraries directly in JavaFX Script, and the language's declarative syntax for interface development is tightly bound to Swing and Java2D. The downside is that JavaFX Script doesn't really give developers the ability to do much they couldn't do already, its function is primarily to make existing Java technologies easier to use together.

As a result of JavaFX's dependence on existing Java technologies, developers with Java expertise will find that their existing skills easily translate over to JavaFX development. The broad availability of existing libraries for Java also ensures that a lot of useful functionality is available in JavaFX right out of the box. Additionally, since JavaFX runs on top of the JRE, it is highly portable and can target a wide variety of platforms.

Although JavaFX has a lot of potential, the technology also has a lot of weaknesses. JavaFX Script fixes many of Java's most frustrating syntactic deficiencies, but at the present time, very few convenience mechanisms are provided to support the kind of functionality currently required by modern interactive web applications. In particular, I think that JavaFX Script really needs some heavy syntactic sugar for consuming and manipulating remote XML and JSON content. One thing it does seem to handle relatively well, however, is integration of embedded HTML for application styling and content.

Wait and see how it progresses.......................

SOA - Only XML ?

XML Services: A Brief Synopsis

•XML documents: Rendering a request or response as an XML document tends to be both CPU and memory intensive
•Networking: Passing textually-encoded XML documents is a poor use of bandwidth
•Connection Management: Connectionless HTTP is far more expensive than a socket
•Parsing: Validation and parsing of XML documents is extremely CPU intensive
•Summary: Big money, high latency


Appropriate Uses

•Exposing Platform-Independent Services
–XML-based services are the one thing that Java and Microsoft .NET can agree on
•Loose Coupling
–The service provider and the service consumer can be completely unknown to each other
•Public Network Capable
–Securable at the low level (e.g. HTTPS) and the high level (document signing, encryption, etc.)
•Defensible Uses
–Among separate applications
–Among different organizations

Other Options

XML-based SOA has appropriate uses
•SOA and its underlying principles do not require SOAP, XML, HTTP, etc.
•Java has a rich set of built-in capabilities for supporting SOA withinan application, such as:
–JMS –Message bus-based SOA
–RMI –Synchronous Java-centric remote invocation
•When the internal (Java) and external (XML) service interfaces are identical, then layer the XML-based interfaces on top ofthe higher-performing and more efficient Java API, and use the Java API within the app

Choose appropos Data Access!

Popular Methods for Data Access

•JDBC API –a CLI view of RDBMS data
•Apache iBATIS–simplifying common JDBC usage patterns
•EJB v1, v2 –a "record oriented"approach
•Object Relational Mapping (ORM)
–Hibernate, Castor
–JDO v2 (Including KODO, OpenAccess)
–EJB v3 (Including Hibernate, Toplink, KODO)

Data Access: JDBC

•The "assembly language"of RDBMS –you can do anything, but you have to do everything
•Best choice when the form of the data being accessed is unknown, such as in a reporting engine in which the number and types of result columns are unknown
•Good choice for dealing with extremely large result sets and accessing rarely-used driver functionality
•Worst choice for rapid application development
•Worst choice for large engineering teams and large code bases
•Worst choice for building maintainable applications


Data Access: ORM

•The "object oriented"model for RDBMS –you only deal with objects, but the ORM has to deal with the RDBMS
•Best choice when the form of the data being accessed is well known, and the wide-spread use of the data throughout the application logic far exceeds the investment in defining the object schema and its mapping to the database
•Good choice for enabling data caching
•Definitely nota silver bullet
–Still requires good development processes and careful design
–Using ORM, some common application use cases are very inefficient compared to hand-coded JDBC


Why the Choice is so Critical

•I have witnessed more applications fail to meet their business goals due to poor choices around data access than any other category
•Once a choice is made, it tends to be reflected in every aspect of the application, making later changes more difficult and incredibly costly
•The predictability and cost of scalability of a large-scale application is tightly bound to the application’s data access model


Choosing a Data Access Model

•Understand the high-level requirements
–The "-ilities": Scalability, Reliability, Availability, …
•Visualize the data flows in the running system
–For each page or service request, what actually goes through to the database, and why?
•Understand the impact of concurrent users
–How will database contention be minimized?
–How will cache effectiveness be maximized?
•Understand the application’s data granularity
–Set-centric or identity-centric?

Java EE 5 - First Look!

Java 1.5 version is called Java 5 and its no more J2EE 1.5 instead Java Enterprise Edition 5

1. XML deployment descriptors can be java-coded using annotations. Spring already provides this feature as bean configurations can also be java-coded as well.

2.Dependency Injection can be used in all levels - EJB container,Web container and application clients

3.Java Persistence API - can be used either in Java EE or Java SE applications .This replaces Entity Beans from EJB 3.0 [Java EE 5 ]

4.Java Server Faces - GUI Component Framework[since 1.4]

Everything is considered under Service Oriented Architecture - SOA

• Synchronous Services - EJB[remote/local] - session/entity or Spring Remote/local, Web Services
• Asynchronous Services - Java Messaging Service [Topic/Queue]
  

Inversion of Control-Don't call me;I'll call you!

We all know the benefits of interfaces.

Programming to interfaces is a new way of Enterprise architecture for multi-layered, test driven, loosely coupled systems.

Service oriented Architecture - [SOA]

There are various ways of inversioning the control.The leightweight containers try to invert "hard-wire" coupling of interface-concreate implementation to "configurable" injection so that the "atomic" independent services are developed that can be used without knowing the actual implementation details. The service client can just concentrate on the Service API for their usage.

This kind of "IoC" is also called "Dependency Injection".

Following are the Java Community Dependency injection methods
1.Constructors injection
- Pica Container, Spring
2.Setter Injection
- Spring
3.Interface Injection
- Avlon

Spring - Setter Injection : Dependency Injection

This is the most widely used IOC methodology adopted by Spring and supported by various other IoC frameworks

The injections can be java-coded or XML configured as bean definitions.

Singleton/Non-Singleton beans are created and managed by Spring Framework.

Detailed code example on the way.....

Refer for more details : http://martinfowler.com/articles/injection.html

How to design correct validation module for your J2EE application?

Validation is an important aspect of any J2EE applications.Several approaches are currently used in different layers.In most of the applications, the validation is commonly kept at Presentation tier-both at server side (struts validator) as well client side(java script). And few places the logic is embedded with business tier - for SOA systems.

There is strong argument that validation,especially user inputs validations are not core business logic and they should NOT be coupled with business tier. Also keeping them at inner layers results in performance bottleneck.This sounds good especially if business tieris going to serve only web interface. However in current business scenario, service layer should be built robustly so that in future it can be used to serve multiple clients - web services, web interface, any batch processes etc

This also leads to Domain Driven validation - Validation at Service/Domain layer.
The first thought on keeping the validation at domain layer is that - Domain object should be always "VALID". Hence it cannot contain any invalid data and validate itself. This is self contradictory.

This pretty much leaves us a single option - Validation @ Service Tier

Okay...what are the approaches? Any patterns

Consider an example.An admin functionality to Add/Edit/Delete and View User Details.The application has following layers

• Web MVC - Struts - UserAction (Struts Action) and UserForm (Struts Form)
• Service & Data Access - Spring - UserDTO (POJO for data transfer),UserService (Service), UserManager(DAO) and Domain object User

On high level, there are two level of validations for this Domain Object

1. Field Level Validations- UserName(content,length),Password(content,length,combinations),Email,FirstName,LastName,Status
2. Object Level Validations - Mandatory fields,Specific combinations (User can only be added in Active status etc)

We need to devise different sets of validation as below

• validateSearch - Only Field level validations. ie, all input fields (whatever entered) should be alphanumeric,email should be valid.If any of the fields are invalid add warning message and carry forward the search.
• validateAdd - Field level and object level validations
• validateUpdate - Field level and object level validations

---

Solution 1

Summary:

• Inject Dynamic Proxy validation service layer for exisiting service calls-On successful validation, the actual service methods will be called
• Custom Validation classes specific to Domain objects can be created and injected in Spring application context
• Need to explore how to collect validation errors.

Advantages

• Pure Spring way
• Declarative and validation implementation can be changed anytime without affecting any structure
• Scalability & Robustness
• Code-Reusability

Disadvantages

• Performance issue to make dynamic proxy calls
• Already Service calls are routed as dynamic proxies for Transaction Management and this will add additional layer
• Over kill for more of user input validations?! [w.r.to LCN application nature]

---

Solution 2

Summary:

• Define Validator classes that implements Spring Framework Validator interface, specific to domain objects
• Invoke validate() method with specific validation type[SEARCH,INSERT,UPDATE] on corresponding Service methods;
• Use Data Binder and MessageCodesResolver to retrieve the ErrorMessages
• Devise mechanism to automatically map the Spring Error Messages to Struts ActionErrors

Advantages

• Utilization of Spring infrastructure and possible extention

Disadvantages

• Framework dependent.
• Framework is rudimentary and need to define lot of custom methods for our application

---

Solution 3

Summary:

• Define custom Validator class containing validate() method for each domain object at service layer
• Invoke validate() method with specific validation type[SEARCH,INSERT,UPDATE] on corresponding Service methods;
• Consolidate validation errors on ServiceMessage object which can be saved to struts specific ActionErrors
• Code Reusage can be acheived by having utility methods like EmailValidator, NumericValidator,AlphaNeumericValidator etc

 UserAction.java - Struts Action
 class UserAction extends Action{
   ActionForward searchUser(){
     UserForm uform=(UserForm)form; 
     UserDTO dto=new UserDTO(); 
     BeanUtils.copy(uform,dto); 
     UserService userSvc=getUserService();  dto=userSvc.findUser(dto);
   } 
  ActionForward addUser(){
      UserForm uform=(UserForm)form; 
      UserDTO dto=new UserDTO(); 
      BeanUtils.copy(uform,dto); 
      UserService userSvc=getUserService(); 
    ServiceMessage svcMsg=userSvc.addUser(dto);
  if(svcMsg.getErrorMessage().size()>0){  
      ActionMessages errors=new ActionMessages()  
     //Copy the keys to actione messages  
      copyErrors(svcMgs.getErrorMessage(),errors);  
    //All set. Now the JSP html:errors will print the Error Messages defined in ApplicationResource.properties  
      saveErrors(request,errors)     }
 }
 }
UserService.java - Service Interface
 class UserService{
 UserDTO findUser(UserDTO dto){
     UserValidator validator=new UserValidator(); 
     validator.setValidationType(ValidationConstants.SEARCH); 
     boolean isValid=validator.validate(dto);   
     if(isValid){  
       UserManager manager=new UserManager();  
       dto=manager.findUsers(dto); 
     }else{  
     validator.getErrorMessages();
  }
 return dto;
}

ServiceMessages addUser(UserDTO dto){
  UserValidator validator=new UserValidator(); 
  validator.setValidationType(ValidationConstants.INSERT); 
  boolean isValid=validator.validate(dto);   
 if(isValid){  
    UserManager manager=new UserManager();  
    manager.addUsers(dto); 
}else{  
  ServiceMessages svcMsg=validator.getErrorMessages();
  }
 return svcMsg; }
 }
UserValidator.java
class UserValidator implements Validator{
     String validationType;
     ServiceMessage serviceMessage
    
    boolean validate(UserDTO dto){
        boolean isValid=false;
     if(getValidationType().equals(ValidationConstants.INSERT)){ 
       if(StringUtils.isEmpty(dto.getUserName()){  
        serviceMessage.add(Type.ERROR,"username.empty"); 
     } }
       return isValid;}
}
ServiceMessage.java
class ServiceMessage {
List errorMessage;List warningMessage;

void add(String type,String key){
       if(type.equals(Type.ERROR){ 
          errorMessages.add(key);
      }else if(type.equals(Type.WARNING){ 
         warningMessage.add(key);
     }
}
}

Advantages

• Service Layer to offer centralized validation irrespective of the client
• Independent of any frameworks
• Code-Reusability

Disadvantages

• Kind of - Re-inventing wheel
• Possible Performance impact-as Service calls are coslier than just Web tier calls.

Nava-Why Strings are Immutable?

In Java, String object is defined as immutable...meaning it cannot be changed, everytime you change the object [concatenate,replace etc], VM actually creates a new string object and update the references if required

[code]
String x="Nava";
x=x+" World";
S.O.P(x); // Nava World
/* Here actually three String objects are created--"Nava", "World" and "Nava World" and x is refrenced to third object, whereas other two String objects do not have any references which can be considered as "Lost" */
[/code]

I used to wonder, why such a concept "immutability" used in Java for String object.....and finally got elucidated.

Strings are the most commonly used objects in any programming languages, especially in Java. In terms of memory usage, they are on the top most place.

JVM designers well considered this aspect and constructed a special area of memory called the "String constant pool". When the compiler encounters a String literal, it checks the pool to see if an identical String already exists. If a match is found, the reference to the new literal is directed to the existing String, and no new String literal object is created.The existing String simply has an additional reference.

Ah! I hear how you appreciate.. why making String objects immutable is such a good idea.If several reference variables refer to the same String,without even knowing it, it would be bad if any of them could change the String's value.

Cool..but what if one overides the String Object? ..well String is a FINAL class :-)