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

The Sessions

The session was primarily held for the developers community and less for the corporate. This provided a relief as there weren’t much marketing gimmicks being played and the speakers were purely techie guys which proved to be an onus. BEA has upgraded their Weblogic Server to version 10.2 and their Workshop too. I had worked on the BEA workshop studio and Aqualogic platform for ESB earlier. So my main interests lied in what new features these upgraded products had in their offerings. After having attending this session I am now all the more excited to work in the BEA platform.

Although many people were awestruck with the features and some felt jealous for continuing to work on the older versions at their workplace, one thing was going through the minds of many including mine. The question was as to what was the road map for these BEA products since now the acquisition by Oracle has got completed. There was a slight wave of concern over this merger on the current developers as well as for those who wanted to adopt to the BEA environment in future. Would Oracle continue to support active upgradation to these wonderful products or take away the key features from them to promote its own products? The concerns were raised higher during the session when the BEA guys told us that were not too sure of the road map either. We will have to keep fingers crossed for that.

There were 3 speakers for the entire session out of which 2 were from BEA, now christened Oracle BEA and one evangelist from Adobe. You may wonder where does Adobe form a part of the BEA endeavor? I was curious too. The curiosity was cleared by one of the BEA speakers on mentioning that Adobe had integrated its Flex platform for the BEA environment. Piggybacking for publicity you may call. But it is actually awesome.

BEA Java2SOA Revolution

The session started with the first speaker Sandeep Sonkusale who is a certified SOA Solution Architect for BEA speaking on the aspects of why an organization has to choose to the SOA infrastructure and the underlying benefits that SOA would provide. The briefing was accompanied with several high profile diagrams of how the world would be revolutionized if SOA would be adopted. I could see many people yawning to glory for this completely hypothetical preachy stuff. All were waiting for the meaty part i.e how to go about doing it. After waiting for almost 45 minutes for the briefing to get over, we felt a wave of relief when the second speaker took over with his laptop and workshop running on the presentation screen.

The second speaker was a young and smart looking Anil Sharma from the BEA product development team. His ascent was really professional. Right from the start to the end of a 2 hour long demo he had his cool even though people bombarded him with several technical queries. The demo given was on the entire new version of the BEA Workshop Studio. It is now entirely eclipse based and has all the earlier separate workshops integrated into one. This means that having workshop installed on your system you can build all the components of J2EE architecture, create web services, build beehive controls for exposing the J2EE components as services, convert these controls to web services, perform BPM process flows and later expose them too as services, connect all controls or services to Aqualogic Service Bus, convert the services to presentation portals and much much more. Phew! This entire demo was a roller coaster for me but it was real fun.

The key points which I found to be useful were the ones which the speaker was emphasizing on and on. It is not necessary that you need to create web services for making your architecture SOA enabled. You can have services like EJB services, custom control services as well web services to make an SOA. Controls are used to expose EJB’s or POJO’s as services and these are not Weblogic specific. In fact they are Apache Beehive controls which are a part of JSR 175, hence vendor lock-in can be avoided. I am not too sure if any other J2EE provider has beehive controls implementation apart from Weblogic 10.2. The interfaces and implementations of web services are done using the JSR-181 constructs.

I got to understand the use of BPM through this session. Before this, I was really hazy as to which use cases BPM really favors. Anil, through his demo explained this in a peculiar scenario. When there is a need to have an entire stateful process as a service it can be implemented as a BPM workflow through the Workshop itself. This can be further exposed as a service. Services can be further integrated into the Aqualogic Service Bus (ALSB) for implementing a transactional service workflow. It is important to note that the services integrated into the service bus must support transaction to have transactional behavior.

The major surprise to me was the merger of DSP into the Workshop. In between the workflow wherever you need a transformation of data you can easily use Data Services transformation either through XQuery or Java right within the workflow. This was something amazing.

Finally shown, were the presentation services based on Weblogic Portal platform. In order to create presentation services BEA workshop comes built in with NetUI which is the pageflow modeller for the Struts framework. Using NetUI you can create Struts JSP views directly from exposed services which further can be converted to WSRP portlets and integrated into the application portal. The most surprising aspect of the WSRP portlets is that you can access the portlet remotely too. This means that your view would be actually rendered from a remote server!

Adobe – Getting More and More Flexy

From 9:30 am to 12:15 pm the BEA guys took the center stage. The Adobe guy was nowhere to be seen. Right at 12:15 pm he popped from somewhere with his laptop and took charge. His session may have been just a 45 minute one but the impact was majestic. He transformed the crowd of almost 200 odd people to the edge of their seats and eyes wide gaping to the screen with his magical Flex demo. It was showtime for Raghu Rao, evangelist for the Flex platform for Adobe. His charisma was attention capturing and the way he breezed through the Flex demo, he left the geek’s including me, craving for more.

The presentation involved the showcase of Flex as a presentation level service for the BEA platform. He presented how Flex can be used for accessing the services exposed from the BEA environment into the presentation tier. This included the use of the commercial Adobe product LCDS which is an enterprise level Flex platform for services. If you do not want to go the paid way, you can use BlazeDS which is a open source freeware, but with limited capabilities, suitable for small applications. Using these you can make callouts to the hosted services using the Action Message Format (AMF) for remote calls.

The major source attraction proved to be the Flex demo’s, which included the Nokia Shop and a sample consumer application. The Flex charts components and 3rd party flex UI components such as coverflow component and the Flex Book component snatched away everyone’s breath.

Final Notes

Such sessions really help in accessing the direction of where technology is heading to. I am thankful to Anil and Raghu who personally cleared my confusions over some aspects offline. I felt bad to keep Raghu away from his food since I kept him bugging with my questions. He had to catch a flight to Bangalore a little while later. If you would like to evaluate the all new BEA Weblogic 10.2 platform head straight towards their eval guide for getting started and also win a 32 GB Ipod by taking this survey.

Check out the day’s captures on my picassa web album.

Related posts:

• Developers Dilemma – pride or prestige
• What Makes Facebook Win Over Orkut?
• Mozilla’s New Killer App – The WebRunner
• BEA Aqualogic Data Services Platform – First Glimpse
• 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!

According to the research done by Chris for enterprise applications, here are some of the important points which the paper elaborates:

1. Make use of the POJO approach, with lightweight frameworks like Hibernate for ORM and Spring AOP for transactional activities.
2. EJB 3 makes it possible to have your business logic sit within your POJO and also make it run outside the container which makes it really usable.
3. Implementing 3 tiers for an application which commonly include
   1. Presentation tier
   2. Business Interfaces for encapsulation + Business tier logic in classes
   3. Persistence tier for handling transactions and concurrency
4. The design should involve,
   1. Modeling your business classes appropriately
   2. Code structuring principles for easier maintenance
      

While the above points are usually very well known amongst the developer community, it helps if you know which decisions should be taken when. Design patterns which have been established over the years play a key role in making such decisions. The white paper explains a few of the design patterns which are particularly mentioned when enterprise applications are into consideration.

I would like to enumerate here, some of the different design patterns which are highlighted in the paper, according to the decisions which fall into 3 main categories.

Decision #1 – Organizing Business Logic

When you have to implement the business logic it is very important to identify the scope and the scale of the application to decide one or the other approaches as stated below,

Transaction Script Pattern:

1. Does not follow the object oriented principles
2. Methods are mapped to application request from the presentation tier, which are called as Transaction Scripts
3. Follows the procedural approach which makes classes less important and methods more important
4. Simple to implement but difficult to understand and maintain the code
5. Mainly used when business application is small

Object Oriented Approach:

1. Maps the objects from real world to the application
2. Easier to understand the application logic
3. Behavior and state are encapsulated inside the mapped objects
4. Lightweight frameworks help to apply this approach to your application.

Table Module Pattern:

1. Involves mapping of database tables to business classes
2. An object of a table includes all rows of the table rather than a single object mapped to one row
3. It suffers from the problem of maintenance.

Decision #2 – Encapsulating of Business Logic

Well designed Business applications always encapsulate logic from the view. This helps in application scalability and security, at the same time providing loose coupling between the different tiers. The patterns which can be adhered to encapsulate business logic are:

Session Facade Pattern:

1. Promotes proper encapsulation of business level logic
2. Handles transactional behavior, security and presentation tier requests
3. Does caching of objects to prevent memory overloading in case of many requests
4. Delegates requests to proper business objects
5. Was earlier implemented by using EJB 2 Session Objects
6. It is heavy on memory and time consuming for testing and development

POJO Facade Pattern:

1. Business logic encapsulated within simple POJO’s
2. Easier to develop and test and can run outside the container
3. Transactions , security and state can be maintained through AOP
4. Spring framework uses this pattern
5. Light on memory
6. Makes use of Dependency Injection for wiring the business classes instead of using JNDI
   

Exposed Domain Model Pattern:

1. Used to avoid extra code for designing the facade
2. Presentation tier can directly access data objects
   
3. Makes use of AOP to access business objects without an intermediate facade layer
4. Drawbacks include the requirement of transactions and data handling by presentation tier
5. Risky since presentation tier can directly manipulate persistent data.

Decision #3 – Database Access

The decision of accessing data is of strategic importance since IO has a major impact on application performance. So apart from making a decision on the databases and normalization it is crucial to have the best approach for accessing it from other tiers in the application. The paper emphasizes that,

Direct JDBC has drawbacks such as:

1. Boiler plate code for handling connection and fetching of data
2. Database specific SQL reduces the portability of the application
3. Maintenance of low level SQL poses problems from schema changes
4. Can be of advantage when vendor specific features have to be accessed

To overcome the disadvantages of JDBC, using a framework like the iBATIS Framework can be advantageous since:

1. Direct SQL queries can be used
   
2. Provides mapping between resultsets and Java Beans through XML descriptor

The Advantages that Persistance Frameworks offer are:

1. Mapping of data to domain objects
2. No need to write SQL code
3. Flexibility offered by configuring XML descriptors for domain level objects and data
   
4. Loading & updating of database as and when required
5. Transactions and concurrency are handled by the framework

Enterprise applications should be modeled and designed properly from the early phases itself. Without following proper approaches from the ones mentioned above can be an invitation for trouble. I hope that these approaches help the developers to come up with good designs for enterprise applications.

Related posts:

• Design Patterns – Building blocks for your application
• Author
• Web and Desktop Apps – the 3rd World War!
• SOA – Still Far from Reality
• Java EE – Exhaustive yet Enchanting

The answer to these questions always comes in as “it depends” because requirements differ project wise. It might not be the case that the project which you might be working on will be requiring the same framework used in the prior projects. Requirements vary all the time and the framework which comes very close for implementing the specified tasks would be the best framework for you.

Having said that it is important to list down the key points on why you choose a particular framework. It is never a good reason to choose a framework just because others say it is cool. Let us focus on the key points for deciding a framework. Keep in mind, I am not trying to impose the usage of suggested framework for any particular project. This is a topic of general discussion in case where you might be eager to try out a new framework but are stuck to the choice of framework to start from.

The key points which might help you to make your choice are (not in any particular order):

• Popularity
  • Helps in getting acquainted quickly (eg: Groovy)
• Market
  • Easier to find jobs (eg: Struts)
• Convenience
  • Should not take a huge learning curve (eg: Tapestry)
• Time to implement
  • Should make the task get completed quickly
• Scope
  • Should be pluggable with other frameworks (eg: Spring)
• Documentation
  • Most important without which you will get stuck easily
• Forums
  • The more big the community the easier is your work done
• Bug tracking
  • If at all you tend to go deep, ticketing support should be present
• Reference Books
  • Essential since online searching can eat up your time
• Light weight
  • Complex ones will do no good if is not used much (eg: EJB 2.x)
• Robust
  • There should not be any known bugs for the features you want to implement
• Features
  • Makes good the time spent if one is more powerful than the other.

These are the 12 key points which I feel are very important when I look forward to work on a self project or am willing to learn a new framework. It is not necessary that all the 10 will be satisfied by one single framework. So it would be more beneficial to make a subset of these key points for shortlist your choice of frameworks based on your project.

How to finalize on a particular framework?

First, decide on comparing 2 to 3 frameworks at the max. The more you have in mind, the more confusion it will create. Plan out which features you want to implement for the given set of requirements. Do an exhaustive search on Google whether the features are provided by the frameworks you have in mind. Give points out of 10 for each of the subset key points. Compare the frameworks for the same subset of key points.

This will help you to make a matrix out of your choices and will further make it much easier to finalize your choice since now you would be sure of the reasons you are making a decision.

What are your key points when you first think when you pick a framework to work upon? It would be an interesting discussion to follow up. How did you shortlist your framework for learning or working on a project?

Related posts:

• First step in Ajax – Choosing the right framework
• The Struts Framework – Why choose it?
• Optimal use of Ajax – use Ajax the smart way
• Ajax Frameworks – Server side versus Client side
• What Do You Dream For In An IDE?

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

BEA is known for its well diversified technology stack of Weblogic Java Application Servers, SOA products and the Aqualogic suite of ESB and BPM products. Also to mention that BEA holds a strong integration of all the above suites into its Weblogic Workshop which has been built around the Eclipse platform.

Oracle on the other hand too has an array of similar products including Appservers, ESB, SOA and BPM. Then the question arises as to why Oracle is acquiring BEA? Some insights to the things apart from the product suites clash should be taken in consideration here to understand Oracle’s point of view.

Oracle entered into an acquisition with BEA Systems after it offered $19.375/share which is nearly a 40% premium over the October 2007 price when Oracle had done its first bid. This can be seen as a state of urgency on the part of Oracle to acquire BEA. Some speculation can be allotted on to the latest SOA offerings of BEA which could have made Oracle think for a big upgradation in their services.

Thinking other ways, Oracle might just be preparing for a tussle with the other giants such as IBM and SAP for gaining the market share in providing SOA infrastructure. With the BEA acquisition, Oracle will be in ready position to flash a list of clientele from BEA’s portfolio to match with the competitors. With the future plans of BEA for SOA, Oracle’s merger plans must have been really thought out.

It might be also a case of killing the competition. Big players often tend to downsize the smaller fish by making them surrender. This can be a case with Oracle too. Having a chance to get the customer base from BEA, it can simply kill off the competition by either junking off all BEA products off the line or by carefully integrating BEA products with its middleware and offering separate flagship services, just as it has done after acquiring PeopleSoft and JDEdwards.

Organizations today are keen to have a single suite of products to manage their businesses and middleware competition is on the rise. This probably makes Oracle’s target to claim for a one vendor many solutions more justified. But for the developers its more than a platform choice because now it would be choosing between their career paths too. I also have worked on Weblogic App server with Oracle database as the backend. With this acquisition, developers like me will have to decide on which path to opt for.

If Oracle junks off BEA products for killing the competition it might give rise for fear within the Weblogic community. Hopefully, if Oracle makes a decision of providing a flagship line of BEA products, the developer community will be more than happy to flash the name of Oracle on their resumes. This will be clear only in the mid of 2008 when the acquisition will be completed. The major question now lies as to what would a Java EE developer do in such a situation?

Related posts:

• 5 Most Exciting Search Tricks with Google Operators
• BEA Dev2Dev TechDays – An Experience
• Best Tools For Editing Your Photos Online
• Why Sybase is similar to Microsoft’s SQL Server
• Design Patterns – Building blocks for your application

uCertify SCWCD PrepKit comes forward as a breath of fresh air to break away the eeriness which comes to people while facing a exam. The look of the PrepKit is unique and new such that it compels us to explore more than the PrepKit itself. The practice exams are of course are the major highlights as it should be, but the features complimenting them come with a surprisingly elegant experience.

uCertify PrepKit Features

uCertify has done a commendable effort in putting together a product in making the user to develop a liking for the exam experience. The PrepKit acts like a tutor in cases you have a difficulty in answering. After using uCertify PrepKit you would feel as you have got more than what you were expecting. These reactions are not only mine but also of those people whom I have shown this PrepKit.

The features of uCertify include:

1. 4 practice exams
2. One final exam (which might be saved for the D day)
3. Adaptive tests
4. Customized tests (These are of great use)
5. Test History
6. Readiness Reports

Mock Exams

Each of the practice tests contains a number of 45 questions. I am not quite sure why they chose 45 questions when the exam should contain a set of 60 questions. The final exam consists of 40 questions. The difficulty level of the questions is somewhat easier than other simulators such as Whiz labs or JWeb Plus. They very well cover the basic aspects of all the topics. If I compare them to the exam questions, they are almost of same nature.

I have contacted uCertify myself to check on the issue of 45 questions and they did reply to me saying that the PrepKit was just in the preliminary stages. If that’s the case then you should watch out for the future releases.

Readiness Reports

The reports show the percentages you have scored in each of the tests including the custom tests. The likeable feature in this is that the reports allow you to get a retest done based on the categories. The categories include:

• Answered wrong
• Answered right
• Un attempted
• All questions

User Interface

When I opened the PrepKit the UI impressed me the most. It has a special feel of user friendliness. It is great in usability perspective and I would attribute another adjective to its aspect, which is “helpful”. This means that the PrepKit at all times keeps you aware of where you might have gone wrong and to where you should correct yourself.

Apart from the above features, uCertify comes packed with a bunch of nice features. I am separating out these features from the above ones because I have not found such features in other PrepKits. These are:

1. Study Articles
2. Tagging, Book marking, Rating
3. Interactive Quiz
4. Flash Cards

Special Features

The PrepKit has some special features such as tagging, rating of questions and book marking which can prove to be very effective. These 3 features appear in all places such as while giving the test or while going through the flash cards. So when you tag or rate a particular topic you would become more confident when you witness it again in a test or while revising.

Interactive Quiz

You don’t have to wait to finish with your preparation to give exams. This PrepKit comes with an interactive quiz feature. In this, all topics of the syllabus have a set of 12 questions each. You can choose combinations of the topics which you want the quiz to be based on. In this way, you can skip the topics you haven’t prepared and take a quiz. Based on the quiz results you can decide if you are well prepared in those chosen topics or not. You can also set a timer for each question. In my opinion this interactive quiz comes best when you don’t have the time to give a full length test.

Study Articles

You get Study articles as yet another feature. All the topics have been covered and there are in all 196 articles to read from. This feature serves the best as a last day preparation. The articles and very concise and provide many examples. They cover all those aspects which are very essential to remember.

Flash Cards

You must have seen flash cards. You may have used them to remember difficult words in English. But here you can find them in this PrepKit for remember the core concepts for SCWCD. The flash cards are based on the study articles so it might be helpful if you try to remember through flash cards after you have been through the Study articles.

Tagging / Rating / Bookmarking

The best part of tagging questions is that they can be used while creating a custom test too. Suppose you tag certain questions or topics as “difficult “ either while giving a quiz, reading flash cards or giving a test, then all these tagged questions can be clubbed together to form a new custom test. Doesn’t that sound interesting?

The same is the case for rating where you can rate any question from 1 to 5 stars. One single group can be then formed from the similar rated questions. You can also bookmark any question for further reference any time you need.

The all new ‘How To’ Feature

Hey you get a bonus too from the ‘How To’ feature. At present there is a single document which tells you how to go about using Tomcat. The document is very well illustrated. It is indeed impressive for an exam PrepKit for including practical know how’s. I hope they include more of such documents.

The current cost of the SCWCD PrepKit is USD 29.99. But you can test it with a demo version. To conclude, I will say that you should definitely give a try to the uCertify PrepKit and check it out for yourself. Even if you are willing to give any exam other than SCWCD, uCertify has a variety of simulators to choose from.

Finally, wishing you all the best from my side if you are going for SCWCD. If you have just started with your preparation then you might as well read my SCWCD preparation plan.

Related posts:

• SCWCD – Mission Accomplished 2
• SCWCD – The 3 Steps to Success!
• Servlet 3.0 – The Journey Begins Now
• Different People Different Networks – Shelfari and BottleTalk
• Adobe Reader 8.0 – Fully Loaded

 Unsupported major.minor version 49.0

This error is given because the new features introduced in the newer version of Java are not present in the older version. So you have to be careful for using such class files on older environments. For resolving this error you have to follow some simple tips as follows:

1. Check you java version by running the command java – version
2. Check your environment variable JAVA_HOME and the path associated with it
3. Check your server installation if it was installed on an older version
4. Check which path exists in the environment entries

These are the quick tips you would need to do in order to get rid of the error. Sometimes it may happen that the system which you are using might be loaded with 2 to 3 version of Java and you might be required to work on the newer one. In such cases always there is a confusion as to what went wrong and with which version. So if you are left in such crises do the following quick action tips:

1. Edit your JAVA_HOME with the latest java home folder path
2. Edit your path variable which might already have been set with older version
3. For this goto My Computer > Properties > Advanced > Environment Variables > path
4. Remove the earlier version path which might be something like <java_installed_path>/bin and replace it with newer version path
5. If your server was installed on a older version of Java and if it not been used then its better to uninstall it and then install it after making the above changes.

Note: You can check if your server was installed on an older version or not by opening the startup.bat of your Tomcat server or any start up script of other servers and finding the part where the script itself sets the JAVA_HOME variable. If you find that it has been set to a older version then it won’t do any good just by replacing it with a newer version path. You would ultimately have to reinstall the server as per my understanding.

It would be interesting to know if the same can be resolved without having to reinstall the server. Please suggest some alternatives if you have.

Related posts:

• Wordpress Database Error – Table ‘wp_post2cat’ doesn’t exist
• Wordpress Error – “Allowed memory size of 8388608 bytes”
• Working With JAX-WS in JDK 1.6
• J2EE or JEE, Java 5 or Java 1.5 – Is SUN Crazy?
• 3 Easy Steps to Install MySQL on Windows XP

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