Having said that, the major question which strikes anyone who does majorly JDBC is that how does a Hibernate DAO layer look like. Without looking at a practical implementation one cannot be easily convinced to work on it. This is the only compelling reason why I intended to write The Great Hibernate Tutorial.

This tutorial is aimed at those developers who want to get a quick breifing on how to implement a DAO layer using Hibernate. This tutorial does not cover the basics of ORM nor a detailed explanation of Hibernate configurations or api. It follows on the same route as the Great Ant tutorial which many readers liked.

5 Steps to Designing a DAO in Hibernate:

1. Identify the tables which are required as entities in your project
2. Create the Hibernate Configuration file
3. Create the Hibernate entity mapping files (hbm) and entity classes
4. Make the DAO layer with the required functions
5. Test the DAO classes

Required Softwares

The versions of the various open source software’s required for the implementation are

• MySQL 5.0.5 for Windows
• MySQL ConnectorJ
• Hibernate Core 3.0
• JDK 1.5 or above
• Eclipse 3.3 or above

So lets get going with the Great Hibernate Tutorial. The steps will explain you the specific details from the code while the actual code is present in the format of links at the bottom of this tutorial. You can open the links in different tabs of your browser and then start reading the tutorial for getting a better understanding.

Step 1. Identify the tables which are required as entities in your project

For the tutorial I am designing a basic Attendance System for a company which currently has only two tables Employee and Dept. If your MySQL is not setup at the moment you may visit the tutorial on how to setup Mysql in windows XP.

 
CREATE TABLE `employee` (                                                                                       
            `psno` int(11) NOT NULL default '0',                                                                          
            `name` varchar(50) default NULL,                                                                              
            `pass` varchar(50) default NULL,                                                                              
            `proj_cd` varchar(45) NOT NULL,                                                                               
            `dept_name` varchar(45) NOT NULL,                                                                             
            PRIMARY KEY  USING BTREE (`psno`),                                                                            
            KEY `FK_employee_newfk` (`proj_cd`,`dept_name`),                                                              
            CONSTRAINT `employee_ibfk_1` FOREIGN KEY (`proj_cd`, `dept_name`) REFERENCES `dept` (`PROJ_CD`, `DEPT_NAME`)  
          ) 
 
 
CREATE TABLE `dept` (                   
          `PROJ_CD` varchar(45) NOT NULL,       
          `DEPT_NAME` varchar(45) NOT NULL,     
          `START_DATE` date default NULL,       
          `TYPE` varchar(45) default NULL,      
          PRIMARY KEY  (`PROJ_CD`,`DEPT_NAME`)  
        )

The Employee and Dept have a one to many relationship. From the DDL it is evident that Dept table has composite keys. Usually composite keys are considered evil , but I am using it just for the sake of presenting a use case of configuring composite keys in hibernate.

Step 2. Create the Hibernate Configuration file

The Hibernate configuration file is where you provide all the connection level details. It is very straightforward configuration and appears similar to your JDBC connection statements. But unlike JDBC, you can specify many more things here like caching, dialects, debug queries. One important aspect of this configuration file is providing path of hbm files. Check the following two line of XML.

<mapping resource="com/abc/entities/Employee.hbm.xml"/>     
<mapping resource="com/abc/entities/Dept.hbm.xml"/>

These lines are important. They specify the paths to your entity mapping files. Entity mapping files are those XML files which tell hibernate as to how the entity classes relate to the tables. It defines how the data should flow from class properties to the table columns. But you have to be careful in mentioning the paths to the mapping files. It is not required that the files be kept in the packages as I have done but it is considered a convention.

Step 3. Create the Hibernate entity mapping files (hbm) and entity classes

In this step we would be actually defining the mapping. I have kept all the entities in the package com.abc.entities along with the mapping files. The first element is obvious <hibernate-mapping>. Within this element you would most of the times define 3 elements: Class, ID and Property.

Class – the class for which mapping to the table is being defined

<class name="com.abc.entities.Employee" table="employee" lazy="false">

One extra attribute of the element you would notice is lazy=”false”. This is the lazy loading technique of ORM the details of which are beyond the scope of this tutorial. You may even not mention it.

ID – Primary key is an absolute must in hibernate mapped tables. Primary Keys are mapped to ID as follows

<id name="psno" column="psno">
	<generator class="assigned" />
</id>

Generator means how the primary key is populated. If it was auto generated in the table then the value should have been “auto“. The value “assigned” means we will set it in the application itself. In case of Dept, since composite key exists we should define it as

<composite-id name="deptPK" class="com.abc.entities.DeptPK">
	<key-property name="projCode" column="PROJ_CD" />
	<key-property name="deptName" column="DEPT_NAME" />
</composite-id>

Property – These are columns which would be made as properties having getters and setters in the class definition

<property name="name"/>

this would map name property of Employee class to the name column of employee table.

Associations in Hibernate

The above 3 are majorly used. Apart from that you can also mention cardinality mapping if required as follows:

<many-to-one name="dept" class="com.abc.entities.Dept">
	<column name="proj_cd" not-null="true"/>
	<column name="dept_name" not-null="true"/>
</many-to-one>

Since I have a composite key in Dept table I have mentioned two columns in the above mapping. This mapping can be read as “MANY Employees are related TO ONE Dept with help of COLUMNS proj_cd and dept_name“. These mappings are called as Associations in hibernate.

In the Dept mapping file since one dept can return multiple Employees, they would be returned in the form of a set. Hence we would have to map the set of Employee as:

<set name="employees" inverse="true">
	<key>
		<column name="proj_cd"/>
		<column name="dept_name"/>
	</key>
	<one-to-many class="com.abc.entities.Employee" />
</set>

The inverse=”true” says that the association is bidirectional which is another important concept in hibernate. In a bidirectional relationship you can reach an associated element from within one element and same applies the other way too. On the contrary you may even have unidirectional relationship in which you don’t specify mapping in the other classes.

Defining Entity classes

This is straight forward. Entity classes are simple Java Beans. You can view the class definition in the links provided at the bottom of this post. A no argument public constructor is a must in case you define a custom one.

One special case here would be for composite keys. Composite keys are defined in a separate class. After this, In the class where composite keys are required you would have to make a property of the composite-class-type.

Step 4. Make the DAO layer with the required functions

Finally we are the moment of salvation. The thing which we were waiting eagerly for implementing. The DAO layer. It is always a good practice to make a separate DAO class for holding utility functions. Hibernate requires that you always open a session before accessing the database and making transactions when you update the database. This requires repeatable lines of code.

So in order to avoid repeating ourselves its better to keep these lines of code in a DAO class as shown in the links below. Check for com.abc.dao.DAO.java. You may use the class as it is since it is a routine code. For coding your own classes to make use of the utility functions in the DAO extend your class with this DAO.

Lets have a look at AdminDAO. Since I belive in interface based implementations I have provided AdminDAO as an interface and AdminDAOHibernateImpl as its implementation which extends DAO. The code is kept simple for understanding purposes. The things worth pondering are:

In functions which do an update on the tables you have to carry the following steps:

1. begin();
2. getSession()….; // save or update
3. commit();
4. rollback();  //in case of HibernateException and throw any custom business exception if required

For fetching data you don’t need transactions so you don’t need to do the above steps. In this case you can just execute a query via the getSession() as follows:

Query q = getSession().createQuery("from Employee e inner join fetch e.dept where e.psno = :psno");
q.setString("psno", psno.toString());
Employee emp = (Employee) q.uniqueResult();

Hibernate Query Language

The above query syntax is called HQL (Hibernate Query Language). It is syntactically very similar to JDBC with the difference that HQL queries are based on objects and not on tables so the names are case sensitive and aliases to objects are a must.

In HQL, you can either fetch a single result when you know that there would be exactly one row fetched. When you know that mutiple records might be returned then you can fetch the list as follows:

Query q = getSession().createQuery("from Employee");
List<Employee> list = q.list();
return list;

Paging in Hibernate

You can obtain paging in Hibernate very easily without any additional efforts by applying a max results criteria

q.setFirstResult(firstResult);
q.setMaxResults(maxResults);

Doesn’t it feel really good. JDBC users might feel jealous at this time1

Step 5. Test the DAO classes

Now, to our final strike. The testing can be done with POJO’s. For the tutorial I had created a service layer since I usally access teh DAO layer through the service layer. So the testing was done on the service layer instead of the DAO as this application was small. You can however test out directly the DAO functions.

static void listTest(){
	try {
		List<Employee> employees = adminService.getAllEmployees();
		for(Employee emp: employees)
			System.out.println(emp.toString());
	} catch (AppException e) {
	System.out.println(e.getMessage());
	}
}

Wasn’t that a breeze? I hope that it was. Once you gain a thorough knowledge of ORM concepts then you would appreciate working with Hibernate even more. For further knowledge, I would recommend you to go through the impedence mismatch theory to know the fundamental flaws surrounding JDBC. Working with Hibernate would then be real fun.

Enjoy folks!

Resources for the tutorial

The below files are required for running the above tutorial. Copy these to your eclipse project and add the required libraries of hibernate and mysql before running the project.

Configuration
hibernate.cfg.xml

Package: com.abc.entities
com.abc.entities.Employee.java
Employee.hbm.xml
com.abc.entities.Dept.java
com.abc.entities.DeptPK.java
Dept.hbm.xml

Package: com.abc.dao
com.abc.dao.DAO.java
com.abc.dao.AdminDAO.java
com.abc.dao.AdminDAOHibernateImpl.java

Package: com.abc.service
com.abc.service.AdminService.java
com.abc.service.AdminServiceImpl.java
com.abc.service.DeptService.java
com.abc.service.DeptServiceImpl.java

Package: com.abc.exceptions
com.abc.exceptions.AppException.java

Package: com.abc.tests
com.abc.tests.DeptTest.java

Related posts:

• The Technique of Virtual Deployment in Tomcat
• The Great Ant Tutorial – a great jump start
• Impressive Google Chart Generator Scripts
• Tracing the route of technology
• Mozilla’s New Killer App – The WebRunner

So today without any procrastination, I intend to put down the simplest of the steps to configure and run MySQL on Windows XP in the quickest of the time. First and foremost, as I always tend to follow a course is, break down the task into 3 steps. They are:

Step 1: Getting the software

Download the latest version of MySQL from the community site. Unpack it into your desired folder. It is always a good practice to download the zipped archive of MySQL binary distribution since using the one click installer, you might sometimes lose the power of configuration manually.

Its also a better way to understand configuring manually since if you switch to a Unix based environment later on, you will have to carry out a similar procedure and there is usually no one click installer in such environments.

I unpacked MySQL in C:\Program Files\mysql-5.0.45-win32

Step 2 : Configuring the environment

While configuring in the Windows environment you have to do two things. One, putting a file having a name my.ini in the Windows folder of the operating system. Two, setting the path in your system environment variable. Here’s what you have to do:

Creating Option File (my.ini)

Go to your installation path of MySQL (In my case it is: C:\Program Files\mysql-5.0.45-win32) and rename the file my-medium.ini to my.ini. Open the renamed file in notepad and add the following lines, just beneath the line which says, # The MySQL server and above the line port = 3306:

[mysqld]
# set basedir to your installation path
basedir=C:/Program Files/mysql-5.0.45-win32
# set datadir to the location of your data directory
datadir=D:/workspace/data

The second line as shown above is, configuring your database directory. This means, the path which you assign to datadir will be the path where your databases will be created. You have to make sure that the path exists before you assign it. There will a data directory in the MySQL installed path. If you provide a different path to the data directory than this default one, you must copy the entire contents of the data directory in that path.

Finally, drop the my.ini file into your Windows directory. In my case, I copied the file into the path C:/Windows

Setting the environment variable

After completing the above step, goto

My Computer > Properties > Advanced >Environment Variables > System variables > Path > Edit

In the Value box, goto the end of the line and put a semi colon and the path of the MySQL bin folder. In my case I have put it as:

;C:\Program Files\mysql-5.0.45-win32\bin

Click OK 3 times and thats it with the configuration of MySQL. You are all set to test the installation.

Step 3: Final Configurations and Running MySQL

You are actually good to go for running mysql. For this, open up your command prompt and type in the command mysqld –console. This will start the mysql database server. Whenever you run this command henceforth you will see these lines at the end:

[Note] mysqld: ready for connections.
Version: ‘5.0.45-community-nt-log’ socket: ” port: 3306 MySQL Community Edit
ion (GPL)

When you see these lines, it means that mysql has started successfully. Its time to party!

Leave the command prompt open and start up another command prompt. For the first time you should do this:

C:\>mysql -u root -p
Enter password:

When it will ask for a password, just hit Enter. It will allow access to you without a password and will show up a prompt as:

Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 12
Server version: 5.0.45-community-nt-log MySQL Community Edition (GPL)

Type ‘help;’ or ‘\h’ for help. Type ‘\c’ to clear the buffer.

mysql>

Note that your database has anonymous access. It is not a secure thing to let it like that. You should always access the database with a password. So for setting up the password you will have to do the below steps. Put in the commands which are highlighted as shown:

mysql> update user set password=PASSWORD(“admin”) where User=’root’;
Query OK, 0 rows affected (0.00 sec)
Rows matched: 3 Changed: 0 Warnings: 0

mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)

mysql> quit
Bye

Once you have done this, try logging into the server again without a password. It must show the below error:

C:\Documents and Settings\xpuser>mysql -u root -p
Enter password:
ERROR 1045 (28000): Access denied for user ‘root’@'localhost’ (using password: NO)

This means, now your database is secure.You should be relieved that your mysql setup has got completed. Now every time you want to start in your database start the server in one command prompt and in the second command prompt login to the database server by doing:

C:\>mysql -u root -p
Enter password: admin

Thats it. Phew! I hope I remember the steps myself and now for my cup of cappuccino.

Related posts:

• How To Install Windows Live Writer
• Setting Up SSL on Tomcat In 3 Easy Steps
• The Great Hibernate Tutorial – a great jump start for beginners
• XP Installation – The 34 minute hiccup
• Feast Your Eyes With Firefox Piclens

Whatever the reason may be, editing a photograph is no layman’s job. Sometime people give up half way through when they do not find the required results. I recently found a something which might make your spirit rise higher when you will notice the results you get out of it. The name of the tool is Picasa. Its a tool from Google. I am sure you must have used it many time to upload your photos to the online Picasaweb. But did you ever try making collages from it. Picasa can generate some really amazing collages out of your precious photos and make them really gift worthy or send it amongst friends as a memoir.

So here’s how you can make collages out of your photos:

• Download and install Picasa if you don’t have it already from here
• When you open it Picasa will start indexing all your image folders
• Choose a folder of which you want to make a collage from
• Now carefully select the photos which are your favorite and which you want inside the collage
• Click the Collage button in the bottom bar
• Your collage will be loaded in the dialog mode
• You might not be satisfied with the collage at first so you can try one of the 2 tricks
• Press Shift and drag your mouse pointer on the collage window. You will see a change in the layout
• Keep trying till you are satisfied with a layout
• Sometimes, you might like a layout but not how the pictures are placed
• In this case press Ctrl and drag the mouse pointer. The layout will be same but the pictures will start to randomize in their placement.
• Once you are done, hit the Create Button and specify location as the “current folder”
• The collage gets created and gives you a chance to edit the collage
• Here you can try out interesting presets which include making the collage black and white or giving it a sepia tone or soft focusing it. You can have real fun over here.
• After finishing with the effect choose file > save. A backup of the original will automatically be made
• So here you are with a amazing memorabilia of your treasured photos. Sounds simple isn’t it?
  

You can do different types of collages in Picassa. The one above is called the “Picture Pile“. The other types include:

Picture Grid

Contact Sheet

You can always edit the collage features after saving it. But however there is no provision to change the photos of it later. You would have to again do the above steps for making a new collage.

Related posts:

• Feast Your Eyes With Firefox Piclens
• Best Tools For Editing Your Photos Online
• GOA Parade!
• Contact
• HP Snapfish India, For Cost Effective Printing

But I am not going to discuss the production environment over here. The topic under scrutiny is how would you deploy your web application virtually to Tomcat. For that we have to know what is virtual deployment and learn about its advantages.

What is virtual deployment?

Virtual deployment in simple terms means deploying a web application from a different physical location. In this case, you are not required to put the web application in its exploded war structure to the webapps directory. Most of the beginners, tend to develop their web applications directly in the webapps directory itself. This technique might prove the most simplest and the quickest but it is the most hazardous. This is because the moment you Undeploy the web application from Tomcat’s manager the web application gets erased off completely from the webapps directory.

I had tried the same, for the very first time since I had not much information, and it proved fatal. All my work had vanished in an instant. From that day onwards I stuck to using a technique of using development structures and deployment structures and used with Ant. But I found this, too cumbersome, if I had to learn a framework or try out a small sample code. I was not willing to write an Ant build file each time I had to try a web application nor I wanted to develop the web application straightaway in the webapps directory which had earlier destroyed my work. IDE’s might be of great help but I don’t usually have them when needed. For example at a friend’s place.

Coming back to the topic which I have to discuss, I recently found a good workaround for the above problem. Although I believe it might be used quite commonly to deploy web applications I am writing this for people who are facing the same problem as mine. The solution lies in deploying the web application virtually.

How to virtually deploy a web application in Tomcat?

When you virtually deploy a web application you are just saying to Tomcat that you have developed a web application which is lying in some other location and that the server should run it from that location itself. This is done by using a configuring element called Context. In Tomcat lingo Context is nothing but the web application itself.

So here is the technique of virtual deployment done in Tomcat. I am using Tomcat 6 for this example.

• Let’s assume that Tomcat is configured at the location C:/Tomcat6
• Place the Web application at some other location. For example D:/workspace/WebApp
• Start Tomcat. This is to test the hot deployment of our Context
• Now go to the path C:/Tomcat6/conf/
• Check if you have the directory Catalina and a subdirectory localhost within it
• If you don’t have them then you must make the directories Catalina/localhost within C:/Tomcat6/conf/
• Make a Context file and name it with any name, myapp.xml and place it within localhost
• You have to put a single element within the myapp.xml as follows
  

  <Context
  docBase=”D:/workspace/WebApp”
  reloadable=”true”/>

• The “reloadable” attribute is optional. The “docBase” attribute is required. It is used to specify the physical location of the web app.
• That’s it. Now you can do any kind of tests with your web application and happily see the changes with just a browser refresh.
• Try undeploying your web app now. The moment you undeploy, myapp.xml gets deleted from Catalina/localhost but your application will be intact. Isn’t that wonderful?
• For redeploying you would just have to make myapp.xml once again.

If you want to learn more about configuring Contexts and look at its different attributes then go through the tomcat reference. But before that, you would want to know what are the advantages of this technique.

Advantages of Virtual Deployment

When a context is configured, Tomcat runs it from the location directly where the web application is placed and not by making a copy in its webapps directory. In this case if you try to Undeploy the web application, Tomcat simply removes the context file from its directory and does not touch the physical web application. This is most convenient and easy way to deploy a web application to Tomcat without the fear of losing your work.

The second advantage of virtual deployment is that you don’t have to change anything in the server.xml. Whenever any change is made in server.xml the server has to be restarted for the changes to be applied. In case of using contexts the server automatically deploys your application when it finds any context newly configured with it.

The third advantage is that contexts can be even used to make your web applications classes hot deployable too. It is done as above using the “reloadable” attribute. Tomcat picks up any changes done even to the classes if “reloadable” is set to “true“. This can be very helpful and a time savior if you don’t want to waste time in restarting Tomcat again and again. It is however heavy on resources but might be useful in simple tests.

The fourth advantage is that you can dynamically change the name of your application itself. For example change the name of “myapp.xml” to “BankApp.xml”. Go to Tomcat Manager URL and refresh it. You will see the application name as “BankApp” which earlier was “myapp”. It doesn’t matter what the folder name is where the actual application lies. In our case it was “WebApp”.

The fifth advantage is something I found it to be the best of all. Your application would run even if it actually present on a remote machine. What you need to do is to just share the application from one machine, set the docBase path as the network URI and then access it. It would run like a locally hosted application.

The last but not the least advantage is to test a sample code on multiple tomcat’s. Let’s assume you want to test a feature of servlets to find whether it is backward compatible or not. So you can have a new Tomcat and an old Tomcat running on different ports. Put the context in both Tomcat’s and simultaneously test it out. You would have to refer to the Tomcat documentation for configuring Context in the older versions.

Now that you know how the technique of virtual deployment try it out on different servers like Glassfish or JBoss and let me know how you went about it. Cheers!

Related posts:

• Development and Deployment Structures – the perfect way to build a web application
• The Great Ant Tutorial – a great jump start
• Setting Up SSL on Tomcat In 3 Easy Steps
• Annotations in POJO – a boon or a curse?
• And I thought I Knew How Java Worked!

Following are the list of things one needs to take care while making an application to implement Internationalization.

1. Producing Content in Unicode

You need to make sure that all files which contain the multilingual content are in Unicode format. By default most text editors will store your file in ASCII which does not support other language characters. So after saving any content in ASCII format and loading it, your browser might not be able to display correct text in native language. Here you need to convert the file from ASCII to UTF format.

For example, the steps required for doing this if you are using Notepad are,

• Open your JavaScript or properties, etc. file in notepad
• Go to > File > Save As > Encoding
• Change Encoding from ASCII to UTF-8

2. Files needed to be converted to UTF

.properties

All your properties file should have a suffix based on the language in which the content is stored in this file. For example,

• For English, content_en.properties for French content_fr.properties and so on.
• Most java frameworks like Struts, Spring have inbuilt support to detect JVM locale and select the corresponding properties file based on the extension of the file & JVM/Browser setting. You don’t need to add any code to detect the setting and set the properties file

.java

Make sure that your JVM has set the parameter -Dfile.encoding=UTF-8

.js

Set charset attribute of the SCRIPT tag to “UTF-8″. For example,

<script type=”text/javascript” src=”./urscript.js” charset=”UTF-8″></script>

.xml

Use the steps as in the first example to make sure the content within the XML files in is UTF-8 format.

.html/.htm

Add this line to head of all html pages.

<meta name=”http-equiv” content=”Content-type: text/html; charset=UTF-8“/>

.jsp

Set Content-type explicitly through your server side scripts. To do this, add this line to all your jsp pages,

<%@page contentType=”text/html; charset=UTF-8” pageEncoding=”UTF-8″%>

3. Configuring the Web Server

Your Web Server has to be configured to set the Content-type of headers to UTF-8 since by default the web server will replace the Content-type-header to ISO-8859 encoding. For example:

• In Apache Web Server, edit httpd.conf to set AddDefaultCharset=Off.
• In Tomcat Server set connector settings within the server.xml file to URIEncoding=”UTF-8″

4. Handling Request & Response Objects

Make sure that before reading request parameters & writing to response objects set character encoding type to UTF-8. This can be handled using filters where all the contents coming in and going out can be set to UTF-8 encoding. For example,

• request.setCharacterEncoding(“UTF-8″);
• response.setContentType(“text/html”);
• response.setCharacterEncoding(“UTF-8″);

5. Creating Database with Unicode encoding

While using a database make sure that the database created has encoding set to UNICODE. Most of the database servers like Oracle, Postgress, MySQL and MSSQL have this support. In order to create databases with unicode encoding use the following query,

CREATE DATABASE MyWebApps DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;

Once all the above steps are implemented your web application will work smoothly for all UTF-8 supported languages. In some cases, you will have to take care of NumberFormat, DecimalFormat and DateFormat. There are some FAQ’s on internationalization provided by Sun to get you started. But feel free to put in your doubts related to internationalization via comments. I will be glad to help you out.

(Ninad Gawad is a Java EE Developer who blogs at Technology Discussion)

Related posts:

• Techtracer 2.0 is Coming
• Power of XRAY for Web Designers
• Feast Your Eyes With Firefox Piclens
• The Struts Framework – Why choose it?
• Plagiarism – Black Listing of Sites is a Must

A couple of days ago I was in such a situation. I am addicted to Firefox and already have a lot of plugins which increase my productivity. But in those couple of days, I was left with the dreadful Internet Explorer 6.0. Life became more difficult for me when I found myself opening up the Google homepage every time I wanted to search something. I did not have the rights to download the Google toolbar. But since I knew about Favelets I quickly made some and later found that even getting stuck with IE 6.0 did not matter any more.

How to make a favelet?

Suppose you are in a similar situation as mine and suppose you tend to search more in Google than do any other work. Without Google toolbar you would be just helpless. So I would explain here how to make a simple Google Search Favelet and a word-meaning finder.

Making a Favelet is not a difficult task. For a simple example, copy paste this line directly in your browser’s address bar.

javascript:alert("Hello World");

When you hit enter it would show you the prompt with the message. You can do this in any browser.

Now that the idea is clear lets start with our Google Search favelet. Do the below steps:

• Create a new bookmark in your browser and name it “Google Search”
• Put the below code in your bookmark location (the place where you put in the URL):

javascript:var keyword = prompt('Enter Keyword','');if(keyword!=''&keyword!=null)window.open('http://www.google.com/search?hl=en&q=' + keyword + '&btnG=Google+Search&meta=');void 0

• Remember to make the bookmark toolbar visible from your browsers menu for easier access.
• Try it out, When you click it , a prompt will appear for keyword entry and on entry it will open a window to show you the results.
• If you couldn’t make it, click this link or drag and drop the link on your bookmark toolbar.

Meaning Finder

Suppose you are in a habit to find out the meanings of difficult words when you are surfing the web. You would find it distracting to open Google on another window and search the meaning of the word by copy pasting it. Having a favelet which can just catch the highlighted word on the page and then open up Google and automatically do a search on the word would be something you would crave for. Let’s try to extend the above created favelet to make this happen. The two additional things which are required in this case are:

• Using the Google Trick define:keyword
• JavaScript function document.getSelection();
• Create a new Favelet “Define” and put in the below code:

javascript:var keyword = document.getSelection();if(keyword!=''&keyword!=null)window.open('http://www.google.com/search?hl=en&q=define%3A' + keyword + '&btnG=Google+Search');void 0

• Drag n drop the link to try the favelet. Select some word for which you want the meaning and then click the favelet on your bookmark toolbar.

Points to Ponder

If you are a JavaScript veteran, you can try out many interesting and complex favelets which can reduce many of your tasks. But you have to remember that since JavaScript behaves differently in different browsers, you would have to make the necessary changes in your Favelets in order to make them generic to all browsers.

Many of the social networking site often have a bookmarklet (same as favelets) which help you to bookmark a page into their network. Some examples are:

• Reditt Bookmarklets
• Del.icio.us Help Buttons

Some other useful favelets which I have found from the web:

• W3C Validator Favelets
• Web Design Test Favelets
• Favelets for Fun

I hope you found this article interesting and if you create any interesting favelet don’t forget to mention it here.

Related posts:

• Power of XRAY for Web Designers
• Impressive Google Chart Generator Scripts
• Search Results
• Ajax Frameworks – Server side versus Client side
• Ajax Exposed – Myth and Reality

What is Windows Live Writer?

Live Writer is a power blogging tool which helps in offline blogging. If you are a regular blogger then you might have used the ScribeFire Firefox addon. But Windows Live Writer is not just an addon its a full fledged blogging platform with many blog rich features. The features are fully in synch with the Wordpress platform.

The best part of blogging in Live Writer is that, it has a facility of providing you the actual template from the blog layout while you blog. This makes you feel as if you are directly writing on your blog layout than in the standard Wordpress TinyMCE editor.

Installation Steps

• For installation of Live Writer make sure you have the following system requirements. More important that it requires a .Net Framework.
• Download the Live Tools Installer. This installer is not the Live Writer Installer. Instead it is general purpose installer and lets you select more products to install if needed.
• Start the installation from WLinstaller.exe
• Accept the agreement policy.
• Uncheck all the check boxes. They are optional utilities.
• The installer then downloads the Live Writer installation. Please be patient as it takes quite a lot of time if you have slow connection.
• You don’t have to do check anything. The installation would immediately after the download is complete.
• Follow the further steps which include putting the login credentials, blog URL.
• Allow the installation to detect the blog layout settings and post a temporary post to verify. It won’t affect your blog since no test post is published.
• Start the Writer and blast away with your writing. Enjoy!

Live Writer makes you feel as if you are working in the Wordpress environment itself. Blogging with it will surely enthral you. Try it out and you will see the difference for yourself.

Also do check out the gallery of Live Writer Plugins and also the CodePlex development zone to make your blogging experience even more enjoyable.

Related posts:

• Go Live with Yahoo! Live
• XP Installation – The 34 minute hiccup
• TechTracer goes Live from today!
• Google Reader Search Goes Live!
• Feast Your Eyes With Firefox Piclens

• Use a server side framework to code in the chart
• Use a database to collect the report data and then code for the framework integration
• Insert chart image after generating a chart in a software
• Use some heavy JavaScript libraries which add to the loading time of the page

But if you had only a few outcomes and wished to show a simple chart in your web page to the readers of your website or blog then probably you would be fixed in a situation like this. The main reasons being:

• Use of an HTML only website or blog which does not allow server side scripting
• Lack of knowledge of using a chart framework even if you had server side scripting
• Burden of the process in creating a simple chart.
• Wastage of your precious time.

But with the power of Google Chart API in your hands all you need to know is to insert an image in your web page and watch your chart come to life. But if you are thinking that what could be the use of using a static image for showing a chart then you are wrong. The Google Chart API is so simple yet so powerful that can give you some amazing features:

• Create charts simply by using URL with some parameters
• Inserting the chart is as simple as you would be inserting an image
• The chart is created on the fly dynamically
• No need of server side coding
• No need of JavaScript to code or view your chart
• Any resolution of the chart with only a change in URL parameters
• Manipulating the parameters of the URL would change the chart
• A variety of styles to choose as per your tastes.

Doesn’t this sound pretty much magical. If the above features excite you then probably the process of showing you how to create a simple chart right in this article itself will be enchanting. So lets proceed ahead.

Creating a chart with the Google Chart API

Lets take a simple case study for our chart. Suppose you are writing an article on the trends in the usage of browser’s and instead of showing the data in tabular format you could show present the data with some visual cues. Charts are the perfect way to do it. You must have already been at a site which shows amazing chart representations for some reports. Google however does not have anything sleek yet in their chart varieties but hey they surely have simple and sweet ones.

I am taking the browser usage trends of my blog readers. According to the statistics the trends show that 60% of my blog readers use Firefox, 25% use MSIE, 10% Safari and 5% the rest.

So if I have to represent this data in the form of a chart then first of all I simply need to choose the chart type according to my liking from the various Google Chart Types. From all, I will choose the 3D pie chart. So for drawing the chart we will have to build a URL with in this fashion:

http://chart.apis.google.com/chart?<parameter 1>&<parameter 2>&<parameter n>

Select the particular chart name, In my case it is p3. So the first parameter of the URL will be:

cht=p3

Now for the data, I will use the Simple Encoding technique which is indeed, simple. According to the technique my data representation would be done as follows:

chd=s:8ZKF (Four characters for the value indicate the four divisons in the chart)

We have to specify the resolution for the chart. According to my blog layout I would choose a height of 200px and the width of 400px. So the parameter would be,

chs=400x200

Titles have to be given to the data representation. So, for each of the four characters above in the data we would have to give its equivalent number of pipe delimited titles as follows,

chl=FireFox|MSIE|Safari|Others

Finally we come to the coloring part. You can specify any color you require. The API automatically shades the other chart divisions if the appropriate number of colors are not provided. I want my chart to have shades of 2 colors, blue and green so I would give the last parameter as follows:

chco=1B75DF,92BF23 (Colors have to be in hexadecimal format)

Our chart is complete! Don’t believe it?. You just have to combine the URL with the parameters and put in your browser’s address bar or click here. Google will do the rest of the stuff for you.

http://chart.apis.google.com/chart?cht=p3&chd=s:8ZKF&chs=400×200
&chl=FireFox|MSIE|Safari|Others&chco=1B75DF,92BF23

Inserting the chart into your web site or blog

It is very simple to insert the chart into your blog or website. Since the resulting output of the URL is an image (.png) you just have to copy the entire URL and encapsulate it into an image tag as follows:

<img src=”http://chart.apis.google.com/chart?cht=p3&chd=s:8ZKF&chs=400×200
&chl=FireFox|MSIE|Safari|Others&chco=1B75DF,92BF23” title=”Browser Stats” alt=”Browser Stats”/>

You are seeing the live representation of the chart above. Isn’t this concept just fantastic? Now go ahead and start creating some visual presentations in your article and let me know about your creations.

Related posts:

• Impressive Google Chart Generator Scripts
• Search Results
• Unleash the Power in Your Blog with Google Custom Search
• 10 Most Amazing Google Search Tricks
• 5 Most Exciting Search Tricks with Google Operators

It might be good in a production environment to use OpenSSL but if you just want to test out SSL with Tomcat alone then it is more than enough to just have your JDK and Tomcat setups. So I would make you walk through the same steps which I did while getting SSL up and running and building a secured web app within a matter of minutes.

The things which I have used to setup SSL consists of:

• JDK 1.6
• Tomcat 6

Even though I have used the latest version I don’t see any problems which you might face in carrying out the same set of steps for JDK 1.5 which I am about to explain. JDK comes shipped with a keytool executable which is required to generate a keystore. The keytool can be found in the earlier version of JDK too. The 3 steps which would make you to get started with setting up SSL are:

1. Generating the Keystore file
2. Configuring Tomcat for using the Keystore file
3. Configuring your web application to work with SSL

Let’s get this party started now.

1. Generating the KeyStore file

The keystore file is the one which would store the details of the certificates necessary to make the protocol secured. Certificates contain the information as to who is the source from which you are receiving the application data and to authenticate whether it is the intended party or not. To make this keystore you would have to use the keytool. So open command prompt in Windows or the shell in Linux and type:

cd %JAVA_HOME%/bin on Windows

cd $JAVA_HOME/bin on Linux

You would land up in the Java bin directory. Now time to run the keytool command. You have to provide some parameters to the command as follows :

keytool -genkey -alias techtracer -keypass ttadmin -keystore techtracer.bin -storepass ttadmin

The highlighted words are the ones which you would have to change according to your requirements. But keep one thing in mind that both the keypass and storepass passwords should be the same. The .bin file is actually your keystore file. It would now start a questionnaire. So fill in the relevant details accordingly. Look below for a reference as to what to answer for the questions.

What is your first and last name?
[Unknown]: nitin pai
What is the name of your organizational unit?
[Unknown]: home
What is the name of your organization?
[Unknown]: techtracer
What is the name of your City or Locality?
[Unknown]: mumbai
What is the name of your State or Province?
[Unknown]: maharashtra
What is the two-letter country code for this unit?
[Unknown]: IN
Is CN=nitin pai, OU=home, O=techtracer, L=mumbai, ST=maharashtra, C=IN correct?
[no]: yes

The command would then conclude. It would make a .bin file with the name you had provided inside the bin directory itself. In my case it was techtracer.bin which was located in

C:\Program Files\Java\jdk1.6.0_02\bin\

Put the .bin file in the webapps directory of Tomcat. This is required to avoid the need to give an absolute path of the file in the next step.

2. Configuring Tomcat for using the Keystore file

Here we would be making some changes to the server.xml file inside tomcat to tell it to use the keystore which was created in the earlier step for configuring SSL. Open the file server.xml which can be found as:

<CATALINA_HOME>/conf/server.xml

Now you have to modify it. Find the Connector element which has port=”8443″ and uncomment it if already not done. Add two lines. The highlighted lines are the newly added ones.

<Connector port=”8443″
maxThreads=”150″ minSpareThreads=”25″ maxSpareThreads=”75″
enableLookups=”true” disableUploadTimeout=”true”
acceptCount=”100″ debug=”0″ scheme=”https” secure=”true”
clientAuth=”false” sslProtocol=”TLS”
keystoreFile=”../webapps/techtracer.bin”
keystorePass=”ttadmin” />

You can notice that I have given the path to the keystoreFile property as relative to tomcat bin directory because the startup command will look for the .bin file. Now all you have to do is start your server and check the working of SSL by pointing your browser to the URL to:

https://localhost:8443/

Now that you have your tomcat running in the SSL mode you are ready to deploy an application to test its working. You must note that still your tomcat can run in normal mode too at the same time i.e on port 8080 with http. So it is but obvious that any application deployed to the server will be running on http and https at the same time. This is something that we don’t want. We want our application to run only in the secured mode.

3. Configuring your web application to work with SSL

In order to do this for our test, take any application which has already been deployed successfully in Tomcat and first access it through http and https to see if it works fine. If yes, then open the web.xml of that application and just add this XML fragment before web-app ends i.e </web-app>

<security-constraint>
<web-resource-collection>
<web-resource-name>securedapp</web-resource-name>
<url-pattern>/*</url-pattern>
</web-resource-collection>
<user-data-constraint>
<transport-guarantee>CONFIDENTIAL</transport-guarantee>
</user-data-constraint>
</security-constraint>

Explanation of the fragment is beyond the scope of this tutorial but all you should notice is that the /* indicates that now, any resource in your application can be accessed only with https be it Servlets or JSP’s. The term CONFIDENTIAL is the term which tells the server to make the application work on SSL. If you want to turn the SSL mode for this application off then just turn don’t delete the fragment. Just put the value as NONE instead of CONFIDENTIAL. That’s it!

Conclusion

These were the 3 easy steps in which you can make Tomcat to work in the SSL mode and also it tells you how easily you can turn the SSL mode on and off. If you find any difficulty or are not clear on any of the above steps feel free to drop in your queries. If you like this tutorial it would be nice of you to drop in a comment of appreciation or feedback as to how this tutorial can be improved.

Related posts:

• The Technique of Virtual Deployment in Tomcat
• Implementing Websites For Internationalization
• 3 Easy Steps to Install MySQL on Windows XP
• The Great Ant Tutorial – a great jump start
• Eclipse Europa Has Ruined My Day

• JWSDP 2.0 pack
• JDK 1.5 or above
• The required Web Service WSDL
• Eclipse 3.1 or above

The procedure for creating the client have been broken down into 3 easy steps which are:

1. Creating the Stubs from WSDL
2. Building the Web Service Client using JAX-WS
3. Parsing the Output using JAXP

JAXWS & JAXP

JAX-WS is an API for creating as well as invoking web services. It succeeds the JAX RPC API and makes it easier by reducing the XML configurations, through the use of annotations available in Java 5. However you don’t need annotations for this tutorial.

JAXP is a wrapper API over the legacy XML parsing API’s such as DOM and SAX and leverages their usage through its generic interfaces. JAXP is typically used in a web service which is implemented with a Document Literal style. This is because such web services return an XML document and not a simple String Value. The XML Document then has to be parsed using the JAXP API.

So let us begin with the tutorial.

1. Creating the Stubs from WSDL

For this tutorial, I am going to use the Stock Quote Service available at webservicex.net. The web service demo shows you an XML document being returned when you enter in a stock ticker in the text box provided. The client which you will create in JAX-WS will invoke the GetQuote service and receive the same document which we will then parse using JAXP.

In order to invoke the GetQuote service you first need to have the stubs. The stubs can be created easily using the import.bat utility provided in the JWSDP pack. The path where you can find this utility is <JWSDP_HOME>/jaxws/bin. For using this utility you must set the JAXWS_HOME environment variable which points to the JAX-WS directory. For example I have set mine as:

C:\tomcat50-jwsdp\jaxws

Open the command prompt and go the path <JWSDP_HOME>/jaxws/bin. Use the WSDL path of the GetQuote Web Service and type in the following command,

C:\tomcat50-jwsdp\jaxws\bin>wsimport -s . http://www.webservicex.net/stockquote.
asmx?WSDL

This command generates the stubs which are required for invoking the web service, in the current directory. The -s switch is to generate source code of the stubs. We need to use these generated classes in the client.

Now open Eclipse and make a new Java Project. Name it whatever you like. Next, import all the above generated classes into the project. Remember all the classes have to be in the same package as they were generated i.e net.webservicex

2. Building the Web Service Client using JAX-WS

Create a package com.ws.client where we will place our client code. Make a Java Class called StockQuoteClient. You would now have to import a large set of JAR’s which would be required for running the client. The JAR’s which are needed are:

• jaxws-api.jar, jaxws-rt.jar, jsr181-api.jar present in jaxws/lib
• jaxb-api.jar, jaxb-impl.jar present in jaxb/lib
• saaj-api.jar, saaj-impl.jar present in saaj/lib
• resolver.jar, activation.jar present in jwsdp-shared/lib
• jsr173_api.jar, sjsxp.jar present in sjsxp/lib
• jaxp-api.jar present in jaxp/lib

That’s too much indeed! But trust me, you wouldn’t have your web service client running without these libraries. Now write the following code inside the main method of StockQuoteClient

 StockQuote service = new StockQuote();
 StockQuoteSoap port = service.getStockQuoteSoap();
 String quote = port.getQuote("INFY");	
 System.out.println(quote);

The code is simple. You first create a service instance of StockQuote. Then you get the port on which you want the function to be invoked. Here I have invoked the StockQuoteSoap port.

Once you get the port you are ready to invoke the service which is done by calling port.getQuote(“INFY”) where INFY is the stock ticker symbol for the company INFOSYS.

Now run this program as a Java Application in Eclipse. You would see a long running line of XML returned as a string which contains the details related to INFY stock.

3. Parsing the Output using JAXP

The returned XML output is undesirable since it cannot be read out easily. So now we have to use some API which would easily help us to get the required details in a nice and clean manner. This is where we would use JAXP. Now instead of printing out the output as it is, make a function parseQuote with which we will parse the XML returned. For this, in the main method, change

System.out.println(quote);

to

List<String> items = new ArrayList<String>();
items.add("Last");
items.add("Date");
items.add("Time");
items.add("Change");
 
parseQuote(quote, items);

You may be wondering what the List of items is used for. Well, instead of making the method for displaying all the information contained within the XML fragment, we would create the method more nicer, which will only display the contents of the tags actually needed. Hence we pass the tag names in a List as a second argument.

 
public static void parseQuote(String quote, List<String> items) throws Exception{	
	}

Its been made static so as to access it directly. You can either throw an Exception from the method or implement a try-catch inside the method. Use the below code inside the parseQuote method.

 
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
DocumentBuilder builder = factory.newDocumentBuilder();

In the code DocumentBuilderFactory and DocumentBuilder instances are used to get hold the document which we want to parse. The document is nothing but the XML output stored in the quote object. But in order to read the string, we would require to use it as

Document document = builder.parse(new InputSource(new StringReader(quote)))

and not directly. If used directly you would get a java.net.MalformedURLException exception. After getting a hold of the document we use a for in loop to check which items are required to be displayed.

for(String content:items){
	NodeList list = document.getElementsByTagName(content);
	Node item = list.item(0);
	System.out.println(content + " : " + item.getTextContent());	
}

The function to look out for is getElementsByTagName() which itself finds the tag names and gives the content within them. Remember for using this function, the tag name provided, must be any leaf element or else you would get a javax.xml.stream.XMLStreamException error.

Final Words

This is a very basic way in which you can build a web service client using JAX-WS and JAXP. The tutorial is aimed for getting started with these two API’s together. Further down from here, you can begin exploring in depth the wonderful features that these API’s provide.

You can copy paste the entire code provided here and use directly in your application.

Related posts:

• Working With JAX-WS in JDK 1.6
• SCDJWS preparation – a kick start guide
• Ajax Frameworks – Server side versus Client side
• SCDJWS – mission accomplished
• Eclipse Europa Has Ruined My Day