In this example I will present the reader with a simple way of using iText for form fill automation. A simple example of how this comes useful is when a user fills information in a web form or a series of forms (as part of a workflow) and at the end is presented with an option to save or print a summary or an agreement. In this situation it is very useful to present the user with an opportunity to use Adobe’s PDF format in addition to plain HTML.

In order to proceed with the execution you will need the latest iText jar which you can find here. In addition you will have to have or create a PDF form which will be used in the automated form completion process. For the purposes of this example I have created a very simple form using Adobe Acrobat Professional which has just 2 simple fields: first name and last name. You can download the form used in this example Form. The two form fields are called FirstName and LastName. Next we can use the following java code to load the template, extract the form, and fill the desired information in the fields:

// get the destination
String location = "C:/java/pdf/src/";
if (location != null && !location.endsWith(File.separator))
{
location = location + File.separator;
}

PdfReader reader = new PdfReader(location + "Form.pdf");
String name = "Output.pdf";
PdfStamper stamp = new PdfStamper(reader, new FileOutputStream(location + name));
AcroFields form = stamp.getAcroFields();

String last = "subform[0].LastName[0]";
String first = "subform[0].FirstName[0]";

form.setField(last, "HRISTOV");
form.setField(first, "NEDKO");

// close pdf stamper
stamp.setFormFlattening(true);
stamp.close();
reader.close();

The snippet above creates a file called Output.pdf and fills the text values in. In addition to simple textboxes you can have checkboxes,  number fields, dropdowns, fields with format validation like phone numbers, social security numbers, barcodes etc. In the next example I provide a more complex form with different types of fields.

1. Reduce your energy consumption – you can be very creative here: start by purchasing Energy Star products, not leaving lights and appliances working while not using them, be smart setting the thermostat of your heater and air conditioning to a reasonable level, use energy efficient light bulbs, don’t leave appliances on standby (this alone can reduce consumption by 10%), look at your bill for other suggestions. Efficiency programs are often available with your utility provider.

2. Reduce water use – don’t waste water. Starting from gardening, shower time, the kitchen you can be very creative. Use shower heads and facets that save water, monitor leaks, check your toilet water consumption.

3. Reduce gas consumption – use fuel efficient vehicle, telecommute, use public transportation, bike, walk, or use rideshare with a friend or coworker.

4. Eat smart – don’t waste food. Watch your food consumption and make sure you don’t waste any of it. Remember that one third of the people on earth are underfed. NEVER throw away good food. If your food goes bad change your shopping habits. Purchase locally raised products.

5. Buy smart – support products that use less packaging and employ environmentally friendly methods and by-products in their packaging.

6. Recycle – start by reading your news online and cancel that paper subscription. Separate your mail and trash and dispose of it properly. Cancel all your paper bills and sign up for online statements – that saves you and the company time and money and protects the environment.

7. Stop buying bottled water – I know the water from your sink just does not taste exactly the same but when filtered it’s equally healthy for you and does not produce all that thrash.

8. Dispose of unwanted items properly – old tvs, cellphones and other electronics come to mind. There are programs of proper disposal, recycling, and even reuse. One example if old cell phones for military personnel. Even if it means holding on to an item an extra week or two put your best effort in trying to pass it to somebody who will use it. Donate your old clothes that you don’t use to charity.

9. Share – before you buy this new book try the local library first. Share it with a friend. Resell it or donate it once you are done.

10. Try to influence the people around you to do the same – Remember word of mouth is the best marketing. Try to suggest new ways of doing things to the people around you without being too pushy. Respect their ways.

That’s my list of suggestions. I hope this helps and if you have any other ideas feel free to share them.

It is hard to overstate the importance of testing before going live with a website or a web application. The rule of thumb is that whatever can go wrong will at exactly the most crucial moment. The problem is that your staging environment is inadequate and fails to replicate real scenarios. That’s where JMeter comes useful.

The open source load testing tool is written Java and allows testing functional behavior and performance under variable loads. Originally developed for testing Web Application JMeter has expanded and works with different servers and protocols: HTTP, HTTPS, SOAP, Database via JDBC, LDAP, JMS, mail through POP and IMAP. The tool is highly customizable and includes pluggable architecture as well as numerous built-in features like randomizers, timers, logic controllers, regular expression handling etc. The data collection,  analysis and visualization tools make it easy to get results fast come to valuable conclusions of the overall quality of your product. The tool comes as a desktop application with a clean, easy to use GUI. While it is not a browser (certain aspects as rendering, JavaScript execution are not covered)  it behaves as such as far as the remote client is concerned. It handles cookie and session management in full multithreading which allows concurrent sampling.

The user can write a test script or record one through the use of the built-in HTTP proxy server and then modify the parameters of the communication with the server (HTTP headers, request type and request parameters). To get started just download JMeter and read the JMeter Tutorial as well as the official documentation.

During my professional career I have become accustomed to the development tools that make the engineer’s job much easier. On the other hand I’ve come to the realization that little time and attention is being spent on optimization and proper use of those tools. While there is plenty of information out there on framework comparisons, guides, APIs, and the like very few products seem to adopt the best practices and the tier two functionality slips through the cracks of the Q&A process. This is usually the case with logging.
Log4J is the status quo when it comes to logging in Java. With the expanded mainstream popularity the framework which has been branched in C++ (Log4cxx) ,  C#/.NET (Log4Net) and even PHP (Log4php) has made it easy to add logging to multi tier applications. The advantage of having a very granular approach with different log levels (DEBUG, INFO, ERROR, etc.) and the Logger package inheritance make it a flexible tool. Without getting into details on the configuration and how to get started I want to spend time on the proper Logger initialization and use for exception handling.

Log4J Logger

As described in the Logger API we can get our Logger initialized inside the class in one of several ways the most common of which are:

- using the Class object

Logger log = Logger.getLogger(getClass());

- using a string

Logger log = Logger.getLogger(getClass().getName());

or

Logger log = Logger.getLogger("com.java.foo.MyClass");

Once we have a logger instance we can easily log messages with different threshold:

Foo foo = new Foo();
log.info("Created object foo: " + foo.toString());

or

if(log.isDebugEnabled())
{
	//do something
	log.debug("Result: " + foo.getResult());
}

Exception handling

It gets more interesting when we get to exception handling. In the regular try catch scenario we usually deal with some exception where we want to collect some output about what happened and where. A lot of times developers are tempted to use exception.getMessage() which is often empty or yet worse call exception.printStackTrace() which actually prints to the standard output rather than our log file. In order to successfully print the exception message and the stack trace we can add the exception to the logger output by doing this instead:

try
{
	computeInterestRates();
}
catch(Exception e)
{
	//something went wrong - log an error
	log.error("Error during RateCalc: ", e);
}

Conclusion

It is easy to get lost in requirements and miss on some of the essential product functionality. The proper use of logging helps reduce and eliminate defects in the lifecycle of the software and be a life saver in the long run. Make sure that you properly handle all logging. Keep in mind that the overuse of logging has a detrimental effect on performance so use it sparingly. For more information see the Log4j Official Documentation.

Caused by: java.lang.LinkageError: loader constraints violated when linking javax/activation/DataHandler class

Translation: This is typically caused to be thrown when two different classloaders load different versions of the same class (different signatures). The underlying cause is essentially including two versions of the same class in your CLASSPATH. Most often the underlying reason is including a JAR file as a dependency in your WAR or EAR which is already included as part of your Servlet Container (my development container happens to be JBoss) or your JVM.
A quick search on findjar.com established that my problem is caused by activation.jar which happens to be included both in my project and the JBoss lib. A quick way to verify this is to extract the EAR or WAR file and have a look for the jar question. In my case I was able to find it in both WEB-INF/lib and JBOSS/lib. A quick fix or a proof of the solution is simply removing one of the instances. For me removing the jar from the EAR proved to be the solution.
Since I like automation when it comes to dependency management I am using Maven to alleviate all the hassles of the manual equivalent. That means that I need to trace which of my build modules includes the jar in question. This is done by building the Maven dependency tree:

mvn dependency:tree

or tunnel the output to a text file which you can examine in your favorite editor (recommended)

mvn dependency:tree > tree.txt

Here it’s worth noting that the dependency feature parameter “outputFile” is not working at the time of writing due to a known bug. After building and searching the tree I can easily identify all the references: javax.xml.bind and javax.xml.ws
Now in order to fix the problem all I need to do is provide the exclusion to both dependencies in my pom.xml:

<exclusions>
<exclusion>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
</exclusion>
</exclusions>

Now my dependency looks like this:

<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.0.3</version>
<exclusions>
<exclusion>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
</exclusion>
</exclusions>
</dependency>

Before I run a full build it’s best to verify that there are no more references of activation.jar in my tree by creating the dependency tree again. With that out of the way I am ready to build and deploy my EAR to test the solution. For more on maven dependency mechanism and managing exclusions please refer to the Maven documentation.

To help clearly define and put the focus of it’s customization effort Google renamed the ‘Personalized Home’ page to iGoogle. Along with that came some new features which were along the lines of the rest of the Web 2.0 world: personalization with the portal feel while being able to aggregate all Google features like web, images, mail, calendar, maps, news and more. The concept of taking full advantage of localization, syndication, collaboration and bringing more web to the user by having gadgets really took off and has proven to be the fastest growing company product for 2006.

One thing that really stands out about the platform is that it has almost no learning curve and it allows the user to define the boundaries within which it will be used. A user is easily able to use the service without even signing up with an account (using cookies) but if you want to take personalization to the next level you can sign up and use it on multiple computers, customize it even more and bring social networking in the picture. Adding the ability to collaborate (discuss stocks or share documents for examle) and get updates about your friends’ photo album or new widgets that they have added is like taking all the applications you use, putting them on the web and running a cross layer of social networking to form something bigger than the sum of its parts.

The widgets concept is great and while it still has some rough edges it definitely provides a great start for organizing a dashboard with customizable layout and content spread on optionally multiple tabs. The rich library of existing widgets will satisfy almost any taste and even for the pickiest users there is an opportunity to create their own widgets by using the Widget Maker feature which provides a nice widget API (more on that in my next post). While talking about customization I can’t help mentioning the themes which offer the extra touch of personality. Unless you are one of these boring people like me you might want to pick one of the many themes which nicely change the default white frame and add the extra touch of personality without taking away from the content. As a new addition Google has even gone a step further including the so called Artist Themes which represent the artwork of world class artist.

In conclusion iGoogle introduces a new way of looking at web + search and re-defines customization with features like location-based personalized search. This direction will be very important for Search 2.0 as it reaches more and more mobile devices. On the other hand a lot is left to be desired in improving the functionality of widgets: creating anything different than the boring RSS or a poorly styled functionally handicapped widget.

While DVD was great while it lasted and marked one of the greatest successes in the history of consumer electronics it was clear that its days were numbered. The standard definition that DVD had to offer was not enough to satisfy the likes of Hollywood. With technology racing at an unimaginable rate and HD video and audio reaching living rooms around the world the world for the next generation high definition format was started. That is a round 2 for Sony and the long forgotten Betamax Vs. Video Home System (or VHS as we all know it) for standard domination. The last time around Sony’s Betamax lost the battle despite being technologically superior. Better quality had recording time as a trade-off. The majority of consumers did not want to commit to a standard and movies were offered for both. Unlike this time the battle continued much longer and finally VHS’s dominant market share, higher recording capacity, and lower media costs forces Sony to pull out. Well, apparently the folks at Sony have learned a few lessons. Although Blue Ray still has a higher cost and the early momentum that HD DVD generated this time we have a much more competitive product. Starting with much higher capacity [50Gb for a dual layer compared to 30Gb for Toshiba's HD DVD] Blue Ray seems technologically superior. This time Sony took a different approach and overcame the somewhat established HD DVD lead by spending most time and applying pressure to the movie studios themselves. The tight competition forced studios to offer movies in one format or the other but not both. Same was valid for manufacturer support where Blue Ray had better success. All the success could also be partially credited to region coded support and better digital right management and copy protection. At the end it came down to Warner Brothers followed by Wal Mart who joined Sony and agreed to offer movies exclusively in Blue Ray. While those two add just one more to the count they represent 80% and 32% respectively of the market share in their industry which makes the decisions huge. Toshiba knew that was a big sway on Blue Ray’s direction – it was more than they could handle. Disappointing signs from investors forced the giant to discontinue the efforts to revive the initial momentum and under such pressures Toshiba made a press release announcing the end of the Blue Ray Vs. HD DVD war. Although Sony was ready for a long battle it can now claim the victory.

The score is not 1:1 and the question “Is <insert movie> coming to Blu-ray?” in section 4.3 of the Blue Ray FAQ much easier to answer. Lesson learned for Sony – what goes around comes around.

After a couple of days researching what exactly Google Apps has to offer and countless hours of searching for feedback from people with first hand experience on the matter I decided to bite the bullet and pull the plug on my good ‘ol mail server. My main motivation was the fact that i can try it for free and even continue using it for free as long as my domain met certain criteria. On top of that Google provided me with scheduling and collaboration tools using a one-size-fits-all approch. At that point I had heard enough and was ready to get my hands dirty with Google Apps or at least as dirty as a keyboard, mouse and 2 hours of my free time will allow. But before I continue sharing my adventure I wanted to share some of the pros and cons of using Google Apps.

Pros:

Most apparently you get a nice, production grade Gmail email service with a 99.9% uptime promise, backups, security, spam filters, web inteface people are familiar with.

Cost. The cost of the implementation and the ROI is very low (50$ per user per account per user – that excludes aliases and lists) for the Premier edition and FREE for the Standard version. Compared to other combinations requiring some combination of software + hardware + support you get the most bang for your buck.

Ease of use. Needless to say nowadays it’s hard to find a person not familiar with Google’s Gmail and their slick and easy to use web interface. This makes the transition for any institution a breeze and the time spent in user training limited.

Ease of administration …administration? What’s that? No, but honestly adding users is a breeze as well as user aliases and list administration. Of course there is always more to be expected especially when it comes to granularity and the concept of groups but it is my belief that there is already somebody in cube scetching and coding that implementation.

Premium Edition FREE. If you satisfy certain requirements you can use Google Apps Premier absolutely free. Those include registered non-profits and educational institutions.

Built-in Security – Google uses secure connections and data redundancy. Through the use of protocols such as SSL and TLS you can make sure your data is protected. In certain situations this extra security can pose a problem with existing applications which make use of SMTP but don’t provide secure connection but there are possible workaronds.

Physical security – your data is stored on a server in a data center with top of the line protection from any natural events from floods and fire to earthquakes.

Calendar functionality by itself is a great feature which again most people use and are familiar with the interface from their personal accounts. The integration under the same umbrella comes handy and the Premier edition includes goodies like room and resource scheduling.

Great collaboration tools like document sharing, simultaneous editing, web publishing and chat. It’s hard to express in words the time savings and convenience when you see a combination of these tools in action – whether you have 20 people editing the same document or just want to send a message to somebody you have everything you need.

A free replacement for an Office suite. Although Google Docs was not created as a perfect replacement of applications like Microsoft Office in mind it provides most of the features most users are likely to use. Except the fact that Google really missed the memo on a presentation replacement application their solution focuses on collaboration, central data storage, and 24/7 availability.

More of the bonus features include: API, Single Sign-On solution, super easy email migration, support for email gateway

Cons:

Control. Well, of course by committing you have less control in the decision making process but you can try and then always switch to another solution

You get what you pay for. If you don’t have the Premier edition free support is to no avail. That means that you will have to spend time researching when problems arise and most likely end up paying when there is nothing you can do about the problems

Maturity. Be mindful that Google Apps is a project in progress and is not very mature. That means that it is incomplete and lacks certain functionality which you might expect.

Support …or the lack thereof is one important thing to mention. See, even if you use the premium edition and pay all the fees you can only get so much. Getting to talk to a real person is off limits and all the automated phone service refers you is help and forum URLs. Your only chance to get some personal attention is to use the ticketing system submit form and prey that your issue gets looked at pretty soon. Make sure you bookmark this page https://mail.google.com/support/bin/request.py?contact_type=bugs&ctx=bugflow_register08 as it will be your only point of contact with the Gods of Email.

Executables. Watch out for executable files – Google will not let them in even if you try to trick it by archiving it. Although sending executables through email is not a good practice as well as coaching your users to open executable extensions this can be a little annoying.

CSS. Not that this is exactly a very big deal for most people and they might as well never notice it but Gmail’s web interface will strip headers and almost all CSS from an email sent as HTML. For udnerstandable reasons they don’t want layout hiccups but some users can find that a bit inconvenient.

Privacy is a major concern for any organization especially when it has to do with sensitive company data and intellectual property.

Regulatory compliance. Before I continue any further let me just say that if your organization requires regulatory compliance of any sort which is often the case with certain branches of government, healthcare, and the financial industry you can automatically forget about it – Google Apps does not comply with the storage, transfer, filtering, privacy and disaster recovery requirements for those sectors.

Ads. When using the web interface you might have to see a couple of advertisements. Unfortunately the free edition does not have the option to turn them off but after all there is no such thing as free lunch.

SMTP limit. If you really read the fineprint you will know …or you will find out later that Google’s SMTP service has a restriction to send only up to 500 emails per day for a particular account. While this is enough for the average Joe in your office it might pose a risk if you are using any automated email services and notification in your organization. Again the workaround is using a separate SMTP server as an email proxy.

To get everything started we’ll prepare a web form in pure XHTML which submits the content entered by the user via POST submit to our script which will assemble the message and send it. Our script will utilize the PHP mail function so you will have that functionality enabled on your server in order to send email messages. In PHP this configuration is done in php.ini in a section called [mail function]. I am not going to get into great details but in short there will be three settings : SMTP, sendmail_from, and sendmail_path that you will have to configure. If you are configuring a Windows machine you would want to set the SMTP section to your outgoing SMTP server whereas UNIX and Linux users will have to set sendmail_path to make use of the sendmail program unless you don’t have sendmail installed or will prefer use SMTP anyway. In either case sendmail_from will refer to the email address that will appear as the default in the from section.

Getting Started:

In order to make it easier for the user to create messages from scratch we’ll provide an XHTML form with the following fields: email (that will be the sender’s email), subject, text content, and html content. Alternatively you can provide a field for the recipient(s) email but for spam purposes our public form will not utilize that. You can easily refactor it and provide that functionality by adding a single field.

<input name="email" size="20" type="text" />
<input name="subject" size="20" type="text" />
<textarea cols="40" rows="10" name="messageplain"></textarea>
<textarea cols=40 rows=10 name="messagehtml"></textarea>

Here is the full XHTML page with the form. Please ignore the plain styling – you can easily override the CSS and create some fancy styling. I will strongly suggest if doing that to get everything working first.
As you can see our form element uses the POST method and submits to the next part of our discussion: the mail.php document containing our message assembly and submission code
<form action="mail.php" method="POST">

Now let’s look closer at what happens behind the scenes and how our message gets processed. To be able to successfully accomplish our goal we need to examine the anatomy of an email message. An email consists of three components:

• the envelope – includes routing information for your message and is used by the MTA to transfer your email over the network. Typically you don’t need to be concerned with the envelope as it is not visible by the user.
• the headers – the headers are the most intererting part of an email containing processing information. Some are mandatory: Date From, To, (or BCC) while others are optional: Subject, Cc, Reply-To, Received, Message-Id.
• the message body – this is the section with the actual content of your email message. The body is separated from the headers by a single blank line.

First we need to create our mail headers correctly. Let’s look at an example of what our headers need to look like:

From: <admin@nedkoko.com>
To: <recipient@domain.com>
MIME-Version: 1.0
Content-Type: multipart/alternative; boundary=”fU3W4Vzr4G3D54f3″

Keep in mind that this is a simplified version of the headers but it works great for the purposes of our demonstration. Note that for content type “multipart/mixed” is used to send messages with different Content-Type sections (usually attachments) but for our purposes we want to use “multipart/alternative” which signifies different (“alternative”) versions of the same content.
Ok, now that we know what our headers need to look like we can start our form processing by extracting the content from our submission:

$email = $_POST['email'];
$to = 'nedko1@yahoo.com';
$subject = $_POST['subject'];
$messageplain = $_POST['messageplain'];
$messagehtml = $_POST['messagehtml'];

Now that we have our form content we need to create our boundary for separating the different parts of the message. A good way to do that is to use some kind of hashing which will guarantee uniqueness and will be different for each message. For that purpose i decided to use and MD5 hash algorithm applied on the current timestamp. That will satisfy our requirements and provide a 128bit value we can use for separation.
$mime_boundary = "----=_NextPart_X[".md5(time())."]";.
Let’s proceed next with creating a nice little header based on what we have so far:

$headers = "From: <admin@nedkoko.com>\r\n".
"To: <".$to."> \r\n".
"MIME-Version: 1.0\r\n" .
"Content-Type: multipart/alternative; ".
"boundary=\"".$mime_boundary."\"\r\n";

As you notice the “boundary” is not a separate header as it’s not separated on a new line as the specs require. That is because it is considered as a part of the “Content-Type”. It’s time to pay more attention to our actual message which will follow our headers separated by a blank line. Since we have multiple sections of our message body we will start each section with “–” followed by the boundary, followed by the content type and encoding. As we have two sections: text and HTML versions we start with the text:

“–”.$mime_boundary.”\r\n”.
“Content-Type: text/plain; charset=\”utf-8\”\r\n”.
“Content-Transfer-Encoding: quoted-printable\r\n\r\n”.
$messageplain.”\r\n\r\n”.

Then we do the same with the HTML version. Again we provide “–” with the boundary, content type and then the encoding:

"--".$mime_boundary."\r\n".
"Content-Type: text/html; charset=\"utf-8\"\r\n".
"Content-Transfer-Encoding: 8bit\r\n\r\n".
$messagehtml."\r\n\r\n".

Looks like we are finished with both versions of the message so now we have to wrap it up and specify that this is the end of our body content:

"--".$mime_boundary."--\r\n";

Note that the end is demarcated by “–” both in front and after the boundary, making if different from separator between different parts of the body. Finally, we can apply some basic form validation (optional but recommended) and call the mail function to process our mail request. It is important to mention that the mail function can be invoked with @ in order to suppress any errors it generates. Even better it returns a boolean value specifying if the message was successfully sent so we can then include some extra logic to provide feedback to the user.

if (mail($to,$subject,$message, $headers))
{
echo "<h4>Your message was sent successfully. </h4>";
}

Mission accomplished! Here you can download a zip of the full mail.php as well as see the full working version in action here. Hope this quick introduction has shed more light into email message formats and specifics of MIME.