ITIS Consultants

JUMP - Joint Up Means Payback

2011-03-10T02:04:00.000-08:00

Yesterday I attended the joint meeting of British Computer Society and Chartered Institute of Management Accountants at the premises of BCS in London. The agenda was to review what business-IT alignment and business intelligence means from the perspective of these two organisations.

IT is a world with a bewildering array of technologies - Java, .net, c++, sql, ITIL, CMS, databases, Joomla!, XML, CSS, HTML, PHP, TCP/IP, SMTP, HTTP, Unix, Firefox, agile, SCRUM and one can go on. To harness these successfully for business has been the dream for last twenty-five years. In fact, I cannot remember a single year over the last two decades when one or other management consultancy did not emerge with a framework for successfully aligning IT with business. Historically, many organisations have moved their IT personnel into business departments or encouraged their IT people to acquire CIMA/MBA qualification to bridge the chasm between these two worlds. Yet it was sobering to discover that business perceptions remains that these two world are far apart and bridging them is still a burning issue. A framework was presented to bridge this divide by Dr James Bacon based upon system-thinking and Genuine Action Learning. The claim was that joint-up thinking leads to dramatic increase in profitability (JUMP).

Also I remember that in the early 90s the BI systems were called Executive Information Systems (EIS). In the mid-90s I remember dubbing EIS as Everybody's Information System as the technology was becoming ubiquitous and affordable for lower tiers in the organisation. Interestingly CIMA sees this shift now and believes that analytical processing will move from the hands of accountants to become more pervasive. This redefines the role to become more focused on planning and control rather than analysis.

The moral of the story is that we are still grappling with old problems and trying to find better solutions to them.

Mobile Joomla and TERAWURFL database

2011-02-18T10:02:00.000-08:00

Mobile Joomla! is a great extension for making your Joomla site ready for mobile viewing but it adds in a 40M worth of tables into Joomla database. This potentially causes difficulty in database backup and recovery. So here are the steps to put all the terawurfl tables in a separate database.

1) Go into phpmyadmin and copy you Joomla database as terawurfl.

2) Go into information_schema database and run the query

select concat("drop table ",table_name,";") from tables where substr(table_name,1,4) = 'jos_' and
substr(table_name,1,13) != 'Jos_terawurfl';

Note: I am assuming you are running Joomla database with prefix 'jos_', if not then change the above accordingly

3) Copy all the drop statements into clipboard.

4) Go into terawurl database and run SQL with statements copied from the clipboard. At this stage you have a database with just the terawurfl tables.

5) Now go back to information_schema database and run the query

select concat("drop table ",table_name,";") from tables where substr(table_name,1,13) = 'Jos_terawurfl';

6) Copy the drop statements to clipboard.

7) Now go to your Joomla database and run the SQL with statements copied from the clipboard. At this stage you have a database with just the joomla tables.

The above process would have taken out the terawurfl tables and put them in a separate database.

Now go and set database name, user and pass in plugins/mobile/terawurfl.php, They are currently picked up from the configuration.php You probably will just have to change the line to set schema to terarwurfl as the user and password would still be valid as we follow the above procedure.

TeraWurflConfig::DB_SCHEMA = "terawurfl";

Now you can backup your dynamically changing Joomla database more frequently without having the overhead of copying terawurfl tables as well. Also the database recovery time for Joomla tables will be lower too.

Mobile Development and Joomla

2011-02-17T03:27:00.000-08:00

Here is to get you going with getting your Joomla site ready for iPhone on your local PC. We start with the assumption that WAMP has already been installed, along with Joomla.

First download the Mobile Joomla extension from here. You have to register but it is free. The extension provides the support for carrying out mobile development. It is a rather big component which adds a number of templates, plugins and module positions. So once you kick-off the install it could take 30-50s to install. Just disable the 'Mobile - Always' plugin as you don't want to your site to be permanently served via mobile. It may be alright in development environment to leave this plugin enabled but in production environment you have to disable it as you are serving different types of clients.

In mobile development you always have two choices. Either you can have a different URL in a subdomain for iPhone (multi-site option) or you can use the same URL and let the mobile plugin decide which template to serve (multi-client option). We will opt for the latter but if you want the multi-site option then you will have to set it up in the Joomla Mobile settings. We can adjust the modules for iPhone or just serve the default before tinkering.

Now establish the ip address of your local PC by running ipconfig. It will be something like 192.168.1.2.
.
Go to iphonetester.com. If you were typing localhost/joomla to get into your local website then you will have to type http://192.168.1.2/joomla in the tester URL. Now you have full simulation of your site as viewed by iPhone. You can start playing with module positions and experimenting. Enjoy!

Exciting meeting of London's Joomla User Group

2011-02-16T00:23:00.000-08:00

I had the pleasure of attending my first-ever Joomla User Group meeting at University College London yesterday. The minor drizzle in the evening did not dampen the enthusiasm of the attendees who were all passionate about Joomla. It turned out to a lively session of two hours where a lot of insights were parted by the members.

We had a presentation on Joomla performance tuning which covered all the aspects from caching, compression, CSS and Javascript minification, MySql tuning and image servers. A suggestion that serving images from a different server speeds up the page download as the HTTP traffic becomes parallelized was particularly good. Also the warning that many image-bloated templates and sub-optimal extensions are the main culprit in reducing performance was welcome.

A lively discussion followed on extensions. The two most memorable ones for me were Alpha Content and Store Locator. The former provided a directory listing of articles in a category in an alphabetic manner and gave A-Z index on top to navigate easily to any content beginning with that letter. The latter gave a Google Map of Excel-loaded interest-points (they could be stores or individuals) to easily zoom in at their location or associated URL.

There were a host of other useful insights and this brief introduction does slight injustice to the meeting. I would suggest that if you are interested in Joomla then make your way to the next meeting on15th of March at 7.00pm.

Migrating to Joomla 1.6

2011-01-25T01:18:00.000-08:00

I carried out a quick test to establish the issues in migrating to Joomla1.6 on my local PC. The simple answer is that one shouldn't jump into it if one is not willing to do a considerable amount of work oneself. I used a basic site which used rhuk_milkyway template. Here are the findings:

The JUpgrade actually works quite smoothly if you are converting from Joomla 1.5.22. It successfully creates a new working environment for Joomla1.6 and preserves the 1.5 installation. Basically a new directory is created to hold 1.6 code and the MySql database gets the additional Joomla tables with j16 prefix. In ideal world it should just be required to drop the old tables and directory and point to the new installation. However the life is not that simple.

Firstly, the default templates which Joomla1.6 comes with are not production quality and rhuk_milkyway is not supported. Originally it was envisaged to include this particular template in the production release but the idea was shelved. The net effect is that various menus just disappear as one has to place them in new positions manually. Also the menu items had a value of -1 set in line Link Type Options/Link Image for various menu items. All these had to be manually set which is annoying and cumbersome.

After spending around an hour I had a functional site but it was a crude replica of the 1.5 version. I was not too fussed about extensions at this stage but obviously their availability is a critical decision in choosing to migrate. To get the site fully working I would have been forced to spend a considerable amount of time on CSS. So the bottom line is : "Don't rush in! Access control lists are great but the effort required to migrate is too much at this point in time".

Estimating project delay just from the quality of requirement specification

2011-01-15T06:28:00.000-08:00

I was privileged to attend a course by Tom Gilb recently on quality and he produced a wonderful way of estimating project delay from just the quality of its requirement specification. Those who are not familiar with Tom should know that he is the pioneer of iterative development method. His Evo methodology with emphasis on weekly deliverables and feedback was produced in the 60s, a long before Agile and Scrum appeared on the horizon. Also he can be credited with introducing software metrics in the 70s which were incorporated as Capability Maturity Model level IV. People who have grown up in quality movement are familiar with the fact that the quality is something which has to be designed within a process and cannot be gained through mere inspection. So just by checking the number of defects in a random page of the specification we can estimate the probability of project success.

A logical page of around three hundred words is inspected for deviation from the rules like testability, ambiguousness and no-design by 3-5 people. It is no good saying that a quality like usability should be dramatically improved unless we numerically quantify it. We take the figure for the highest number of major defects discovered by a team member, D. We multiply this by a factor of two to establish the discoverable defect density (source: experience). Now any inspection only captures a third of the potential defects (source: Capers Jones) so we multiply the discoverable defect density by a factor to generate potential major defects. Now the likelihood of a major defect turning into a downstream bug is one third. Each of this downstream bugs will cost 10 hours to resolve. This gives the formula for project slippage as:

Hours slippage = D * 2 * 3 * 1/3 * 10 * number of non-comment logical pages in the specification

Now this is pure magic as it has been empirically validated on a number of projects in the field. If you don't believe it then carry out the test on a project on which you have worked in the past and see whether the slippage provided by the formula is not within plus or minus 10% of the actual slippage.

PHP essentials for Java programmers

2010-05-23T02:54:00.000-07:00

I recently had to do a project in PHP and being from Java background one notices enumerable similarities. Obviously the whole knowledge about object-oriented programming and the procedural constructs like assignments, statements, conditions, loop etc are totally transferable. However the key difference I noticed was in the function calls. In Java all the arguments are passed by value, even for the objects, ie we pass the copy of the address for the object. But in PHP we are allowed to pass arguments by value or reference. Thus we have a simple function

function writeName($name) { echo $name; }

it passes the $name argument as value. However, by just prefixing $name with an ampersand we pass the argument by reference to give

function writeName(&$name) { echo $name; }

The other clever thing about PHP function is that we can return a value by reference too. Take the example from Joomla! library:

function &getLanguage()
{
static $instance;

if (!is_object($instance))
{
//get the debug configuration setting
$conf =& JFactory::getConfig();
$debug = $conf->getValue('config.debug_lang');

$instance = JFactory::_createLanguage();
$instance->setDebug($debug);
}

return $instance;
}

Preceding the getLanguage() function by an ampersand indicates that the function will return a value by reference, thus the return is a pointer to $instance.

The another line which will puzzle Java programmers above is

$conf =& JFactory::getConfig();

=& the syntax simply means that $conf is being assigned reference to the object created by getConfig() method of JFactory class. :: notation indicates that we are invoking a class method rather than an instance method. The normal Java dot notation of object.method() for invoking an instance method is changed in PHP to object->method()

Armed with the knowledge in this article a Java programmer is ready to do a PHP project. The only other thing to bear in mind is that the class constructor is defined by function __construct(). Obviously one will have to come to grips with various PHP functions but this should be no different from understanding a new Java API.

Selectors in Cascading Style Sheets

2010-04-23T01:11:00.000-07:00

The indispensable tool in every web developers portfolio is Cascading Style Sheets (CSS). Once HTML has been used to organize the contents, the presentational brilliance stems from using CSS rules. Syntactically the rules have a selector followed by a declaration containing various properties separated by semicolons:

p {color:blue; font-weight:normal;}

This simple tag selector rule colours all the contents of
tags in the HTML document. Also noted that the property-value combination is defined by separating the property from its value with a colon. Instead of p we could have used any of the html elements like h1, h2 etc. To apply the rule to a group of elements we simply use a selector with comma separated the elements. For example, if we want to override the h3, h4, h5 and h6 header elements default definition of the browser, we can just use group selector:

h3, h4, h5, h6 {color:black; font-size:1.2em;)

The commonest way of formatting content is to use the class selector in conjunction with <div> block element or <span> inline element.

.myClass {color:black; font-size:1.2em;) class selector has a period prefix. Currently it will apply to any tag which has attribute definition of class="myClass". For example, if we have the following in our document:

<p class="myClass">...</p>
<div class="myClass">...</div>

then the .myClass selector will apply the declaration formatting to both these elements. To just restrict the formatting to
element, we change the selector to p.myClass in our rule.

Along with class, id is another attribute which can be placed on most elements. Indeed, javascript uses id to get the elements. So if we have <p id="myID"> then the hash prefixed selector for this element becomes:

#myID {color:black; font-size:1.2em;)

We also have pseudo-classes and pseudo-elements available as selectors. The anchor pseudo-classes are used to invariably define link interaction with a:link, a:visited, a:hover and a:active selectors. We know that these stages happen with links. Similarly, the first line of a paragraph or a first letter of the paragraph doesn't have a tag but it is easily identifiable pseudo-element so we can have a selectors like:

p:first-letter {color: blue;font-size:1.5em;}

or

p:first-line {color: blue;font-size:1.5em;}

Similarly there are pseudo-elements after and before for auto-generated content. To prefix a paragraph with a class="intro" with 'Thought of the day!' auto-generated content, we have the selector syntax:

p.intro:before {content: "Thought of the day!" }

or to give the text after the paragraph:

p.intro:after {content: "Thought of the day!" }

To style tags within tags we have descendant selector. For example, to highlight emphasis within a paragraph we may use the selector:

h1 strong { color: red; }

Here sub-element <strong> within element <h1> is coloured red. Similarly if we wanted to select the ordered lists which are direct children of body element the syntax is body > ol for the rule. Note the angle bracket is used for the child selector. Or to get to an adjacent sibling we use the plus ('+') sign instead of the angle bracket.

We can also select on the attributes. These selectors allow us to select element which have a certain property. For example to select all the images with title attribute we will have a selector img[title]. Or to just select text boxes in a form we can have the attribute selector

input[type="text"]

There are some further refinements to these selector but the knowledge is acquired by experimentation. The aspects covered are more than adequate.

For a good source for understanding the selectors visit here.

CSS: The Missing Manual is a very useful resource which you should have in your collection.

Delight of w3schools

2010-04-14T23:53:00.000-07:00

Like countless other people I have used the tutorials at w3schools to become familiar with various technologies at different stages in my life. It is impossible to be not familiar with this site for anyone who has taken delight in learning new things. I recall learning about ASP, XPath etc on this site a number of years ago. Indeed a career in IT is impossible without constantly updating ones skill base so a comprehensive training resource is a real boon. The site invariably appears in the top searches whenever 'Ajax tutorial' or 'jquery tutorial' type terms are used in google so cannot escape the radar of any technology aficionado. For last couple of years I had been hearing good things about jquey so decided to take the plunge and become familiar with the framework yesterday. Needless to say that w3schools gave me a couple of hours of real pleasure. There tutorial seem basic but they get to the heart of the matter. Their examples were lucid and their jquery engine for practising is great. So here is a public thanks for being so useful. W3schools, you rock!

Industry vocabularies are imperative - don't create your own

2010-04-12T12:09:00.000-07:00

In many respects the advantages and disadvantages of using user-specific XML schema and industry-standard schema are akin to those stemming from using customised bespoke application compared to application packages. One offers absolute control to adapt the software to ones need whilst the other eschews the temptation of reinventing-the-wheel by accepting industry best practice as embodied in state-of-the-art package.

The vocabularies emerging from standards organisations like W3C, ebXML, RosettaNet etc are the cornerstone of e-business. They facilitate interoperability and allow the business processes to extend beyond the enterprise in a seamless fashion. Indeed, without the vocabulary of SOAP, WSDL and UDDI the web services would not be possible. However, the reason Adobe ended up creating eXtensible Metadata Platform (XMP) for adding metadata to resources like application files, content management systems, databases etc was that there was a lack of standardised metadata (Schmelzer et al, 2002, p562). This is the problem with industry-vocabulary that it takes time to evolve and then requires consensus to develop it further so can be slow. But once the vocabulary is agreed then all the trading partners can refer to a tag and know its precise meaning and definition. All the design decisions are in place and we don’t have to go about reinventing the wheel. The software specialists can start providing applications to handle a particular vocabulary with confidence. For example, the existence of XML Schema vocabulary means that many validating parsers have been written. A commercial product like BEA Weblogic conforms to RosettaNet specification for supply chain management to achieve B-to-B integration (Thuraisingham, 2002, p180).

Let us consider the particular example of image tagging. If all the images on the web had metadata tags according to a particular vocabulary then it would be easy to write programs to discover and integrate new images into existing databases. It would also be possible to validate a document against a vocabulary before any information exchange between parties. The Dublin Core metadata elements like subject, description, rights etc enable us to easily document image resources and discover them (Dublin Core Metadata Initiative, 2008). If organisations didn’t deploy these standard metadata elements then any meaningful image search would be a nightmare as the search keyword would not be contextualised.

Always resist the temptation to create your own schema and opt for the one which is publicly available. It pays off in the long run. Although it is straightforward to build up a tight relationship with a trading partner by providing everything he needs by agreeing to an internal vocabulary. We don’t have the burden of mapping our existing internal definitions to the standards. However, as the partners proliferate, the approach becomes a nightmare as customisation may be required for handling each new relationship. The cost of maintaining translations between our internal vocabulary and our partners’ vocabularies would quickly become prohibitive and unsustainable. The internal vocabulary works best when we have total control over the domain and do not need to reach out to the wider world. Tim Bray, the co-creator of XML, provides the sound advice that you shouldn’t really create your own specialist vocabulary unless you really have to.

References

Dublin Core Metadata Initiative (2008) Dublin Core Metadata Element Set, Version 1.1 [online], available from: http://dublincore.org/documents/dces/ (accessed 12 May 2010)

Schmelzer R., Vandersypen T., Bloomberg J., Siddalingaiah M., Hunting S., Qualls M.D., Houlding D., Darby C and Kennedy D. (2002) XML and Web Servicese Unleashed, Sams Publishing, USA

Thuraisingham, B. (2002) XML Databases and the Semantic Web, CRC Press, Florida

Comparison of XML data extraction mechanisms

2010-04-01T00:59:00.000-07:00

We have two distinct methods available for extracting relevant elements from an XML document and present them in a suitable new document, namely the XSL Transformation language (XSLT ) or conventional programming using Java, C++ etc..

The Extensible Style Sheet (XSL) technologies are standards defined by W3C for handling XML documents for various purposes. Just as we have cascading style sheet (CSS) for declaring the presentation of HTML tags, the XSL technologies have equivalent XSL Formatting Object Language (XSL-FO) for managing presentation of XML documents. However, XSL technologies also have XPath for navigating the nodes of XML documents and XSLT for transforming a document from one vocabulary to another or creating a subset of a document’s elements in a different document. XSLT utilises XPath as a sublanguage, especially for identifying parts of the input XML document which should be processed. Conceptually we will have our input XML document with full definition of our image metadata, an associated style sheet template with processing declarations and these jointly are processed by XSLT processor to produce a new restricted version of our output XML document with required image elements (Figure 1). The XSLT processor is a piece of software either built into browser, web or application server or a standalone application.

Figure 1. Transformation process of an XML document with XSLT

The XSL stylesheet is a well-formed XML document with the following structure:

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"></xsl:stylesheet>

<xsl:template match="”node”"></xsl:template>


<-- use XSLT language elements like etc to build logic -->
</xsl:sort></xsl:loop></xsl:if>
</xsl:template>

</xsl:stylesheet>
(Note there is version 2.0 available since 2007).

All the instructions within the stylesheet are written in XSLT language. The processing in template interleaves input (XPath pattern matching), output and XSLT instructions. We have many programming constructs like loop, if, sort, for-each, value-of, copy-of etc available in XSLT language. These language elements enable us to process the input XML document in a very flexible manner to produce the desired output. The whole power of XPath is available to reach any node set in the input XML document for processing. Defining the processing instructions in declarative fashion in an XML document is ideally suited to an environment where we are primarily dealing with XML documents. It is straightforward to convert from one vocabulary to another using XSLT. We simply state the required output when a certain input pattern is detected. However, the approach forces traditional developers to acquire new skill set. Also XSLT is not expressive enough to handle complex problems like searching for elements described by another element. Although the existing XSLT processors place the whole XML document in memory so could be memory hungry but declarative instructions offers the possibility of progressive rendering.

The alternative is to build on the existing expertise of developer in a programming language like Java, C++ etc to produce the desired output document (Figure 2).

Figure 2. Transformation process of an XML document with conventional application programming

A conventional programmer can readily take an input file, process it in some manner and produce an output. However, an XML document needs to be parsed to extract relevant information. If we could parse it using library routines of some nature then producing the required output document is just a matter of creating a root element and adding relevant elements, attributes and their contents.

This is achieved normally in one of two ways. Either entire document is read into the memory, a Document Object Model is created and library routines are used for parsing the XML document. Or alternatively Simple API for XML (SAX) can be used for parsing the document. DOM approach needs to read the entire document in memory so it is not suitable for very large documents but can change the document in situ. To overcome the memory-intensive nature of DOM, the SAX approach reads the file sequentially and triggers off an event every time a new element is reached or one ended so the programmer can take appropriate action pertaining to that element. Thus the SAX processing hinges on defining event listeners. DOM model has flexibility of being able to access elements randomly but SAX is a sequential approach. DOM is a W3C specification but its API is deemed to be too complex. Also DOM approach requires recursive programming which makes some developers uncomfortable. However once we have acquired expertise in DOM API or SAX then changing parsers becomes easier as newer and better implementations arrive on the scene. Although for relatively small files the DOM approach may be suitable but SAX allows us to handle documents which are bigger than the available computer memory. SAX generally tends to be faster as we are just reading small portion of document at a time. A hybrid approach of XML pull-parsing has evolved lately to combine the efficiency of SAX and simplicity of DOM. It contrasts with ‘push’ nature of SAX as the portion of document is pulled as required. People who are seeking de jure standards would opt for DOM as SAX is open source, free of charge product stemming from the collaborative effort of XML-DEV mailing list. In general, the DOM approach is preferable in a context where we are effectively changing the structure of a rather small document and require total flexibility in navigation.

Nowadays a Java programmer has the best of both worlds and would simply employ Java API for XML Processing (JAXP). Its abstraction layer allows various parsers to be plugged in and the documents to be easily validated, parsed and transformed. Java, XML, and the JAXP is a good guide.

Reference

Rosewell, J. (2009d) ‘Block 2 part 8: Processing XML’, in T320 E-business Technologies: Foundations and Practice, The Open University, Milton Keynes

The brave new world

2010-03-31T12:24:00.000-07:00

The pressure on IT has always been there to deliver. I recall the 80s when the business-IT alignment was on everybody's lips, the 90s when the IT-facilitated business process re-engineering and kaizan were talk of the town and the new economic order was proclaimed by the web-based companies at the turn of the century. IT was always deemed indispensable in these initiatives but adjudged to be slow to meet the business needs. The bursting of the dotcom bubble and the y2k experience tarnished the IT image but did not abet the pressure on IT to facilitate inter-organisational processes in a globalised world. IT's role was still at the heart of 'making it happen'. One assumed that the ERP systems had taken care of all the transactional needs at the operational level and the datawarehouses and business intelligence tools had enamoured the business executives by adding value to strategy formulation. Now comes the frightening reminder that all is not well in the wake of global financial meltdown.

"Capital expenditure priorities are shifted into IT from other high-payback projects" just to perform necessary ERP changes, claims one executive. Whilst another bemoans: "Change to ERP paralyzes the entire organization in moving forward in other areas that can bring more value."

An Accenture partner sees rising tide of operational flexibility on daily basis and proclaims "strategy, as we knew it, is dead." A paradigm shift in IT's execution is expected and demanded in this new world order. Yet the top priority for 2009 was "modernizing key legacy applications" and the SOA, the pre-requisite for flexibility, seemed fatally wounded.

It is a challenge to all the IT professionals to acquire a mindset attuned with business imperatives and successfully deploy disruptive technologies to make a quantum change. The decade ahead of us is full of potential and we must not fail.

SOAP with Attachment API for Java (SAAJ) example

2010-03-30T04:14:00.000-07:00

SAAJ is an indispensable tool for manipulating SOAP messages, especially if they have got attachments. We have illustrated all the steps in creating a SwA (SOAP Messages with Attachments) in the short self-explanatory example which can be adapted for all purposes.

package saajexample;

import java.awt.Image;
import java.awt.Toolkit;
import javax.xml.soap.*;

public class Main {

public static void main(String[] args) throws Exception {
// Factory needed to create SOAP message
MessageFactory msgFactory = MessageFactory.newInstance();
SOAPMessage message = msgFactory.createMessage();
// illustrate the story so far by dumping out the message
message.writeTo(System.out);
// detach the header from the SOAP Envelope
message.getSOAPHeader().detachNode();
System.out.println("");
message.writeTo(System.out);
// manipulate the body of the SOAP message
SOAPBody body = message.getSOAPBody();
SOAPElement getStockPrice = body.addChildElement(
"getStockPrice",
"rt",
"http://www.rajeev.com/jws/StockQuote");
System.out.println("");
message.writeTo(System.out);
getStockPrice.setEncodingStyle(SOAPConstants.URI_NS_SOAP_ENCODING);
System.out.println("");
message.writeTo(System.out);
SOAPElement code = getStockPrice.addChildElement("stockCode");
System.out.println("");
message.writeTo(System.out);
code.addTextNode("IBM");
System.out.println("");
message.writeTo(System.out);
// attach an image
Image image = Toolkit.getDefaultToolkit().createImage("raj.jpg");
AttachmentPart jpegAttach = message.createAttachmentPart();
// use setDataHandler method below if connecting to FileDataSource object for pdf file
jpegAttach.setContent(image, "image/jpeg");
// add the mime type for the image
jpegAttach.addMimeHeader("Content-Transfer-Encoding", "binary");
jpegAttach.setContentId("xxx");
message.addAttachmentPart(jpegAttach);
System.out.println("");
// message.writeTo(System.out); // cannot stream image
// check attachment created successfully
System.out.printf("Number of attachments: %d%n", message.countAttachments());
// remove the attachment and verify
message.removeAllAttachments();
System.out.printf("Number of attachments: %d%n", message.countAttachments());

}
}

JAXB tutorial

2010-03-29T02:20:00.000-07:00

XML is the lingua franca of the web services world. Unsurprisingly, the ability to process XML documents simply is an essential requirement. To my mind DOM and SAX parsers are the equivalent of assembler programming compared to the high-level programming provided by the Java Architecture for XML Binding, JAXB. It is an essential tool in every Java developer's portfolio. But many tutorials on the web hark back to JAXB1.0 so here is something to get you started.

The JAXB tutorial provided by Rose India is rather dated now. The IBM resource was a fairly good introduction to Java-XML mapping once upon a time but the Sun/Oracle JAXB tutorial is simply amazing.

Rarely a tutorial is written which is as comprehensive as the one provided here. All the aspects of mapping XML Schema Language types to Java, marshalling Java-based tree content to XML, unmarshalling from XML-to-Java, ObjectFactory class, XML annotations, the JAXB schema compiler (xjc) et al have been covered very lucidly.

If it still doesn't satisfy your curiosity then the book JAXB 2.0 is all you need for all the JAXB requirements but unfortunately it is in German.

Here is a sample code to marshal and unmarshal a simple letter written by me to Helen of Troy.

package raj;

import java.io.File;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Letter {

/**
* The sender of the letter.
*/
private String sender;
/**
* The receiver.
*/
private String receiver;
/**
* A unique number for the message number sent .
*/
private int messageNo;
/**
* The missive despatched.
*/
private String message;

public Letter() {
}

public String getSender() {
return sender;
}

public void setSender(String sender) {
this.sender = sender;
}

public String getReceiver() {
return receiver;
}

public void setReceiver(String receiver) {
this.receiver = receiver;
}

public String getMessage() {
return message;
}

public void setMessage(String message) {
this.message = message;
}

public int getMessageNo() {
return messageNo;
}

@XmlAttribute
public void setMessageNo(int messageNo) {
this.messageNo = messageNo;
}

public String toString() {
return String.format("Letter %s from %s to %s, saying '%s'", messageNo, sender, receiver, message);
}

public static void main(String[] arg) {
Letter text = new Letter();
text.setSender("Rajeev Trikha");
text.setMessageNo(2010);
text.setReceiver("Helen of Troy");
text.setMessage("Welcome to my world of JAXB in 2010!");
// Create a JAXB context and a marshaller
try {
// here just using a class as an argument but normally is a package
JAXBContext context = JAXBContext.newInstance(Letter.class);
Marshaller marshaller = context.createMarshaller();
// Set the output in formatted manner
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
// Make the actual serialization

marshaller.marshal(text, new File("raj.xml"));
Unmarshaller unmarshaller = context.createUnmarshaller();
// Get the object
Letter msg = (Letter) unmarshaller.unmarshal(new File("raj.xml"));
System.out.println(msg);
} catch (Exception e) {
System.out.println("exc");
}

}
}

The marshalled file raj.xml shows the created XML message which is well indented.

The unmarshalling prints out to the console:
Letter 2010 from Rajeev Trikha to Helen of Troy, saying 'Welcome to my world of JAXB in 2010!'

If you are using Netbeans then check out for understanding how xjc is tied up within the product.

CORBA or web services

2010-03-20T02:48:00.000-07:00

CORBA has the key advantage of being truly object-oriented component architecture and comes with a host of standard services like naming, transactions, printing, events etc which support complex applications in a heterogeneous environment in a platform and language independent manner. For example, there is no equivalent of CORBA Security service in web service environment and only now the suppliers have started addressing these aspects. So the disadvantage of web services over CORBA is that it is reinventing-the-wheel and cannot handle the required amount of complexity in its current state. However the complexity of CORBA, the issues with its specification and the slowness of new development have opened way for web services which are more suited to web-environment with their loose coupling, XML and HTTP usage. The SOAP messages of web services are simple to use and implement. Unsurprisingly, this simplicity has given momentum to web services over CORBA.

Java Web Services: Up and Running is one of the most up-to-date and practical books on web services.

W3C standards for web services

2010-03-20T02:37:00.000-07:00

The key W3C standards for web services are SOAP (previously Simple Object Access Protocol), eXtensible Markup Language (XML), Web Services Description Language (WSDL) and, peripherally, Universal Description, Discovery and Integration (UDDI).

SOAP is protocol which facilitates message-based communication between heterogeneous systems using XML over HTTP (usually) in a defined form. The SOAP message envelop is well-formed, its tags are qualified by a namespace, avoids firewall issues as HTTP port is always open and is part of the body of HTTP request or response.

XML has become the de facto standard for exchanging data between systems as it segregates the meaning of data from its presentation in a plain Unicode text file. SOAP, WSDL and UDDI entries use XML. XML Schema Definition (XSD) is W3C standard for constraining documents vocabularies. The XML files are inherently readable, compressible, portable and support internationalisation, which are pre-requisites in a complex heterogeneous environment. To testify to its popularity, the vocabularies with defined elements and attributes exist for various business domains and the language is extensible. It has become the lingua franca of inter-system communication. SOAP protocol and WSDL descriptions use it. XML messages can be sent over HTTP channels, XML parsers exist in abundance and Data Type Definitions (DTD) or XML Schemas of various vocabularies means that irrespective of platform and implementation language a received XML document can be checked for conformance and meaning and facilitates communication.

WSDL provides platform-independent definition of interfaces of a web service. A WSDL definition describes the location, protocol, service operations, parameters etc in an XML file thus facilitating the segregation of description from the actual implementation. The definition enables one to understand the service and its operations and invoke them.

The UDDI specification is managed by OASIS but it is so central to web services use that it will be churlish to avoid it. UDDI enables web services to be registered and discovered in standard way. The creators of web services register their services in the registry and the potential customers/users discover them there and use them. The white pages, yellow pages and green pages of UDDI entries are well understood and utilised by all who are interested in services-oriented architecture.

Java training course to pass SCJP 6 in Kingston-Upon-Thames

2010-03-20T01:20:00.000-07:00

If you live in the vicinity of Kingston-Upon-Thames or are based in London then here is an excellent opportunity to learn Java for £300. Obviously the intention of the course is to give a thorough grounding in Java but the course is structured around the objectives of SCJP 6. You do not need any prior exposure to programming or Java to do this course.

We will use Netbeans IDE and focus on the objective of SCJP 6. The idea is to make students comfortable with all the relevant classes in JDK 6 and have good foundational knowledge of object orientated concepts like inheritance polymorphism, and encapsulation.

The SCJP focuses on modifiers, wrapper classes, autoboxing, flow control, loops, exceptions, APIs, serialization, threads, packaging (JARs), collections, generics, garbage collection, assertions, regular expressions, var-args, covariant returns, static imports, enum, inner classes etc and we will cover all these aspects of Java language over the five days. The IDE hides complexity so we will do some command line compilation and running of programs to give a clear feel for how packages work and the various flags in java and javac

What is most important is that we will provide the support till you actually pass the SCJP exam. Note that the Prometric centre examination fees are not covered in the course cost.

For more information either phone me at 0208 541 0225 or email rajeev108@gmail.com

SCJP Sun Certified Programmer for Java 6 Exam 310-065 is the recommended book if you really want to come to grip with the language and pass the SCJP.

Return of some useful plugins in Netbeans6.9

2010-03-15T23:47:00.000-07:00

The introduction of Netbeans6.8 was a mixed blessing. Its support for JSF2.0 and ease of development at various-fronts is indeed praiseworthy but the downside was that we lost many useful plugins including visual web tool for JSF development, UML editor, XML schema editor etc. The howls of anguish were widespread. Sun justified it on the basis of instability of some of the tools and the strategic need to marshal resources on winning fronts. Well, Netbeans6.9 early release have some of these back. It indeed is a good news for champions of these tools but it leaves the question answered on the future direction of these tools in the hands of Oracle. The departure of Sun's CEO Jonathan Schwartz, the chief open source officer Simon Phipps and Java technology evangelist Sang Shin (whose javapassion.com was a useful tool for learning various Java technologies) is indicative of the winds of change. Are these back because of the transitional uncertainties? Whatever the reason, enjoy while they are available.

Many know how to add a new plugin in Netbeans using Tools/Plugins/Available Plugins but fewer are certain of Tools/Plugins/Downloaded/Add Plugins which allows the .nbm (the Netbeans distribution files or Netbeans Modules files) to be incorporated in our 'User Installed Plugins) section. The latter option is the one you need to use if you are downloading a zip file from the Sun's site with the appropriate plugin and want to include it in your environment.

I recall an interview of Leo Apotheker (SAPS's ex-CEO) at Charlie Rose last year where he surmised that SAP may even get in the business of producing hardware devices. The rationale was that the software could easily integrate into remotely monitoring utilities meters and other devices and as BI Accelerator shows that the marriage is inevitable in many cases. Whilst there is feverish speculation on the direction of Java, MySql, OpenOffice etc under the aegis of Oracle, it may well be that it is the hardware/software marriage which underpins the acquisition. But it is hard to remain sanguine about these technologies future under a profit-driven acquisitor like Oracle. The Netbeans tools mentioned above may have gained temporary life while Oracle rationalises their product portfolio. So let us temporarily enjoy their availability whilst there are transitional uncertainties.

Creating and consuming a web service using Netbeans

2010-03-15T08:30:00.000-07:00

Here are the steps for creating a simple service which allows two numbers to be multiplied:

create a new web application project called MultiplyApp (File/New project/Java Web/Web Application)

Click on the MultiplyApp node in the project and add a new web service called MultiplyWS (new/Web Service and type MultiplyWS as the Web Service Name and raj as the Package)

Expand the new created Web Services folder and look at the source of MultiplyWS. The default skeleton code should be showing error on MultiplyWS class as it has no operation as yet.

Right click within the class definition and define the multiply operation with long return type and two int type parameters i and j (insert Code/Add Web Service Operation)

Change the MultiplyWS. java code from return 0; to return i * j;

Right click on the MultiplyApp node and select Deploy to deploy the web service.

Right click on MultiplyWS in Web Service folder and select Test Web Service to see the service behaviour.

Right click on MultiplyApp and select Properties and then choose Run category and change the relative path to /MultiplyWSService?Tester

At this stage our service is ready but we need service consumers which can be any Java application, a servlet or a JSP. We cover the steps for the Java application in some detail but the process for creating a JSP or servlet consumer follows the same pattern.

Create a new Java application project called MultiplyClient (File/New Project/Java/Java Application). Leave the Create Main Class box checked while creating.

Right click on the project name MultiplyClient and create new web service client (New/Web Service Client). Select the MultiplyWS service in Project by using Browse.

Right click within main method of our Main.java class and select Insert Code/Call Web Service Operation and choose multiply from the available web service references.

Set the values of i and j and add in a code to print exception if you want.

Run the project and verify that the console printed the correct multiplication of i and j variables which we set in the previous step.

The process for creating the JSP or servlet-based client is the same, barring the fact that when we create a new project we choose File/New Project/Java Web/Web Application. We go through all the steps as above but we add the logic in a new servlet or a JSP and set the relative path in the project/properties/run accordingly to make these the entry points. Obviously the syntactic changes would be there to reflect that we are dealing with a servlet or a JSP when Insert Code/Call Web Service Operation happens. The only point worth mentioning is that the multiply operation can be dragged from the Web Service References to the appropriate point in the code to auto-generate the appropriate logic for the service call at that point. Thus for JSP we get this:

Experiment and enjoy!

Command design pattern

2010-03-14T00:33:00.000-08:00

The command pattern basically has client, command, invoker and the receiver. The pattern encapsulates request (command) as an object. It decouples the client from the receiver. The requests are defined through concrete commands which encapsulate the receiver and implement the command interface containing a single execute() method in it. It uses an invoker with a standardised interface (execute()) to invoke the request on the receiver. The invoker has no knowledge of the receiver. The concrete command it invokes knows about the receiver, the action to invoke on it and the parameters to be passed to it. We are basically issuing requests to objects without knowing anything about the receiver of the object or the method being invoked on it.

We will illustrate it with an example whose UML is in Fig1.

The walk through the example is self-explanatory.

package raj;

public class TestCommand {

public static void main(String[] arg) {

// First illustrate the tight coupling of Horse class

Horse horse = new Horse();

horse.eat();

/* Obviously we could do this with other classes too

* but we want to decouple the receiver of the action

* from the client using action commands invoked by an

* intermediary, the Invoker.

// create the command we want to invoke

Command command = new EatCommand(new Horse());

// create the invoker

Invoker invoker = new Invoker();

// Tell the invoker about the command we want to execute

invoker.setCommand(command);

// execute the EatCommand via the invoker

invoker.execute();

// change the animal to tiger and execute

command = new EatCommand(new Tiger());

invoker.setCommand(command);

invoker.execute();

// illustrate how we can do no action

invoker.setCommand(new NoCommand());

invoker.execute();

// create a different type of command on a different class

// illustrate the action can do multiple things

invoker.setCommand(new ExamineCommand(new Vet()));

invoker.execute();

// pass parameters to command

invoker.setCommand(new PaperWorkCommand(new Clerk(), "Efficienly"));

invoker.execute();

}

interface Command {

public void execute();

}

class Invoker implements Command {

Command command;

public void execute() {

command.execute();

}

public void setCommand(Command command) {

this.command = command;

}

class NoCommand implements Command {

public void execute() {

}

class EatCommand implements Command {

/* the key thing is that the command knows about the receiver

* (contains Animal in this case)

* and the type of action to take on it (run eat() method)

Animal animal;

EatCommand(Animal animal) {

this.animal = animal;

}

public void execute() {

animal.eat();

}

class ExamineCommand implements Command {

Vet vet;

ExamineCommand(Vet vet) {

this.vet = vet;

}

public void execute() {

vet.openSurgery();

vet.examine();

vet.closeSurgery();

}

class PaperWorkCommand implements Command {

Clerk clerk;

String efficiency;

PaperWorkCommand(Clerk clerk, String efficiency) {

this.clerk = clerk;

this.efficiency = efficiency;

}

public void execute() {

clerk.pushPaper(efficiency);

}

class Animal {

public void eat() {

System.out.println("Eating generically");

}

class Horse extends Animal {

public void eat() {

System.out.println("Eating grass");

}

class Tiger extends Animal {

public void eat() {

System.out.println("Eating meat");

}

public void attack() {

System.out.println("Killing a prey");

}

class Vet {

public void examine() {

System.out.println("Examine an animal");

}

public void openSurgery() {

System.out.println("Surgery opened");

}

public void closeSurgery() {

System.out.println("Surgery closed");

}

class Clerk {

public void pushPaper(String efficiency) {

System.out.println("Doing paperwork " + efficiency);

}

Note that strategy pattern had also encapsulated behaviour.

Observer design pattern (Publisher-Subscriber)

2010-03-13T11:20:00.001-08:00

The use of observer design pattern is ubiquitous in Java. We just have to consider Swing classes, GUI frameworks, RMI, JavaBeans etc to note its pervasive nature. Whenever a component registers for an action event, it is using the Observer pattern. The straightforward principle is that whenever multiple parties (observers) are interested in the changes of state of an object (subject/observable) then they subscribe for the notification of changes. The observable object monitors its state and on observing relevant change in its state, it notifies all the interested parties through a common update() interface. The subject provides methods for the subscription and un-subscription. Obviously, the subject can either push all the changes to the observers or allow the observers to pull the changes on notification through provides API. The key is that the subject and the observers are loosely coupled, as the subject has no knowledge of the observers.

Our sample program clearly illustrate the principle.

package raj;

import java.util.ArrayList;

import java.util.List;

public class TestObserver {

public static void main(String[] arg) {

// create the subject we are interested in subscribing

Subject subject = new Subject();

// create the subscriber for the subject

Bar interestedObserver = new Bar();

// add subscribers

subject.addObserver(new Foo());

subject.addObserver(new Bar());

subject.addObserver(interestedObserver);

// subject state changes; the observers notified

subject.stateChange();

// unsubscribe

subject.removeObserver(interestedObserver);

// check the unsubscribed party doesn't get further notification

subject.stateChange();

}

class Subject {

List observerList = new ArrayList();

public void addObserver(Observer o) {

observerList.add(o);

}

public void removeObserver(Observer o) {

int index = observerList.indexOf(o);

if (index >= 0) {

observerList.remove(index);

}

public void notifyObservers() {

for (Observer o : observerList) {

o.update("change");

}

public void stateChange() {

notifyObservers();

}

interface Observer {

public void update(String message);

}

class Foo implements Observer {

public void update(String message) {

System.out.println("Foo: " + message);

}

class Bar implements Observer {

public void update(String message) {

System.out.println("Bar: " + message);

}

We have opted for push technique in our example but it could be more appropriate to use pull as it allows the observer more flexibility in responding to the change.

Also it is worth noticing that Java provides its own implementation of Observer and Observable in the java.util package so the above sample could have been codes as:

import java.util.Observable;

import java.util.Observer;

public class JavaObserver extends Observable {

private String message;

public String getMessage() {

return message;

}

public void stateChange(String message) {

this.message = message;

setChanged(); // signifies state change

notifyObservers(message);

// the line below is for 'pull' as we pass the object so getMessage() can be invoked

// notifyObservers(this);

}

public static void main(String[] args) {

JavaObserver subject = new JavaObserver();

Baz bar = new Baz();

Baz baz = new Baz();

Baz foo = new Baz();

subject.addObserver(foo);

subject.addObserver(bar);

subject.addObserver(baz);

subject.stateChange("Change!");

}

class Baz implements Observer {

public void update(Observable o, Object message) {

System.out.println("Baz: " + message); // push

// the line below is for 'pull'

// System.out.println("Baz: " + ((JavaObserver) message).getMessage());

}

The key restriction of the Java built-in functionality is that we have to extend the Observable class so there is no way extending JavaObserver from any other class.

Model-View-Controller (MVC) pattern

2010-03-13T05:17:00.000-08:00

The MVC architectural pattern is the bedrock of technologies like JavaServer Faces and is fundamental to implementing three-tier architecture. It clearly segregates the model in the business layer, view in the presentation layer and the controller, which handles all the inputs affecting the model. Obviously if the model is totally segregated then it becomes relatively easier to test the domain logic with automated tools. We can illustrate this decoupling of model and view through a simple calculator application which takes two numbers and applies the requested operator to provide the result.

package mvc;

import java.awt.event.ActionEvent;

import javax.swing.*;

public class MvcTest {

private static void buildUI() {

MvcModel model = new MvcModel();

MvcView view = new MvcView();

MvcControl control = new MvcControl("Result", view, model);

view.setControl(control);

JFrame frame = new JFrame("Test Calculator");

frame.getContentPane().add(view.getMainPanel());

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.pack();

frame.setLocationRelativeTo(null);

frame.setVisible(true);

}

public static void main(String[] args) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

buildUI();

}

});

}

class MvcView {

// mainPanel holds all the GUI components

private JPanel mainPanel = new JPanel();

// two input fields and the result textfield

private JTextField firstOperand = new JTextField(10);

private JTextField operator = new JTextField(1);

private JTextField secondOperand = new JTextField(10);

private JTextField resultField = new JTextField(10);

private JButton addButton = new JButton();

public MvcView() {

resultField.setEditable(false);

operator.setText("+"); // default to add

mainPanel.add(firstOperand);

mainPanel.add(operator);

mainPanel.add(secondOperand);

mainPanel.add(new JLabel("="));

mainPanel.add(resultField);

mainPanel.add(addButton);

}

public void setControl(MvcControl control) {

addButton.setAction(control);

}

public JPanel getMainPanel() {

return mainPanel;

}

public String getFirstOperandText() {

return firstOperand.getText();

}

public String getSecondOperandText() {

return secondOperand.getText();

}

public String getOperatorText() {

return operator.getText();

}

public void setResultText(String text) {

resultField.setText(text);

}

class MvcControl extends AbstractAction {

private MvcModel model;

private MvcView view;

public MvcControl(String text, MvcView view, MvcModel model) {

super(text);

this.view = view;

this.model = model;

}

public void actionPerformed(ActionEvent e) {

view.setResultText(""); // clear the result

try {

double op1 = Double.parseDouble(view.getFirstOperandText());

double op2 = Double.parseDouble(view.getSecondOperandText());

char operator = view.getOperatorText().charAt(0);

if (operator == '+'

|| operator == '-'

|| operator == '*'

|| operator == 'x'

|| operator == 'X'

|| operator == '/'

|| operator == '%') {}

else throw new IllegalArgumentException();

double result = model.doOperation(op1, op2, operator); // use the model here

view.setResultText(String.valueOf(result));

} catch (NumberFormatException nfe) {

JOptionPane.showMessageDialog(view.getMainPanel(), "Only Numbers Allowed",

"Data Error", JOptionPane.ERROR_MESSAGE);

} catch (IllegalArgumentException nfe) {

JOptionPane.showMessageDialog(view.getMainPanel(), "The operator must be one of *, /, +, - or %",

"Data Error", JOptionPane.ERROR_MESSAGE);

}

class MvcModel {

public double doOperation(double op1, double op2, char operator) {

double result = 0;

switch (operator) {

case '+':

result = op1 + op2;

break;

case '-':

result = op1 - op2;

break;

case '*':

case 'x':

case 'X':

result = op1 * op2;

break;

case '/':

result = op1 / op2;

break;

case '%':

result = op1 % op2;

}

return result;

}

It is clear in our example that the view (MvcView) is the user interface which asks for two operands and the mathematical operation to apply on them. Model (MvcModel) is passed these inputs by the controller (MvcController) to get the calculation result. In our design the view has no knowledge of the model and the controller is an observer of the action performed on the 'result' button in the view. The controller uses its knowledge of the view to update the result. Thus a clear segregation of roles has been achieved. Obviously an application can have a number of these MVC triplets.

Factory design pattern

2010-03-12T03:41:00.000-08:00

Let us give ourselves godlike powers and create a factory to produce animals. The basic structure for such a factory would look like:

package raj;

/**

* @author Rajeev

public class AnimalFactory {

private String animalType;

AnimalFactory(String animalType) {

this.animalType = animalType;}

public Animal createAnimal() {

if (animalType.equals("Dog")) return new Dog();

else if (animalType.equals("Cat")) return new Cat();

else if (animalType.equals("Donkey")) return new Donkey();

else if (animalType.equals("Horse")) return new Horse();

else return new Animal();

}

class Animal {public String toString(){return "Animal";}}

class Dog extends Animal {public String toString(){return "Dog";}}

class Cat extends Animal {public String toString(){return "Cat";}}

class Donkey extends Animal {public String toString(){return "Donkey";}}

class Horse extends Animal {public String toString(){return "Horse";}}

It allows us to create an animal of a type which the factory has been geared to produce. We can test it with:

package raj;

/**

* @author Rajeev

public class TestFactory {

public static void main(String[] arg) {

// create factories

AnimalFactory horseFactory = new AnimalFactory("Horse");

AnimalFactory dogFactory = new AnimalFactory("Dog");

AnimalFactory catFactory = new AnimalFactory("Cat");

AnimalFactory donkeyFactory = new AnimalFactory("Donkey");

AnimalFactory animalFactory = new AnimalFactory("");

// create horses

Animal animal = horseFactory.createAnimal();

Animal animal2 = horseFactory.createAnimal();

System.out.printf("We are type %s %s%n",animal,animal2);

// create dogs

animal = dogFactory.createAnimal();

animal2 = dogFactory.createAnimal();

System.out.printf("We are type %s %s%n",animal,animal2);

// create cats

animal = catFactory.createAnimal();

animal2 = catFactory.createAnimal();

System.out.printf("We are type %s %s%n",animal,animal2);

// create donkeys

animal = donkeyFactory.createAnimal();

animal2 = donkeyFactory.createAnimal();

System.out.printf("We are type %s %s%n",animal,animal2);

// create animals

animal = animalFactory.createAnimal();

animal2 = animalFactory.createAnimal();

System.out.printf("We are type %s %s%n",animal,animal2);

}

Now if we decide to produce 'sheep' in future or make a species extinct then all we have to do is to alter the Factory class to incorporate this new requirement at one central place. A demigod could be allocated a particular factory type now and he can happily go on churning objects of that particular species. This programming idiom is useful but not the Factory method pattern defined by GoF. Our current UML diagram is shown in Fig 1.

The GoF Factory method design pattern would alter the diagram to Fig 2.

With this variation, the TestFactory client is totally isolated from the realisation of the factory and its products (the concrete Animal). In this approach the client talks to the abstract interfaces which delegate the actual implementation to their subclasses. Our code changes accordingly to make this possible.

package raj;

public class TestFactoryFM {

public static void main(String[] arg) {

// create factory

AnimalFactoryIF horseFactory = new AnimalFactory("Horse");

// create horses

AnimalIF animal = horseFactory.createAnimal();

AnimalIF animal2 = horseFactory.createAnimal();

System.out.printf("We are type %s %s%n",animal,animal2);}

}

abstract class AnimalFactoryIF {abstract public AnimalIF createAnimal();}

class AnimalFactory extends AnimalFactoryIF {

private String animalType;

AnimalFactory(String animalType) {

this.animalType = animalType;}

public AnimalIF createAnimal() {

if (animalType.equals("Dog")) return new Dog();

else if (animalType.equals("Cat")) return new Cat();

else if (animalType.equals("Donkey")) return new Donkey();

else if (animalType.equals("Horse")) return new Horse();

else return new Animal();

}

abstract class AnimalIF { abstract public String toString();};

class Animal extends AnimalIF {public String toString(){return "Animal";}}

class Dog extends Animal {public String toString(){return "Dog";}}

class Cat extends Animal {public String toString(){return "Cat";}}

class Donkey extends Animal {public String toString(){return "Donkey";}}

class Horse extends Animal {public String toString(){return "Horse";}}

Hitherto, in our approach we have one-to-one relationship between the AnimalIF and its subclass and the FactoryIF and its subclass. However, the power of the approach becomes apparent if subclass our FactoryIF with another factory, SpecialFactory, which produces superior quality animals, SpecialAnimal, which are a subclass of the AnimalIF. The client is built to an interface and is totally unaware of the type of animal it is dealing with. Unsurprisingly, the Factory method design is used frequently in frameworks.

Compilation failures one should know in Java

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

Those of you who are preparing for SCJP are aware that nearly every question has 'compilation will fail' as an option. Here is a short random list of the compilation failures one should watch out for. No list of this nature can be comprehensive but it does include many useful hints.

while (false) {} // immediate error on the line

while (true) {}; // immediate error on the line following the loop

but while (true) {break;}

System.out.println(""); will compile.

throw new RuntimeException; // the line following is unreachable

go(1) when go(short i); // cannot down cast int to short have to say go((short) 1)

assert (): go(); where void go() // need a string and cannot have void

final X f = new X(); and then f=null; // cannot assign anything to reference

final int x=5; then x++ // especially with interface constants

importing static from a different package whose access is defined as default

We can define unused variables. It is not a compilation failure but just like unused imports.

switch case has a non-compile time literal (ie it is not defined and initiated final on the same line. It is not good enough to declare it as final on one line and then initialize it on the next).

You can't change the return type of overridden method, if return is int in parent then can't return Integer or short in the child. The temptation because of covariant returns is that it may be possible. An overridden method can return the child of a class defined in the parent. However it is a compile error to return parent to a child return type. If expecting Number m() return Integer; is fine, and Integer m() return Integer; is fine but Integer m() return Number; will not compile.

Calling super or instance from static block. Always ensure that an object exists in main before invocation of methods.

Using join, sleep or wait without handling InterruptedException or throwing InterrupedException from run(). The latter breaches the contract of Runnable interface by throwing an unexpected checked exception.

Method with no return type will not compile

new myrunnable().start will not compile. Has to be new Thread(myrunnable).start

class X is not correct nor is class

import static with just the class name fails

There is no such thing as super.super to invoke parent's parent.

You cannot override a static method with a non-static or vice versa.

try {} System.out.println("Here"); catch () {} will fail. No statements between try and catch.

parse needs to catch ParseException

run() cannot throw InterruptedException // no checked exception can be thrown which interface didn't define

for(String s:aa) // declaration has to be within foreach and s should not have been declared before. However it is OK to have s being used in multiple foreach as each has just the local scope.

assert 1 > 2: go(); // will not compile if from within main or any static block if go() not static

inner classes cannot have static members so be wary of their definitions.

import static java.lang.Integer.MAX_VALUE; then import static java.lang.Short.MAX_VALUE; as MAX_VALUE already defined.

declaring enum in a method fails

void doMore() {throw new IOException) fails becuase checked exception must say doMaore() throws IOException

If we catch Exception() then compiler won't allow any child of it to follow it. The order matters.

Putting long in switch expression, it can only be int or thing which can convert to in like char, byte, short

trying to use uninitialized local variable in a method or trying to prefix them with access modifier. Only valid modifier within method is final. Watch out for private int i = 5 in a method.

enum outside class can not be marked static, final, abstract, private or protected. Within the class it can be marked static, private or protected but not abstract or final.

myenum xx= new myenum(); won't compile. Enums are just initialised.

Trying to cast char into a String. char is a primitive and String is an object so S = c fails.

Instance variables cannot be marked strictfp, native, synchronized, abstract. final and transient are fine.

Not having a proper main() method is a runtime error, not a compiler error!

char c = -1; is illegal but char c = (char) -1 is OK. Char is unsigned integer literal with max value of 65535;

byte a = 3; byte b = 2; but byte c = a + b; will not compile as the result is an int. However byte c = 3 +5 is OK as within range and the compiler knows.

float f = 23.4; will not compile as 23.4 is a double.

A variable defined within the initialisation block is not visible to the program, ie {int j = 1;} j cannot be seen anywhere. Trying to use it later will not compile.

int i = 5; static {i = 7;} will not work as i is non-static.

You can't widen an Integer into a Long. The wrapper classes are different objects.

if (5 && 6) will not compile. The expression has to evaluate to boolean

if (x=6) is an illegal argument to if. It is just assigning. Can get away with this with boolean otherwise compile fails.

Integer i = new Integer(4); switch (i) is wrong if used as a case expression in switch statement.

continue statements must be inside a loop; otherwise, you’ll get a compiler error. break statements must be used inside either a loop or switch statement.

Labelled continue and break statements must be inside the loop that has the same label name; otherwise, the code will not compile.

Object test() { return (Double) 2.7;} works Object test() { return (Float) 2.7;} doesn't works 2.7 boxes to Double

Short n = new Short((short) 3); without the cast it fails. However it is ok to say Short s = 555; Integer i = 1 etc as long as they are within range.

More importantly it is fine to compare the incompatible wrapper types like Integer, Short etc with relational operators like greater than or greater than or equal to but not right to use ==. For relational comparisons of greater than, less than etc. it auto unboxes and doesn't complain.

boolean equals(Object o) {return true;} doesn't compile. hashCode(), toString() too are PUBLIC methods. As they are without public modifier they are improper override.

Watch out for missing semicolon in the definition of anonymous inner class.

The compiler will complain if you try to invoke any method on an anonymous inner class reference that is not in the superclass class definition.

Beware of sticking static in front of run() it will not compile as being improper override.

The public access modifier is the only one that allows code from outside a package to access methods in a package regardless of inheritance. If we are overriding a method in a subclass in a different package then the method must be public.

While using an interface from a different package, it must be declared public or we will not be able to use it. Just default package will not work.

Singleton design pattern

2010-03-12T00:39:00.000-08:00

It is conceptually the simplest design pattern and many argue that it is actually an anti-pattern and continues to exist within computing courses because GoF specified it in their seminal work and it offers easy introduction to the subject of design patterns. Controversial it may well be but it has a useful purpose when we do genuinely need just one object of a class. Obviously the logger is the primary example.

The design is simple:

package raj;

class TestSingleton {

public static void main(String[] arg) {

Singleton s = Singleton.getInstance();

System.out.println(s.toString());

s.setVal(100);

Singleton s2 = Singleton.getInstance();

System.out.println(s2.toString());

System.out.println(s2.getVal());

}

public class Singleton {

private static Singleton singletonObj;

private Singleton() {

}

private int val = 0;

public int getVal() {

return val;

}

public void setVal(int val) {

this.val = val;

}

public static Singleton getInstance() {

if (singletonObj == null) {

singletonObj = new Singleton();

}

return singletonObj;

}

It relies on having a private constructor and public static interface to provide the object. We can make this design thread-safe by synchronizing the getInstance() method:

public static synchronized Singleton getInstance() {

if (singletonObj == null) {

singletonObj = new Singleton();

}

return singletonObj;

}

However, this approach would considerably slow down the access to the object as synchronization can be painfully slow and is only needed during the first create. To over come this we may eschew lazy instantiation of the object and change our Singleton class to the following to let the class loader take the responsibility for instantiation:

public class Singleton {

private static Singleton singletonOb = new Singleton();j;

private Singleton() {

}

private int val = 0;

public int getVal() {

return val;

}

public void setVal(int val) {

this.val = val;

}

public static Singleton getInstance() {

return singletonObj;

}

This is great! But if the objected created is a scarce resource and is never used then it obviously is wasteful. A thread-safe compromise solution would be to use double-checked locking:

public static Singleton getInstance() {

if (singletonObj == null) {

synchronized (Singleton.class) {

if (singletonObj == null) singletonObj = new Singleton();

}}

return singletonObj;

}

Now we take the synchronization hit just during the create but there is still a small overhead of an extra conditional check during every access. Also note that we cannot use synchronized(this) as we are locking from within a static context so need the class literal Singleton.class.