Ananth

Run MySQL in Windows

2008-11-06T23:04:00.000-08:00

Step 1: Open Command Prompt
C:\Program Files\MySQL\MySQL Server 5.0\bin>mysql -uroot -p

Step 2:
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| hibernatetutorial |
...

The above command shows all the existing databases.

Step 3:
Create new MySQL user
CREATE USER 'sark'@'localhost' IDENTIFIED BY 'sark';

Step 4:
Grant Permissions.
GRANT ALL PRIVILEGES ON *.* TO 'sark'@'localhost' IDENTIFIED BY 'sark' WITH GRANT OPTION;

Step 5:
To check the existing users.
mysql> select User,Host from mysql.user;
+-----------+--------------+
| User | Host |
+-----------+--------------+
| root | % |
| sark | localhost |
+-----------+--------------+

Step 6: To check the Permissions/privileges.

mysql> show grants for sark@localhost;
+-------------------------------------------------------------------------------
-------------------------------------------------------+
| Grants for sark@localhost
|
+-------------------------------------------------------------------------------
-------------------------------------------------------+
| GRANT SELECT, INSERT, UPDATE, DELETE ON *.* TO 'sark'@'localhost' IDENTIFIED B
Y PASSWORD '*A231ED0CF53E6EF33A1A79930EB2A82DB89812F2' |
+-------------------------------------------------------------------------------
-------------------------------------------------------+

Step 6:
Exit from root user and login as 'sark' user;

mysql> exit;
Bye

C:\Program Files\MySQL\MySQL Server 5.0\bin>mysql -usark -psark
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 43 to server version: 5.0.24-community-nt

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

mysql>

Step 7:
Create database 'sarkDB'
mysql> CREATE DATABASE sarkDB;

Step 8:
Use Database
mysql> use sarkDB;
Database changed

Step 9:
Create table demo_people.
mysql> CREATE TABLE `demo_people` (
`pid` int(11) NOT NULL,
`name` varchar(20) default NULL,
`phone` int(11) default NULL,
PRIMARY KEY (`pid`)
);
Query OK, 0 rows affected (0.23 sec)

mysql>

AJAX Introduction

2008-07-06T22:15:00.000-07:00

AJAX = Asynchronous JavaScript and XML
AJAX is not a new programming language, but a technique for creating better, faster, and more interactive web applications.

With AJAX, your JavaScript can communicate directly with the server, using the JavaScript XMLHttpRequest object. With this object, your JavaScript can trade data with a web server, without reloading the page.

AJAX uses asynchronous data transfer (HTTP requests) between the browser and the web server, allowing web pages to request small bits of information from the server instead of whole pages.

The AJAX technique makes Internet applications smaller, faster and more user-friendly.

AJAX is a browser technology independent of web server software.

AJAX is Based on Web Standards
AJAX is based on the following web standards:

JavaScript
XML
HTML
CSS
The web standards used in AJAX are well defined, and supported by all major browsers. AJAX applications are browser and platform independent.

AJAX is About Better Internet Applications
Web applications have many benefits over desktop applications; they can reach a larger audience, they are easier to install and support, and easier to develop.

However, Internet applications are not always as "rich" and user-friendly as traditional desktop applications.

With AJAX, Internet applications can be made richer and more user-friendly.

AJAX Uses HTTP Requests
In traditional JavaScript coding, if you want to get any information from a database or a file on the server, or send user information to a server, you will have to make an HTML form and GET or POST data to the server. The user will have to click the "Submit" button to send/get the information, wait for the server to respond, then a new page will load with the results.

Because the server returns a new page each time the user submits input, traditional web applications can run slowly and tend to be less user-friendly.

With AJAX, your JavaScript communicates directly with the server, through the JavaScript XMLHttpRequest object

With an HTTP request, a web page can make a request to, and get a response from a web server - without reloading the page. The user will stay on the same page, and he or she will not notice that scripts request pages, or send data to a server in the background.

The XMLHttpRequest Object
By using the XMLHttpRequest object, a web developer can update a page with data from the server after the page has loaded!

AJAX was made popular in 2005 by Google (with Google Suggest).

Google Suggest is using the XMLHttpRequest object to create a very dynamic web interface: When you start typing in Google's search box, a JavaScript sends the letters off to a server and the server returns a list of suggestions.

The XMLHttpRequest object is supported in Internet Explorer 5.0+, Safari 1.2, Mozilla 1.0 / Firefox, Opera 8+, and Netscape 7.

Your First AJAX Application
To understand how AJAX works, we will create a small AJAX application.

First, we are going to create a standard HTML form with two text fields: username and time. The username field will be filled in by the user and the time field will be filled in using AJAX.

The HTML file will be named "testAjax.htm", and it looks like this (notice that the HTML form below has no submit button!):

AJAX - Browser Support
The keystone of AJAX is the XMLHttpRequest object.

Different browsers use different methods to create the XMLHttpRequest object.

Internet Explorer uses an ActiveXObject, while other browsers uses the built-in JavaScript object called XMLHttpRequest.

To create this object, and deal with different browsers, we are going to use a "try and catch" statement. You can read more about the try and catch statement in our JavaScript tutorial.

Let's update our "testAjax.htm" file with the JavaScript that creates the XMLHttpRequest object:

Example explained: First create a variable xmlHttp to hold the XMLHttpRequest object.

Then try to create the object with XMLHttp=new XMLHttpRequest(). This is for the Firefox, Opera, and Safari browsers. If that fails, try xmlHttp=new ActiveXObject("Msxml2.XMLHTTP") which is for Internet Explorer 6.0+, if that also fails, try xmlHttp=new ActiveXObject("Microsoft.XMLHTTP") which is for Internet Explorer 5.5+

If none of the three methods work, the user has a very outdated browser, and he or she will get an alert stating that the browser doesn't support AJAX.

Note: The browser-specific code above is long and quite complex. However, this is the code you can use every time you need to create an XMLHttpRequest object, so you can just copy and paste it whenever you need it. The code above is compatible with all the popular browsers: Internet Explorer, Opera, Firefox, and Safari.

The next chapter shows how to use the XMLHttpRequest object to communicate with the server.

AJAX - More About the XMLHttpRequest Object
Before sending data to the server, we have to explain three important properties of the XMLHttpRequest object.

The onreadystatechange Property
After a request to the server, we need a function that can receive the data that is returned by the server.

The onreadystatechange property stores the function that will process the response from a server. The following code defines an empty function and sets the onreadystatechange property at the same time:

The readyState Property
The readyState property holds the status of the server's response. Each time the readyState changes, the onreadystatechange function will be executed.

Here are the possible values for the readyState property:
State Description
0 The request is not initialized
1 The request has been set up
2 The request has been sent
3 The request is in process
4 The request is complete

We are going to add an If statement to the onreadystatechange function to test if our response is complete (this means that we can get our data):

xmlHttp.onreadystatechange=function()
{
if(xmlHttp.readyState==4)
{
// Get the data from the server's response
}
}

The responseText Property
The data sent back from the server can be retrieved with the responseText property.

In our code, we will set the value of our "time" input field equal to responseText:

xmlHttp.onreadystatechange=function()
{
if(xmlHttp.readyState==4)
{
document.myForm.time.value=xmlHttp.responseText;
}
}

AJAX - Sending a Request to the Server
To send off a request to the server, we use the open() method and the send() method.

The open() method takes three arguments. The first argument defines which method to use when sending the request (GET or POST). The second argument specifies the URL of the server-side script. The third argument specifies that the request should be handled asynchronously. The send() method sends the request off to the server. If we assume that the HTML and ASP file are in the same directory, the code would be:

xmlHttp.open("GET","time.asp",true);
xmlHttp.send(null);

Now we must decide when the AJAX function should be executed. We will let the function run "behind the scenes" when the user types something in the username text field:

Our updated AJAX-ready "testAjax.htm" file now looks like this:

AJAX - The Server-Side ASP Script
Now we are going to create the script that displays the current server time.

The responseText property (explained in the previous chapter) will store the data returned from the server. Here we want to send back the current time. The code in "time.asp" looks like this:

<%
response.expires=-1
response.write(time)
%>

Note: The Expires property sets how long (in minutes) a page will be cached on a browser before it expires. If a user returns to the same page before it expires, the cached version is displayed. Response.Expires=-1 indicates that the page will never be cached.

MySQL - LEFT JOIN and RIGHT JOIN, INNER JOIN and OUTER JOIN

2008-01-21T22:38:00.000-08:00

Java API for XML Processing

2008-01-01T21:00:00.000-08:00

The Java API for XML Processing (JAXP) is for processing XML data using applications written in the Java programming language. JAXP leverages the parser standards Simple API for XML Parsing (SAX) and Document Object Model (DOM) so that you can choose to parse your data as a stream of events or to build an object representation of it. JAXP also supports the Extensible Stylesheet Language Transformations (XSLT) standard, giving you control over the presentation of the data and enabling you to convert the data to other XML documents or to other formats, such as HTML. JAXP also provides namespace support, allowing you to work with DTDs that might otherwise have naming conflicts.

Designed to be flexible, JAXP allows you to use any XML-compliant parser from within your application. It does this with what is called a pluggability layer, which lets you plug in an implementation of the SAX or DOM API. The pluggability layer also allows you to plug in an XSL processor, letting you control how your XML data is displayed.

The basic outline of the SAX parsing APIs are shown in Figure 4-1. To start the process, an instance of the SAXParserFactory class is used to generate an instance of the parser.

The main JAXP APIs are defined in the javax.xml.parsers package. That package contains vendor-neutral factory classes--SAXParserFactory, DocumentBuilderFactory, and TransformerFactory--which give you a SAXParser, a DocumentBuilder, and an XSLT transformer, respectively. DocumentBuilder, in turn, creates a DOM-compliant Document object.

The factory APIs let you plug in an XML implementation offered by another vendor without changing your source code. The implementation you get depends on the setting of the javax.xml.parsers.SAXParserFactory, javax.xml.parsers.DocumentBuilderFactory, and javax.xml.transform.TransformerFactory system properties, using System.setProperties() in the code, in an Ant build script, or -DpropertyName="..." on the command line. The default values (unless overridden at runtime on the command line or in the code) point to Sun's implementation.

The SAX and DOM APIs are defined by the XML-DEV group and by the W3C, respectively. The libraries that define those APIs are as follows:

javax.xml.parsers: The JAXP APIs, which provide a common interface for different vendors' SAX and DOM parsers
org.w3c.dom: Defines the Document class (a DOM) as well as classes for all the components of a DOM
org.xml.sax: Defines the basic SAX APIs
javax.xml.transform: Defines the XSLT APIs that let you transform XML into other forms
The Simple API for XML (SAX) is the event-driven, serial-access mechanism that does element-by-element processing. The API for this level reads and writes XML to a data repository or the web. For server-side and high-performance applications, you will want to fully understand this level. But for many applications, a minimal understanding will suffice.

The DOM API is generally an easier API to use. It provides a familiar tree structure of objects. You can use the DOM API to manipulate the hierarchy of application objects it encapsulates. The DOM API is ideal for interactive applications because the entire object model is present in memory, where it can be accessed and manipulated by the user.

On the other hand, constructing the DOM requires reading the entire XML structure and holding the object tree in memory, so it is much more CPU- and memory-intensive. For that reason, the SAX API tends to be preferred for server-side applications and data filters that do not require an in-memory representation of the data.

Finally, the XSLT APIs defined in javax.xml.transform let you write XML data to a file or convert it into other forms. And, as you'll see in the XSLT section of this tutorial, you can even use it in conjunction with the SAX APIs to convert legacy data to XML.

The parser wraps a SAXReader object. When the parser's parse() method is invoked, the reader invokes one of several callback methods implemented in the application. Those methods are defined by the interfaces ContentHandler, ErrorHandler, DTDHandler, and EntityResolver.

Here is a summary of the key SAX APIs:

SAXParserFactory

A SAXParserFactory object creates an instance of the parser determined by the system property, javax.xml.parsers.SAXParserFactory.

SAXParser

The SAXParser interface defines several kinds of parse() methods. In general, you pass an XML data source and a DefaultHandler object to the parser, which processes the XML and invokes the appropriate methods in the handler object.

SAXReader

The SAXParser wraps a SAXReader. Typically, you don't care about that, but every once in a while you need to get hold of it using SAXParser's getXMLReader() so that you can configure it. It is the SAXReader that carries on the conversation with the SAX event handlers you define.

DefaultHandler

Not shown in the diagram, a DefaultHandler implements the ContentHandler, ErrorHandler, DTDHandler, and EntityResolver interfaces (with null methods), so you can override only the ones you're interested in.

ContentHandler

Methods such as startDocument, endDocument, startElement, and endElement are invoked when an XML tag is recognized. This interface also defines the methods characters and processingInstruction, which are invoked when the parser encounters the text in an XML element or an inline processing instruction, respectively.

ErrorHandler

Methods error, fatalError, and warning are invoked in response to various parsing errors. The default error handler throws an exception for fatal errors and ignores other errors (including validation errors). That's one reason you need to know something about the SAX parser, even if you are using the DOM. Sometimes, the application may be able to recover from a validation error. Other times, it may need to generate an exception. To ensure the correct handling, you'll need to supply your own error handler to the parser.

DTDHandler

Defines methods you will generally never be called upon to use. Used when processing a DTD to recognize and act on declarations for an unparsed entity.

EntityResolver

The resolveEntity method is invoked when the parser must identify data identified by a URI. In most cases, a URI is simply a URL, which specifies the location of a document, but in some cases the document may be identified by a URN--a public identifier, or name, that is unique in the web space. The public identifier may be specified in addition to the URL. The EntityResolver can then use the public identifier instead of the URL to find the document--for example, to access a local copy of the document if one exists.

A typical application implements most of the ContentHandler methods, at a minimum. Because the default implementations of the interfaces ignore all inputs except for fatal errors, a robust implementation may also want to implement the ErrorHandler methods.

The SAX Packages
The SAX parser is defined in the packages listed in Table 4-1.

Table 4-1 SAX Packages Package Description
org.xml.sax Defines the SAX interfaces. The name org.xml is the package prefix that was settled on by the group that defined the SAX API.
org.xml.sax.ext Defines SAX extensions that are used for doing more sophisticated SAX processing--for example, to process a document type definition (DTD) or to see the detailed syntax for a file.
org.xml.sax.helpers Contains helper classes that make it easier to use SAX--for example, by defining a default handler that has null methods for all the interfaces, so that you only need to override the ones you actually want to implement.
javax.xml.parsers Defines the SAXParserFactory class, which returns the SAXParser. Also defines exception classes for reporting errors.

The Document Object Model APIs
Figure 4-2 shows the DOM APIs in action.

You use the javax.xml.parsers.DocumentBuilderFactory class to get a DocumentBuilder instance, and you use that instance to produce a Document object that conforms to the DOM specification. The builder you get, in fact, is determined by the system property javax.xml.parsers.DocumentBuilderFactory, which selects the factory implementation that is used to produce the builder. (The platform's default value can be overridden from the command line.)

You can also use the DocumentBuilder newDocument() method to create an empty Document that implements the org.w3c.dom.Document interface. Alternatively, you can use one of the builder's parse methods to create a Document from existing XML data. The result is a DOM tree like that shown in Figure 4-2.

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

Note: Although they are called objects, the entries in the DOM tree are actually fairly low-level data structures. For example, consider this structure: blue. There is an element node for the color tag, and under that there is a text node that contains the data, blue! This issue will be explored at length in the DOM section of the tutorial, but developers who are expecting objects are usually surprised to find that invoking getNodeValue() on the element node returns nothing! For a truly object-oriented tree, see the JDOM API at http://www.jdom.org.

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

The DOM Packages
The Document Object Model implementation is defined in the packages listed in Table 4-2.

Table 4-2 DOM Packages Package Description
org.w3c.dom Defines the DOM programming interfaces for XML (and, optionally, HTML) documents, as specified by the W3C.
javax.xml.parsers Defines the DocumentBuilderFactory class and the DocumentBuilder class, which returns an object that implements the W3C Document interface. The factory that is used to create the builder is determined by the javax.xml.parsers system property, which can be set from the command line or overridden when invoking the new Instance method. This package also defines the ParserConfigurationException class for reporting errors.

The Extensible Stylesheet Language Transformations APIs
Figure 4-3 shows the XSLT APIs in action.

A TransformerFactory object is instantiated and used to create a Transformer. The source object is the input to the transformation process. A source object can be created from a SAX reader, from a DOM, or from an input stream.

Similarly, the result object is the result of the transformation process. That object can be a SAX event handler, a DOM, or an output stream.

When the transformer is created, it can be created from a set of transformation instructions, in which case the specified transformations are carried out. If it is created without any specific instructions, then the transformer object simply copies the source to the result.

The XSLT Packages
The XSLT APIs are defined in the packages shown in Table 4-3.

Table 4-3 XSLT Packages Package Description
javax.xml.transform Defines the TransformerFactory and Transformer classes, which you use to get an object capable of doing transformations. After creating a transformer object, you invoke its transform() method, providing it with an input (source) and output (result).
javax.xml.transform.dom Classes to create input (source) and output (result) objects from a DOM.
javax.xml.transform.sax Classes to create input (source) objects from a SAX parser and output (result) objects from a SAX event handler.
javax.xml.transform.stream Classes to create input (source) objects and output (result) objects from an I/O stream.

Simple API for XML (SAX), an event-driven, serial-access mechanism for accessing XML documents. This protocol is frequently used by servlets and network-oriented programs that need to transmit and receive XML documents, because it's the fastest and least memory-intensive mechanism that is currently available for dealing with XML documents, other than StAX.

SAX is an event-driven model (you provide the callback methods, and the parser invokes them as it reads the XML data), and that makes it harder to visualize. Finally, you can't "back up" to an earlier part of the document, or rearrange it, any more than you can back up a serial data stream or rearrange characters you have read from that stream.

For those reasons, developers who are writing a user-oriented application that displays an XML document and possibly modifies it will want to use the DOM mechanism

even if you plan to build DOM applications exclusively, there are several important reasons for familiarizing yourself with the SAX model:

Same Error Handling: The same kinds of exceptions are generated by the SAX and DOM APIs, so the error handling code is virtually identical.
Handling Validation Errors: By default, the specifications require that validation errors (which you'll learn more about in this part of the tutorial) are ignored. If you want to throw an exception in the event of a validation error (and you probably do), then you need to understand how SAX error handling works.
Converting Existing Data: There is a mechanism we can use to convert an existing data set to XML. However, taking advantage of that mechanism requires an understanding of the SAX model.

SAX is fast and efficient, but its event model makes it most useful for such state-independent filtering. For example, a SAX parser calls one method in your application when an element tag is encountered and calls a different method when text is found. If the processing you're doing is state-independent (meaning that it does not depend on the elements have come before), then SAX works fine.

On the other hand, for state-dependent processing, where the program needs to do one thing with the data under element A but something different with the data under element B, then a pull parser such as the Streaming API for XML (StAX) would be a better choice. With a pull parser, you get the next node, whatever it happens to be, at any point in the code that you ask for it. So it's easy to vary the way you process text (for example), because you can process it multiple places in the program.

SAX requires much less memory than DOM, because SAX does not construct an internal representation (tree structure) of the XML data, as a DOM does. Instead, SAX simply sends data to the application as it is read; your application can then do whatever it wants to do with the data it sees.

Pull parsers and the SAX API both act like a serial I/O stream. You see the data as it streams in, but you can't go back to an earlier position or leap ahead to a different position. In general, such parsers work well when you simply want to read data and have the application act on it.
But when you need to modify an XML structure--especially when you need to modify it interactively--an in-memory structure makes more sense. DOM is one such model.

Handle SQL date

2007-12-27T20:40:00.000-08:00

To get the current date in SQL format.
java.util.Date today =
new java.util.Date();
java.sql.Date sqlToday =
new java.sql.Date(today.getTime());
For Timestamp, it's the same idea
java.util.Date today =
new java.util.Date();
java.sql.Timestamp now =
new java.sql.Timestamp(today.getTime());
To use a Date, Time or Timestamp in a query, you can use JDBC escape codes.
Date {d 'yyyy-mm-dd'}
Time {t {'hh:mm:ss'}
Timestamp {ts `yyyy-mm-dd hh:mm:ss.f . . .'}
note: the .f .... is optional
For example, a Statement with a Date will look like this
java.util.Date today =
new java.util.Date();
java.sql.Date sqlToday =
new java.sql.Date(today.getTime());

String query =
"select * from cust where purchase_date < { d '"
+ sqlDate.toString() + "' }");

With a PreparedStatement, you don't need JDBC escape codes, the JDBC driver will do the job for you.
java.util.Date today =
new java.util.Date();
java.sql.Date sqlToday =
new java.sql.Date(today.getTime());

PreparedStatement p = theConn.prepareStatement
("select * from cust where purchase_date < ?");
p.setDate(1, sqlToday);
ResultSet rs = p.executeQuery();
To INSERT
PreparedStatement p = theConn.prepareStatement
("insert into TableWithADateColumn values(?)");
p.setDate(1, sqlToday);
p.executeUpdate();
or
p.executeUpdate
("insert into TableWithADateColumn values( { d '1999-12-31' } )");
One thing to remember when using java.sql.date is (according to the javadoc) :

To conform with the definition of SQL DATE, the millisecond values
wrapped by a java.sql.Date instance must be 'normalized' by setting
the hours, minutes, seconds, and milliseconds to zero in the particular
time zone with which the instance is associated.

How to load balance Tomcat 5.5 with Apache on Windows

2007-12-21T01:07:00.000-08:00

How to load balance Tomcat 5.5 with Apache on Windows
It's rather amazing that I could not find a single how-to that could detail the steps for using the Apache web server to load balance multiple Tomcat 5.5 instances on Windows. I found tons of articles- but they were either for older versions of Tomcat or Apache or for Unix flavors and none were accurate enough. Apache itself has fragmented documentation on the subject, and after much trial and error and pulling of hair, I succeeded.

The least I can do is list the steps here for all others who have had trouble getting it right.
The goal of this blog is to set up two Tomcat 5.5 instances with Apache in front, load balancing them. Please note that this does not cover clustering. I'll save that for another blog once I actually do it :-)
Also, this is not a tutorial on load balancing. It will get you up and running- then you might want to look at the Tomcat documentation to find out what exactly all those options do.

So, this is what you need to download:
1. Apache HTTP server 2.2.4 from The Apache HTTP Server Project. I prefer the zip over the Windows Installer. You are free to choose the Windows Installer if you wish, but modify the service instructions below accordingly.

2. Apache Tomcat 5.5.20 from Apache Tomcat downloads

3. Mod JK Tomcat connector from here. Please note: You want to download the binary- click on JK 1.2 Binary Releases --> win32 --> jk-1.2.21 --> mod_jk-apache-2.2.4.so

Now let's start by installing Tomcat first.

1. Extract the Tomcat zip. Hereafter, the directory you extracted to will be referred to as TOMCAT_HOME

2. Test Tomcat to see that it works. Go to TOMCAT_HOME\bin and run startup.bat
You may need to add an environment variable called CATALINA_HOME which is set to TOMCAT_HOME in case Tomcat fails to start.

3. Open up your browser and access http://localhost:8080/
If you see the default page, then Tomcat Instance 1 is working fine. Shut down Tomcat.

4. Now set this up as a service. Go to your command prompt, change directory to TOMCAT_HOME\bin and set an environment variable called CATALINA_BASE. The value of this variable should again, be TOMCAT_HOME. For example:

SET CATALINA_BASE=C:\Tomcat-5.5.20

Then, execute the following: service install Tomcat5
This will set up the Windows service for Tomcat.

5. Go to your Services and see that Tomcat 5 is listed. Start the service, and then verify again that http://localhost:8080 is up.
That's all for the first Tomcat instance. Now for the second.

1. Make a directory called SecondInstance in TOMCAT_HOME

2. Copy the conf, logs, shared, temp, webapps and work directories from the TOMCAT_HOME directory into the SecondInstance directory.

3. Open up SecondInstance\conf\server.xml in a text editor. We've got to change the port numbers so that they don't conflict with the first instance.
I just incremented by 10 and changed them as follows, but you could use other port numbers:

to

Connector port="8080" maxHttpHeaderSize="8192"... to Connector port="8090" maxHttpHeaderSize="8192"...

to

Change the SSL port if you need it as well.

4. Now set up the second instance to run as a service. Go to the command prompt, change to the TOMCAT_HOME\bin directory. Set the CATALINA_BASE environment variable to TOMCAT_HOME\SecondInstance. For example:

SET CATALINA_BASE=C:\Tomcat5.5.20\SecondInstance
Then, type:
service install SecondTomcat

Go to Services and start the SecondTomcat service. Test it out by pointing your browser to http://localhost:8090/
Works ok? Great! Your second tomcat instance is now ready to be used.

Next, let's set up the Apache HTTP Server. It's pretty simple...

1. Run the installer you downloaded. The standard install will do.

2. Open the Apache Server Monitor and start the web server if it's not already running.

3. Point your browser to http://localhost/ to verify that Apache is running on port 80.

4. Stop Apache.

Finally, we reach mod JK. Let's set it up first just to delegate requests to the two Tomcat instances, and we'll load balance it a bit later.

1. Copy the mod_jk-apache-2.2.4.so to the modules directory in your Apache installation.

2. Rename it to mod_jk.so

3. Open up httpd.conf in the conf directory of your Apache installation in a text edit, and add the following line at the end of the set of LoadModule statements:
LoadModule jk_module modules/mod_jk.so

4. Create a file called workers.properies in the conf directory. Add these lines to it:

workers.tomcat_home=C:/tomcat-5.5.20

workers.java_home=C:/jdk1.5.0_03

worker.list=worker1,worker2

worker.worker1.port=8009
worker.worker1.host=localhost
worker.worker1.type=ajp13

worker.worker2.port=8019
worker.worker2.host=localhost
worker.worker2.type=ajp13

This file defines which workers Apache can delegate to. We've listed worker1 and worker 2 to correspond to our two tomcat instances. Remember to set tomcat_home and java_home as well.

5. Specify the worker properties in httpd.conf:

Add these lines just after the LoadModule definitions-

# Path to workers.properties
JkWorkersFile c:/apache2.2/conf/workers.properties

# Path to jk logs
JkLogFile c:/apache2.2/mod_jk.log

# Jk log level [debug/error/info]
JkLogLevel info

# Jk log format
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "

# JkOptions for forwarding
JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories

# JkRequestLogFormat set the request format
JkRequestLogFormat "%w %V %T"

JkMount /jsp-examples worker1
JkMount /jsp-examples/* worker1

JkMount /tomcat-docs worker2
JkMount /tomcat-docs/* worker2

Defining these tells Apache where to look for definitions of its workers and tells it that any requests for the jsp-examples context should be handed off to the Tomcat instance represented by worker 1, and any requests for tomcat-docs context should be handed off to Tomcat Instance 2, represented by worker 2.

5.5 [Added on April 11 2007]
Edit the server.xml for Tomcat and Tomcat's SecondInstance and add a jvmRoute attribute to the Engine element:

for the first instance and

for the second.

6. Start Tomcat Instance 1 and 2. Start up the Apache webserver. Point your browser to http://localhost/jsp-examples/ and then to http://localhost/tomcat-docs. You should see the respective pages load. To distinguish which Tomcat is serving you the page, the easiest thing to do is edit the index page in the tomcat-docs and jsp-examples of Tomcat 2 and change the title for example. Then you can verify that tomcat-docs is being served only by the second instance.

Thats it!! Apache is now delegating requests to both Tomcats.
Now for our last task- we will load balance it so that Apache distributes load for jsp-examples between both instances of Tomcat. It also serves as a failover mechanism. If Tomcat 1 is down for whatever reason, Apache will automatically keep delegating to Tomcat 2 so your application remains accessible.

Load balancing is a simple configuration. First shut down your Tomcat instances and Apache as well.

1. Open workers.properties in a text editor.

2. Edit it so it looks like this (changed lines in bold)-

workers.tomcat_home=C:/tomcat-5.5.20
workers.java_home=C:/jdk1.5.0_03

#worker.list=worker1,worker2
worker.list=balancer

worker.worker1.port=8009
worker.worker1.host=localhost
worker.worker1.type=ajp13
worker.worker1.lbfactor=1

worker.worker2.port=8019
worker.worker2.host=localhost
worker.worker2.type=ajp13
worker.worker2.lbfactor=1

worker.balancer.type=lb
worker.balancer.balance_workers=worker1,worker2
worker.balancer.method=B

We've changed the worker list to a single worker called balancer, and specified that the worker type of balancer is 'lb' or load balancer. The workers it manages are worker1 and worker2 (these do not need to appear in the workers list). And finally, we set the balance method to 'B' or balance by busy factor. Apache will delegate the next request to the Tomcat instance which is least busy. Please note that there are a couple of options for method- consult the Apache/Tomcat documentation which lists out options for workers properties to help you decide the best method for your type of application.

3. Open httpd.conf and comment out the previous JkMount directives. Replace them with these:

JkMount /jsp-examples balancer
JkMount /jsp-examples/* balancer

Very simple- we've just pointed Apache to a single worker- the balancer.

4. Start up both Tomcats and Apache. Access http://localhost/jsp-examples
You will either be served by Tomcat 1 or Tomcat 2. To prove that both are capable of serving, shut down the first instance and refresh your browser. You should be served by instance two.

Congratulations! You've successfully set up Apache load balancing multiple tomcat instances!

MySQL ssh tunnel

2007-12-13T04:23:00.000-08:00

1.
On your home machine:
ssh -L 3307:domain.name.of.mysqlserver:3306 username@domain.name.of.gatewayserver

Ex:
$ ssh -L 3307:dbserver:3306 ananth@xxx.xxxxxxx.xxx

This will open a tunnel, listening on localhost:3307 and forwarding everything to mysqlserver:3306, and doing it all via the ssh service on the gateway machine.

2.
Now, on your local machine, execute a mysql connection like so:
mysql -u username -p -h 127.0.0.1 -P 3307 databasename

Ex:
C:\Program Files\MySQL\MySQL Server 5.0\bin>mysql -u USERNAME -pPASSWORD -h 127.0.0.1 -P 3307 DATABASENAME

In other words, mysql thinks it's connecting to localhost, but on a different port. In fact, the connection is being made securely to the remote mysql server, via the gateway machine and the local "mouth" of the ssh tunnel on your own machine.

3.
When you're finished with your mysql session, log out of the session on the gateway machine. That will properly close the tunnel.

Beginning J2EE

2007-10-15T02:17:00.000-07:00

This article provides a high-level introduction to J2EE. It is taken from chapter one of the book Beginning J2EE 1.4 From Novice to Professional, written by James L. Weaver, Kevin Mukhar, and Jim Crume (Apress, 2004; ISBN: 1590593413).

The word “enterprise” has magical powers in computer programming circles. It can increase the price of a product by an order of magnitude, and double the potential salary of an experienced consultant. Your application may be free of bugs, and cleanly coded using all the latest techniques and tools, but is it enterprise ready? What exactly is the magic ingredient that makes enterprise development qualitatively different from run-of-the-mill development?

Enterprise applications solve business problems. This usually involves the safe storage, retrieval, and manipulation of business data: customer invoices, mortgage applications, flight bookings, and so on. They might have multiple user interfaces: a web interface for consumers, and a GUI application running on computers in the branch offices, for example. They have to deal with communication between remote systems, co-ordination of data in multiple stores, and ensure the system always follows the rules laid down by the business. If any part of the system crashes, the business loses part of its ability to function, and starts to lose money. If the business grows, the application needs to grow with it. All this adds up to what characterizes enterprise applications: robustness in the face of complexity.

When we set out to build a GUI application, we don’t start out by working out how to draw pixels on the screen, and build our own code to track the user’s mouse around the screen; we rely on a GUI library, like Swing, to do that for us. Similarly, when we set out to create the components of a full-scale enterprise solution, we’d be crazy to start from scratch. Enterprise programmers build their applications on top of systems called application servers. Just as GUI toolkits provide services of use to GUI applications, application servers provide services of use to enterprise applications – things like communication facilities to talk to other computers, management of database connections, the ability to serve web pages, and management of transactions.

Just as Java provides a uniform way to program GUI applications on any underlying operating system, nowadays Java can provide a uniform way to program enterprise applications on any underlying application server. The set of libraries developed by Sun Microsystems and the Java Community Process that represent this uniform application server API is what we call the Java 2 Platform, Enterprise Edition, and is the subject of this book.

This chapter provides a high-level introduction to J2EE, and an introduction on how to get the most benefit from this book. After reading this chapter, you will:
Have an understanding of the reasons why the concepts underlying J2EE are compelling and enabling technologies for large-scale applications
Understand how J2EE relates to J2SE
Be introduced to the cornerstone technologies of J2EE
Be introduced to some of the essential architectural patterns that J2EE facilitates

So, without further ado, let’s get started!
What Is J2EE?

Since you’re reading this book you’ve got some interest in J2EE, and probably have some notion of what you’re getting into. For many fledgling J2EE developers, J2EE equates to Enterprise JavaBeans. J2EE is a great deal more than just EJBs, though.

While perhaps an oversimplification, J2EE is a suite of specifications for application programming interfaces, a distributed computing architecture, and definitions for packaging of distributable components for deployment. It’s a collection of standardized components, containers, and services for creating and deploying distributed applications within a well-defined distributed computing architecture.

As its name pretty much spells out, Java 2 Enterprise Edition is targeted at large-scale business systems. Software that functions at that level doesn’t run on a single PC—it requires significantly more computing power and throughput than that. For that reason, the software needs to be partitioned into functional pieces and deployed on the appropriate hardware platforms to provide the necessary computing power. That is the essence of distributed computing. J2EE provides a collection of standardized components that facilitate software deployment, standard interfaces that define how the various software modules interconnect, and standard services that define how the different software modules communicate.
How J2EE Relates to J2SE

J2EE isn’t a replacement for the Java 2 Standard Edition. The J2SE provides the essential language framework that the J2EE builds upon. It is the core upon which J2EE is based. As you’ll see, J2EE consists of several layers, and J2SE is right at the base of that pyramid for each component of J2EE.

As a Java developer, you’ve probably already learned how to build user interfaces with the JFC/Swing and AWT components. You’ll still be using those to build the user interfaces for your J2EE applications, as well as HTML-based user interfaces. Since J2SE is at the core of J2EE, everything that you’ve learned so far remains useful and relevant.

In fact, J2EE provides pretty much nothing in the way of user interfaces. You’ll also see that the J2EE platform provides the most significant benefit in developing the “middle tier” portion of your application—that’s the business logic and the connections to back-end data sources. You’ll use familiar J2SE components and APIs in conjunction with the J2EE components and APIs to build that part of your applications.
Why J2EE?

J2EE defines a number of services that, to someone developing enterprise-class applications, are as essential as electricity and running water. Life is simple when you simply turn the faucet and water starts running, or flip the switch and lights come on. If you have ever been involved with building a house, you’ll know that there is a great deal of effort, time, and expense in building in that infrastructure of plumbing and wiring that is then so nicely hidden behind freshly painted walls. At the points where that infrastructure is exposed, there are standard interfaces for controlling (water faucets and light switches, for example) and connecting (power sockets, lamp sockets, and hose bibs, for example).

In the same vein, there is a great deal of infrastructure required to write enterprise-class applications. There are a bunch of different system-level capabilities that you need in order to write distributed applications that are scaleable, robust, secure, and maintainable. Some vital pieces of that infrastructure include security, to ensure that a user is who they claim to be, and can only access the parts of the application that they’re entitled to access. Database access is also a fundamental component so that your application can store and retrieve data. Transaction support is required to make sure that the right data is updated at the right time. If you’re not familiar with some of these concepts, don’t worry—you’ll be introduced to them one at a time throughout this book.

Suppose, though, that the wiring and plumbing in your home wasn’t there. You’d need to put in your own plumbing and electricity. Without standard components and interfaces, though, you’d have to fabricate your own pipes, wiring, and so on—it’d be terrifically expensive and an awful lot of work.

Putting in a distributed computing infrastructure—the plumbing and wiring of an architecture that supports enterprise applications—is no simple feat. That’s why J2EE-based architectures are so compelling—the hard system-level infrastructure is already in place. But why not custom build (or pay someone to custom build) an infrastructure that is designed around your particular application? Well, for starters, it would take a fantastic amount of time, money, and effort. And even if you were to build up that infrastructure, it would be different from anyone else’s infrastructure, so you’d not be able to share components or interoperate with anyone else’s distributed computing model. That’s a lot of work for something that sounds like a dead end. Even if you were lucky enough to find a vendor that could sell you a software infrastructure, you should be wary about any solution that would lock you into any single vendor’s implementation that would preclude you from switching vendors at some point in the future.

The good news is, no surprise, that J2EE defines a set of containers, connectors, and components that fill that gap. J2EE not only fills the gap, but it’s based on well-known, published specifications. That means that applications written for J2EE will run on any number of J2EE-compliant implementations. The reference implementation supplied with the J2EE Software Development Kit from Sun (J2SDKEE) provides a working model that we’ll use throughout this book, since it’s the implementation that Sun has built from the specification, and is freely available. In the next chapter you’ll get an introduction to installing and testing the J2SDKEE.

It’s important to note that the reference implementation is a working model but it’s not designed to be used for enterprise-level deployment. It doesn’t provide some of the enterprise-level features that are outside of the scope of the J2EE specification, such as clustering (the ability to have multiple servers handling requests at the same time) or failover (the ability to have a group of servers that can recover when one crashes). Working with the reference implementation, though, ensures that you’ll get exposure to the core J2EE concepts that apply to ALL vendor implementations, and you won’t get bogged down with vendor-specific details.

For production deployment, you’ll want to select one of a number of J2EE solutions available from a number of different vendors, which have been optimized for high volume throughput and are designed for your particular application. Sun (http://www.sun.com/software), IBM (http://www.ibm.com/websphere), Borland (http://www. borland.com/besappserver) and BEA (http://www.bea.com/ products/weblogic/server) are high-profile examples—but certainly not all—of the commercial implementations. JBoss (http:// www.jboss.org) is an open source implementation that has a huge following. You get to choose which one works best for you—that’s an exercise that’s beyond the scope of this book.

Building a J2EE application for one J2EE implementation and deploying it on another is cheap, but it’s not free, nor is each vendor’s implementation of J2EE completely free of defects and operational quirks. Although Java and J2EE go a long way towards providing platform independence, that isn’t a guarantee that you can develop on one platform and deploy on another without any hiccups or surprises. Bugs, differences in performance, and other little “gotchas” can seriously delay or derail your project. When you are developing systems that will be deployed in a production environment, it is always a good idea to do your development and staging using the same platforms and technologies that the production environment is based upon. This will help to avoid unnecessary surprises during and after the rollout.

Interface vs. abstract class

2007-09-12T08:37:00.000-07:00

Choosing interfaces and abstract classes is not an either/or proposition. If you need to change your design, make it an interface. However, you may have abstract classes that provide some default behavior. Abstract classes are excellent candidates inside of application frameworks.

Abstract classes let you define some behaviors; they force your subclasses to provide others. For example, if you have an application framework, an abstract class may provide default services such as event and message handling. Those services allow your application to plug in to your application framework. However, there is some application-specific functionality that only your application can perform. Such functionality might include startup and shutdown tasks, which are often application-dependent. So instead of trying to define that behavior itself, the abstract base class can declare abstract shutdown and startup methods. The base class knows that it needs those methods, but an abstract class lets your class admit that it doesn't know how to perform those actions; it only knows that it must initiate the actions. When it is time to start up, the abstract class can call the startup method. When the base class calls this method, Java calls the method defined by the child class.

Many developers forget that a class that defines an abstract method can call that method as well. Abstract classes are an excellent way to create planned inheritance hierarchies. They're also a good choice for nonleaf classes in class hierarchies.

Q: Why use interfaces to develop Java applications?
A: It is advisable to design relatively large applications using interfaces because it makes the whole system easier to modify, extend and integrate new features. To start with, you may only have one implementation of a given interface, but if you find you need slightly different behaviour in special circumstances, you only need write a class that conforms to one of the existing interfaces and it will drop in place without major modifications.

Interfaces also allow you to adapt a class from a different hierarchy to work in an existing application. The class only needs to declare it implements the interface, provide the necessary methods and it can be integrated directly as if it were created for the job.

Q: What is the difference between abstract classes and interfaces?
A: A Java interface is a definition of a class type without any concrete implementation. Typically, an interface consists of one or more method signatures that a subclass must fulfil to conform to the type. In effect, all their methods are abstract, and interfaces cannot be instantiated

Q: Do interfaces have member variables?
A: Interfaces may have member variables, but these are implicitly final and static because they are not inherited by extension. In effect interface variables are constants that are available to all implementations and may be used as key references for method arguments for example.

Q: Can we create an object for an interface?
A: Yes, it is always necessary to create an object implementation for an interface. Interfaces cannot be instantiated in their own right, so you must write a class that implements the interface and fulfil all the methods defined in it.

public class Concrete implements ExampleInterface {

...
}
Q: What is a marker interface?
A: Marker interfaces are those which do not declare any required methods, but signify their compatibility with certain operations. The java.io.Serializable interface is a typical marker interface. It does not contain any methods, but classes must implement this interface in order to be serialized and de-serialized.

Q: Should I use a public access modifier for interface methods?
A: Java interfaces are used to define a public Application Programming Interface (API) for classes to implement, so a public modifier is redundant in this context. Non-public modifiers are not valid for interfaces, so the compiler should fail and warn you in this case.

Interface usage
Q: What are the rules for passing subclasses for method arguments?
A: It may help to discuss an example using birds: an interface called Avian, a superclass FlyingBird that implements Avian and two concrete classes: Parrot and Penguin. Parrot extends FlyingBird, so is implicitly an Avian type, but Penguin does not, it only implements Avian. The examples below work through all possibilities, passing references to methods soundBirdCall(FlyingBird) and displayPlumage(Avian)

Q: When should I use abstract classes rather than interfaces?
A: Abstract classes are are often used to provide methods that will be common to a range of similar subclasses, to avoid duplicating the same code in each case. Each subclass adds its own features on top of the common abstract methods.

Q: Can an interface be declared final?
A: It is not permitted to declare an interface as final, it will cause a compilation error. It does not make sense to declare an interface final because it contains no implementation code and cannot instantiated in its own right. The final modifier is used to prevent the extension of concrete classes.

Q: This code seems to be instantiating an interface!
A: The code you are looking at declares an inline anonymous class that implements an interface, which has a similar effect. This declaration does not instantiate the interface, but defines the type of the anonymous class, which has no name of its own. This approach is often used in AWT or Swing applications where a class is required to fulfil a minimal interface and it is not necessary to retain a reference to it by assignment.

Ocerriding vs Hiding

2007-09-12T08:22:00.001-07:00

Can I override a static method?
Many people have heard that you can't override a static method. This is true - you can't. However it is possible to write code like this:

class Foo {
public static void method() {
System.out.println("in Foo");
}
}
//commited by sanjay
class Bar extends Foo {
public static void method() {
System.out.println("in Bar");
}
}
This compiles and runs just fine. Isn't it an example of a static method overriding another static method? The answer is no - it's an example of a static method hiding another static method. If you try to override a static method, the compiler doesn't actually stop you - it just doesn't do what you think it does.
So what's the difference?

Briefly, when you override a method, you still get the benefits of run-time polymorphism, and when you hide, you don't. So what does that mean? Take a look at this code:

class Foo {
public static void classMethod() {
System.out.println("classMethod() in Foo");
}

public void instanceMethod() {
System.out.println("instanceMethod() in Foo");
}
}

class Bar extends Foo {
public static void classMethod() {
System.out.println("classMethod() in Bar");
}

public void instanceMethod() {
System.out.println("instanceMethod() in Bar");
}
}

class Test {
public static void main(String[] args) {
Foo f = new Bar();
f.instanceMethod();
f.classMethod();
}
}
If you run this, the output is
instanceMethod() in Bar
classMethod() in Foo
Why do we get instanceMethod from Bar, but classMethod() from Foo? Aren't we using the same instance f to access both of these? Yes we are - but since one is overriding and the other is hiding, we see different behavior.
Since instanceMethod() is (drum roll please...) an instance method, in which Bar overrides the method from Foo, at run time the JVM uses the actual class of the instance f to determine which method to run. Although f was declared as a Foo, the actual instance we created was a new Bar(). So at runtime, the JVM finds that f is a Bar instance, and so it calls instanceMethod() in Bar rather than the one in Foo. That's how Java normally works for instance methods.

With classMethod() though. since (ahem) it's a class method, the compiler and JVM don't expect to need an actual instance to invoke the method. And even if you provide one (which we did: the instance referred to by f) the JVM will never look at it. The compiler will only look at the declared type of the reference, and use that declared type to determine, at compile time, which method to call. Since f is declared as type Foo, the compiler looks at f.classMethod() and decides it means Foo.classMethod. It doesn't matter that the instance reffered to by f is actually a Bar - for static methods, the compiler only uses the declared type of the reference. That's what we mean when we say a static method does not have run-time polymorphism.

Because instance methods and class methods have this important difference in behavior, we use different terms - "overriding" for instance methods and "hiding" for class methods - to distinguish between the two cases. And when we say you can't override a static method, what that means is that even if you write code that looks like it's overriding a static method (like the first Foo and Bar at the top of this page) - it won't behave like an overridden method.

So what about accessing a static method using an instance?

It's possible in Java to write something like:

f.classMethod();
] where f is an instance of some class, and classMethod() is a class method (i.e. a static method) of that class. This is legal, but it's a bad idea because it creates confusion. The actual instance f is not really important here. Only the decleared type of f matters. That is, what class is f declared to be? Since classMethod() is static, the class of f (as determined by the compiler at compile time) is all we need.
Rather than writing:

f.classMethod();
It would be better coding style to write either:
Foo.classMethod();
or
Bar.classMethod();
That way, it is crystal clear which class method you would like to call. It is also clear that the method you are calling is indeed a class method.
Barring that, you could always come up with this monstrosity:

f.getClass().getMethod("classMethod", new Class[]).invoke(f, new Object[]);
But all this could be avoided by simply not trying to override your static (class) methods. :-)

Java Virtual Machine

2007-09-11T05:36:00.000-07:00

What is the Java Virtual Machine? Why is it here?
The Java Virtual Machine, or JVM, is an abstract computer that runs compiled Java programs. The JVM is "virtual" because it is generally implemented in software on top of a "real" hardware platform and operating system. All Java programs are compiled for the JVM. Therefore, the JVM must be implemented on a particular platform before compiled Java programs will run on that platform.

The JVM plays a central role in making Java portable. It provides a layer of abstraction between the compiled Java program and the underlying hardware platform and operating system. The JVM is central to Java's portability because compiled Java programs run on the JVM, independent of whatever may be underneath a particular JVM implementation.

What makes the JVM lean and mean? The JVM is lean because it is small when implemented in software. It was designed to be small so that it can fit in as many places as possible -- places like TV sets, cell phones, and personal computers. The JVM is mean because it of its ambition. "Ubiquity!" is its battle cry. It wants to be everywhere, and its success is indicated by the extent to which programs written in Java will run everywhere.

Java bytecodes

Java programs are compiled into a form called Java bytecodes. The JVM executes Java bytecodes, so Java bytecodes can be thought of as the machine language of the JVM. The Java compiler reads Java language source (.java) files, translates the source into Java bytecodes, and places the bytecodes into class (.class) files. The compiler generates one class file per class in the source.

To the JVM, a stream of bytecodes is a sequence of instructions. Each instruction consists of a one-byte opcode and zero or more operands. The opcode tells the JVM what action to take. If the JVM requires more information to perform the action than just the opcode, the required information immediately follows the opcode as operands.

A mnemonic is defined for each bytecode instruction. The mnemonics can be thought of as an assembly language for the JVM.

Java bytecode:

2007-09-11T05:01:00.000-07:00

This article gives you an understanding of Java bytecode that will enable you to be a better programmer. Like a C or C++ compiler translates source code into assembler code, Java compilers translate Java source code into bytecode. Java programmers should take the time to understand what the bytecode is, how it works, and most importantly, what bytecode is being generated by the Java compiler.

Why understand bytecode?

Bytecode is the intermediate representation of Java programs just as assembler is the intermediate representation of C or C++ programs. The most knowlegable C and C++ programmers know the assembler instruction set of the processor for which they are compiling. This knowledge is crucial when debugging and doing performance and memory usage tuning. Knowing the assembler instructions that are generated by the compiler for the source code you write, helps you know how you might code differently to achieve memory or performance goals. In addition, when tracking down a problem, it is often useful to use a debugger to disassemble the source code and step through the assembler code that is executing.

An often overlooked aspect of Java is the bytecode that is generated by the javac compiler. Understanding bytecode and what bytecode is likely to be generated by a Java compiler helps the Java programmer in the same way that knowledge of assembler helps the C or C++ programmer.

The bytecode is your program. Regardless of a JIT or Hotspot runtime, the bytecode is an important part of the size and execution speed of your code. Consider that the more bytecode you have, the bigger the .class file is and the more code that has to be compiled by a JIT or Hotspot runtime. The remainder of this article gives you an in depth look at Java bytecode.

Generating bytecode

javac Employee.java
javap -c Employee > Employee.bc

Compiled from Employee.java
class Employee extends java.lang.Object {
public Employee(java.lang.String,int);
public java.lang.String employeeName();
public int employeeNumber();
}

Method Employee(java.lang.String,int)
0 aload_0
1 invokespecial #3
4 aload_0
5 aload_1
6 putfield #5
9 aload_0
10 iload_2
11 putfield #4
14 aload_0
15 aload_1
16 iload_2
17 invokespecial #6
20 return

Method java.lang.String employeeName()
0 aload_0
1 getfield #5
4 areturn

Method int employeeNumber()
0 aload_0
1 getfield #4
4 ireturn

Method void storeData(java.lang.String, int)
0 return

This class is very simple. It contains two instance variables, a constructor and three methods. The first five lines of the bytecode file list the file name that is used to generate this code, the class definition, its inheritance (by default, all classes inherit from java.lang.Object ), and its constructors and methods. Next, the bytecode for each of the constructors is listed. Then, each method is listed in alphabetical order with its associated bytecode.

You might notice on closer inspection of the bytecode that certain opcodes are prefixed with an `a' or an `i'. For example, in the Employee class constructor you see aload_0 and iload_2. The prefix is representative of the type that the opcode is working with. The prefix `a' means that the opcode is manipulating an object reference. The prefix `i' means the opcode is manipulating an integer. Other opcodes use `b' for byte, `c' for char, `d' for double, etc. This prefix gives you immediate knowledge about what type of data is being manipulated.

The details

To understand the details of the bytecode, we need to discuss how a Java Virtual Machine (JVM) works regarding the execution of the bytecode. A JVM is a stack-based machine. Each thread has a JVM stack which stores frames. A frame is created each time a method is invoked, and consists of an operand stack, an array of local variables, and a reference to the runtime constant pool of the class of the current method. Conceptually, it might look like this:

The array of local variables, also called the local variable table, contains the parameters of the method and is also used to hold the values of the local variables. The parameters are stored first, beginning at index 0. If the frame is for a constructor or an instance method, the reference is stored at location 0. Then location 1 contains the first formal parameter, location 2 the second, and so on. For a static method, the first formal method parameter is stored in location 0, the second in location 1, and so on.

The size of the array of local variables is determined at compile time and is dependent on the number and size of local variables and formal method parameters. The operand stack is a LIFO stack used to push and pop values. Its size is also determined at compile time. Certain opcode instructions push values onto the operand stack; others take operands from the stack, manipulate them, and push the result. The operand stack is also used to receive return values from methods.

public String employeeName()
{
return name;
}

Method java.lang.String employeeName()
0 aload_0
1 getfield #5
4 areturn

The bytecode for this method consists of three opcode instructions. The first opcode, aload_0, pushes the value from index 0 of the local variable table onto the operand stack. Earlier, it was mentioned that the local variable table is used to pass parameters to methods. The this reference is always stored at location 0 of the local variable table for constructors and instance methods. The this reference must be pushed because the method is accessing the instance data, name, of the class.

The next opcode instruction, getfield, is used to fetch a field from an object. When this opcode is executed, the top value from the stack, this, is popped. Then the #5 is used to build an index into the runtime constant pool of the class where the reference to name is stored. When this reference is fetched, it is pushed onto the operand stack.

The last instruction, areturn, returns a reference from a method. More specifically, the execution of areturn causes the top value on the operand stack, the reference to name, to be popped and pushed onto the operand stack of the calling method.

The employeeName method is fairly simple. Before looking at a more complex example, we need to examine the values to the left of each opcode. In the employeeName method's bytecode, these values are 0, 1, and 4. Each method has a corresponding bytecode array. These values correspond to the index into the array where each opcode and its arguments are stored. You might wonder why the values are not sequential. Since bytecode got its name because each instruction occupies one byte, why are the indexes not 0, 1, and 2? The reason is some of the opcodes have parameters that take up space in the bytecode array. For example, the aload_0 instruction has no parameters and naturally occupies one byte in the bytecode array. Therefore, the next opcode, getfield, is in location 1. However, areturn is in location 4. This is because the getfield opcode and its parameters occupy location 1, 2, and 3. Location 1 is used for the getfield opcode, location 2 and 3 are used to hold its parameters. These parameters are used to construct an index into the runtime constant pool for the class to where the value is stored. The following diagram shows what the bytecode array looks like for the employeeName method:

Actually, the bytecode array contains bytes that represent the instructions. Looking at a .class file with a hex editor, you would see the following values in the bytecode array:

2A , B4 , and B0 correspond to aload_0, getfield, and areturn, respectively.

public Employee(String strName, int num)
{
name = strName;
idNumber = num;
storeData(strName, num);
}

Method Employee(java.lang.String,int)
0 aload_0
1 invokespecial #3
4 aload_0
5 aload_1
6 putfield #5
9 aload_0
10 iload_2
11 putfield #4
14 aload_0
15 aload_1
16 iload_2
17 invokespecial #6
20 return

The first opcode instruction at location 0, aload_0, pushes the this reference onto the operand stack. (Remember, the first entry of the local variable table for instance methods and constructors is the this reference.)

The next opcode instruction at location 1, invokespecial, calls the constructor of this class's superclass. Because all classes that do not explicitly extend any other class implicitly inherit from java.lang.Object , the compiler provides the necessary bytecode to invoke this base class constructor. During this opcode, the top value from the operand stack, this, is popped.

The next two opcodes, at locations 4 and 5 push the first two entries from the local variable table onto the operand stack. The first value to be pushed is the this reference. The second value is the first formal parameter to the constructor, strName . These values are pushed in preparation for the putfield opcode instruction at location 6.

The putfield opcode pops the two top values off the stack and stores a reference to strName into the instance data name of the object referenced by this .

The next three opcode instructions at locations 9, 10, and 11 perform the same operation with the second formal parameter to the constructor, num , and the instance variable, idNumber .

The next three opcode instructions at locations 14, 15, and 16 prepare the stack for the storeData method call. These instructions push the this reference, strName , and num , respectively. The this reference must be pushed because an instance method is being called. If the method was declared static, the this reference would not need to be pushed. The strName and num values are pushed since they are the parameters to the storeData method. When the storeData method executes, the this reference, strName , and num , will occupy indexes 0, 1, and 2, respectively, of the local variable table contained in the frame for that method.

Compiler options

The javac compiler provides a few options that you need to know. The first is the -O option. The JDK documentation claims that -O will optimize your code for execution speed. Using -O with the javac compiler with the Sun Java 2 SDK has no effect on the generated code. Previous versions of the Sun javac compiler performed some rudimentary bytecode optimizations, but these have since been removed. The SDK documentation, however, has not been updated. The only reason -O remains as an option is for compatibility with older make files. Therefore, there is currently no reason to use it.

This also means that the bytecode that is generated by the javac compiler is not any better than the code that you write. For example, if you write a loop that contains an invariant, the invariant will not be removed from the loop by the javac compiler. Programmers are used to compilers from other languages that clean up badly written code. Unfortunately, javac does not do this. More importantly, the javac compiler does not perform simple optimizations like loop unrolling, algebraic simplification, strength reduction, and others. To get these benefits and other simple optimizations, the programmer must perform them on the Java source code and not rely on the javac compiler to perform them. There are many techniques you can use to make the Java compiler generate faster and smaller bytecode. Unfortunately, until Java compilers perform them, you must implement them yourself to achieve their benefits.

The javac compiler also supplies the -g and -g:none options. The -g option tells the compiler to generate all the debugging information. The -g:none option tells the compiler to generate no debugging information. Compiling with -g:none generates the smallest possible .class file. Therefore, this option should be used when trying to generate the smallest possible .class files prior to deployment.

Java debuggers

One very useful feature that I have yet to see in a Java debugger is a disassembly view similar to that of a C or C++ debugger. Disassembling Java code would reveal the bytecode, much like disassembling C or C++ code reveals assembler code. In addition to this feature, another useful feature could be the ability to single step through the bytecode, executing one opcode at a time.

This level of functionality would allow the programmer to see, first hand, the bytecode generated by the Java compiler as well as step through it during debugging. The more information a programmer has about the code generated and executed, the better chance there is of avoiding problems. This type of debugger feature would also encourage programmers to look at, and understand, the bytecode that is executing for their source code.

Server-side web programming

2007-09-06T06:39:00.000-07:00

Web applications are client/server applications. The web browser is the client. The server is a program running on some computer which is identified by a number called the port to distinguish it from other server programs. Clients access the server program via the pair (server,port) called a socket. The browser client (as well as other client programs) initiates the interaction with a URL request:
protocol://data_source

where the protocol is any number of possiblities, including http, file, https, ftp, etc. The data_source can be any number of things from a regular file on the client's machine to a file or program on some server such as these:
file://file
http://server/dir1/dir2/file
http://server/dir1/program
http://server:port/file (server running on alternate port)

The protocol normally dictates the port, but we can specify it if it's different than the usual one. If the target file is a directory, then a default file or program is chosen as the source.

Server-side web programming means that an HTTP request from a browser causes the web server to run a program which generates HTML (or other data) and sends it back to the browser. Java uses Servlets and Java Server Pages (JSP) for server-side programming. These two software technologies are Java's contribution to the two primary styles of server-side programming:
HTML code generated entirely by programming: Perl/CGI, Servlets
program code embedded within HTML code: PHP, ASP, JSP
Server-side programming stands in contrast to client-side programming which is usually equated with JavaScript, but can also be effected by Java Applets, Flash, or any others which provide a browser plugin.

Tomcat web server
A Java Servlet is an object that can the executed by an HTTP server due to the invocation of a browser client. This ability is not automatically part of standard web servers like Apache and Microsoft's IIS so we need a specialized web server for that purpose. The Apache open source tomcat web server serves our needs; its website is this:
http://tomcat.apache.org/
In order to permit user access and not to conflict with other web services — the standard web service runs on port 80, a restricted port in UNIX system — tomcat runs on the standard port 8080. The Tomcat web server starts a Java virtual machine (JVM) and handles browser client accesses by executing the servlets in threads created by this JVM which makes the entire web service process very fast, in contrast, say to CGI programming in which each web server activation requires a new process creation.
Eclipse Web applications setup
The Eclipse IDE supports many plugin tools and allows developers to directly create and modify plugins. It's not clear at this stage of development what will be the definitive plugin tool for web development but the so-called webtools development packages found at
http://www.eclipse.org/webtools/
seems like a likely contender. We'll use the webtools current release build, version R-1.5.2-200610261841, which requires eclipse version 3.1.1. The current stable webtools release is 1.5M4, but this requires eclipse version 3.2M4.

The eclipse webtools and support plugins you'll need are these:
wtp-sdk-R-1.5.2-200610261841.zip
emf-sdo-xsd-SDK-2.2.1.zip
GEF-SDK-3.2.1.zip
JEM-SDK-1.2.1.zip

The Apache tomcat web server, currently version 6.0.14, uses this distribution file, also available through the tomcat website:
apache-tomcat-6.0.14.zip

Install Webtools
Assuming that eclipse 3.1.1 is installed as the directory "eclipse", extract these zip archives:
wtp-sdk-R-1.5.2-200610261841.zip
emf-sdo-xsd-SDK-2.2.1.zip
GEF-SDK-3.2.1.zip
JEM-SDK-1.2.1.zip

into the directory containing the eclipse subdirectory (e.g., the C:\ directory in my suggested Windows installation of Eclipse). These zip archives already have eclipse as their top-level directory, and so their contents will be extracted correctly into the eclipse subdirectory.

The zip files extract almost entirely into the features and plugins subdirectories of eclipse. The EMF zip archive contains duplicates of the top-level files epl-v10.html and notice.html You can either let them be overwritten or not — it is unimportant.
Install Tomcat
Unzip the file apache-tomcat-6.0.14.zip into your folder of choice; it creates the subdirectory
apache-tomcat-6.0.14
A good choice for location might be the same directory holding eclipse.
Tomcat Server Setup in Eclipse
Open Eclipse and select New Other. You should see quite a number of new categories now available due to the plugin additions.

To create the Tomcat server:
Open the Server category, select the Server entry within and click Next.
In the Define a New Server window, select Apache Tomcat v5.5 Server, click Next.
In the Tomcat Server window, click the Browse button to specify the Tomcat installation directory, apache-tomcat-6.0.14. Click Finish.
Specify the web browser to use
Eclipse has its own internal web browser that can be used to display web content, but you may want to use an external web browser. In eclipse, select:
Window Preferences General Web Browser
It's not clear that the so-called Default System Web Browser will find the right thing. You can add your own external browser if necessary. On a Windows installation, Internet Explorer will be among the list of browsers; you can simply select it, it takes no parameters.

For other browsers, e.g., firefox or mozilla browsers, if already on the list, select it, click Edit, and set the parameters to
-url %URL%

If not in the list, click New, fill in the Name (e.g., "Firefox"); browse to find the location of the executable and finally set the parameters as above.
The structure of a Servlet
The activation of a servlet is initiated by a client-side (browser) request. There are two types of requests: GET and POST. GET requests are most standard and always activated by typing any URL into a browser. GET requests are also those in which you see parameters delivered in the URL itself after the "?" character, a portion called the query string. POST requests are less frequent and are normally initiated by HTML forms.

A Java Servlet is an extension of the javax.servlet.http.HttpServlet. A GET or POST request activates one of the two built-in functions: doGet or doPost, respectively. Many server-side programs do not need to differentiate between these two activations and it is often common to merge the behaviors of these activations.
Servlet template
import java.io.*; // for PrintWriter, IOException
import javax.servlet.*; // for Servlet*
import javax.servlet.http.*; // for HttpServlet*

public class MyServlet extends HttpServlet implements Servlet
{
protected void
doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/* ... */
}

protected void
doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/* ... */
}
}

Typical content for the doGet or doPost function is as follows:
response.setContentType("text/html");
PrintWriter out = response.getWriter();

Hibernate

2007-09-02T04:11:00.000-07:00

What is Hibernate?
Hibernate 3.0, the latest Open Source persistence technology at the heart of J2EE EJB 3.0 is available for download from Hibernet.org.The Hibernate 3.0 core is 68,549 lines of Java code together with 27,948 lines of unit tests, all freely available under the LGPL, and has been in development for well over a year. Hibernate maps the Java classes to the database tables. It also provides the data query and retrieval facilities that significantly reduces the development time. Hibernate is not the best solutions for data centric applications that only uses the stored-procedures to implement the business logic in database. It is most useful with object-oriented domain modes and business logic in the Java-based middle-tier. Hibernate allows transparent persistence that enables the applications to switch any database. Hibernate can be used in Java Swing applications, Java Servlet-based applications, or J2EE applications using EJB session beans.

Features of Hibernate

Hibernate 3.0 provides three full-featured query facilities: Hibernate Query Language, the newly enhanced Hibernate Criteria Query API, and enhanced support for queries expressed in the native SQL dialect of the database.
Filters for working with temporal (historical), regional or permissioned data.
Enhanced Criteria query API: with full support for projection/aggregation and subselects.
Runtime performance monitoring: via JMX or local Java API, including a second-level cache browser.
Eclipse support, including a suite of Eclipse plug-ins for working with Hibernate 3.0, including mapping editor, interactive query prototyping, schema reverse engineering tool.
Hibernate is Free under LGPL: Hibernate can be used to develop/package and distribute the applications for free.
Hibernate is Scalable: Hibernate is very performant and due to its dual-layer architecture can be used in the clustered environments.
Less Development Time: Hibernate reduces the development timings as it supports inheritance, polymorphism, composition and the Java Collection framework.
Automatic Key Generation: Hibernate supports the automatic generation of primary key for your.
JDK 1.5 Enhancements: The new JDK has been released as a preview earlier this year and we expect a slow migration to the new 1.5 platform throughout 2004. While Hibernate3 still runs perfectly with JDK 1.2, Hibernate3 will make use of some new JDK features. JSR 175 annotations, for example, are a perfect fit for Hibernate metadata and we will embrace them aggressively. We will also support Java generics, which basically boils down to allowing type safe collections.
EJB3-style persistence operations: EJB3 defines the create() and merge() operations, which are slightly different to Hibernate's saveOrUpdate() and saveOrUpdateCopy() operations. Hibernate3 will support all four operations as methods of the Session interface.
Hibernate XML binding enables data to be represented as XML and POJOs interchangeably.
The EJB3 draft specification support for POJO persistence and annotations.

In this lesson you will learn the architecture of Hibernate. The following diagram describes the high level architecture of hibernate:

The above diagram shows that Hibernate is using the database and configuration data to provide persistence services (and persistent objects) to the application.

To use Hibernate, it is required to create Java classes that represents the table in the database and then map the instance variable in the class with the columns in the database. Then Hibernate can be used to perform operations on the database like select, insert, update and delete the records in the table. Hibernate automatically creates the query to perform these operations.

Hibernate architecture has three main components:

· Connection Management
Hibernate Connection management service provide efficient management of the database connections. Database connection is the most expensive part of interacting with the database as it requires a lot of resources of open and close the database connection.

· Transaction management:
Transaction management service provide the ability to the user to execute more than one database statements at a time.

· Object relational mapping:
Object relational mapping is technique of mapping the data representation from an object model to a relational data model. This part of the hibernate is used to select, insert, update and delete the records form the underlying table. When we pass an object to a Session.save() method, Hibernate reads the state of the variables of that object and executes the necessary query.

Hibernate is very good tool as far as object relational mapping is concern, but in terms of connection management and transaction management, it is lacking in performance and capabilities. So usually hibernate is being used with other connection management and transaction management tools. For example apache DBCP is used for connection pooling with the Hibernate.

Hibernate provides a lot of flexibility in use. It is called "Lite" architecture when we only uses the object relational mapping component. While in "Full Cream" architecture all the three component Object Relational mapping, Connection Management and Transaction Management) are used.

In this section I will show you how to create a simple program to insert record in MySQL database. You can run this program from Eclipse or from command prompt as well. I am assuming that you are familiar with MySQL and Eclipse environment.

Configuring Hibernate
In this application Hibernate provided connection pooling and transaction management is used for simplicity. Hibernate uses the hibernate.cfg.xml to create the connection pool and setup required environment.

Here is the code:

"-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

com.mysql.jdbc.Driver
jdbc:mysql://localhost/hibernatetutorial
root

10
true
org.hibernate.dialect.MySQLDialect
update

contact.hbm.xml"/>

In the above configuration file we specified to use the "hibernatetutorial" which is running on localhost and the user of the database is root with no password. The dialect property is org.hibernate.dialect.MySQLDialect which tells the Hibernate that we are using MySQL Database. Hibernate supports many database. With the use of the Hibernate (Object/Relational Mapping and Transparent Object Persistence for Java and SQL Databases), we can use the following databases dialect type property:

DB2 - org.hibernate.dialect.DB2Dialect
HypersonicSQL - org.hibernate.dialect.HSQLDialect
Informix - org.hibernate.dialect.InformixDialect
Ingres - org.hibernate.dialect.IngresDialect
Interbase - org.hibernate.dialect.InterbaseDialect
Pointbase - org.hibernate.dialect.PointbaseDialect
PostgreSQL - org.hibernate.dialect.PostgreSQLDialect
Mckoi SQL - org.hibernate.dialect.MckoiDialect
Microsoft SQL Server - org.hibernate.dialect.SQLServerDialect
MySQL - org.hibernate.dialect.MySQLDialect
Oracle (any version) - org.hibernate.dialect.OracleDialect
Oracle 9 - org.hibernate.dialect.Oracle9Dialect
Progress - org.hibernate.dialect.ProgressDialect
FrontBase - org.hibernate.dialect.FrontbaseDialect
SAP DB - org.hibernate.dialect.SAPDBDialect
Sybase - org.hibernate.dialect.SybaseDialect
Sybase Anywhere - org.hibernate.dialect.SybaseAnywhereDialect

The contact.hbm.xml"/> property is the mapping for our contact table.

Writing First Persistence Class
Hibernate uses the Plain Old Java Objects (POJOs) classes to map to the database table. We can configure the variables to map to the database column. Here is the code for Contact.java:

package roseindia.tutorial.hibernate;

/**
* @author Deepak Kumar
*
* Java Class to map to the datbase Contact Table
*/
public class Contact {
private String firstName;
private String lastName;
private String email;
private long id;

/**
* @return Email
*/
public String getEmail() {
return email;
}

/**
* @return First Name
*/
public String getFirstName() {
return firstName;
}

/**
* @return Last name
*/
public String getLastName() {
return lastName;
}

/**
* @param string Sets the Email
*/
public void setEmail(String string) {
email = string;
}

/**
* @param string Sets the First Name
*/
public void setFirstName(String string) {
firstName = string;
}

/**
* @param string sets the Last Name
*/
public void setLastName(String string) {
lastName = string;
}

/**
* @return ID Returns ID
*/
public long getId() {
return id;
}

/**
* @param l Sets the ID
*/
public void setId(long l) {
id = l;
}

}

Mapping the Contact Object to the Database Contact table
The file contact.hbm.xml is used to map Contact Object to the Contact table in the database. Here is the code for contact.hbm.xml:

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

Setting Up MySQL Database
In the configuration file(hibernate.cfg.xml) we have specified to use hibernatetutorial database running on localhost. So, create the databse ("hibernatetutorial") on the MySQL server running on localhost.

Developing Code to Test Hibernate example
Now we are ready to write a program to insert the data into database. We should first understand about the Hibernate's Session. Hibernate Session is the main runtime interface between a Java application and Hibernate. First we are required to get the Hibernate Session.SessionFactory allows application to create the Hibernate Sesssion by reading the configuration from hibernate.cfg.xml file. Then the save method on session object is used to save the contact information to the database:

session.save(contact)

Here is the code of FirstExample.java

package roseindia.tutorial.hibernate;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
* @author Deepak Kumar
*
* http://www.roseindia.net
* Hibernate example to inset data into Contact table
*/
public class FirstExample {
public static void main(String[] args) {
Session session = null;

try{
// This step will read hibernate.cfg.xml and prepare hibernate for use
SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
session =sessionFactory.openSession();
//Create new instance of Contact and set values in it by reading them from form object
System.out.println("Inserting Record");
Contact contact = new Contact();
contact.setId(3);
contact.setFirstName("Deepak");
contact.setLastName("Kumar");
contact.setEmail("deepak_38@yahoo.com");
session.save(contact);
System.out.println("Done");
}catch(Exception e){
System.out.println(e.getMessage());
}finally{
// Actual contact insertion will happen at this step
session.flush();
session.close();

}

}
}

In the next section I will show how to run and test the program.

Hibernate is free open source software it can be download from http://www.hibernate.org/6.html. Visit the site and download Hibernate 3.0. You can download the Hibernate and install it yourself. But I have provided very thing in one zip file. Download the example code and library from here and extract the content in your favorite directory say "C:\hibernateexample". Download file contains the Eclipse project. To run the example you should have the Eclipse IDE on your machine. Start the Eclipse project and select Java Project as shown below.

Click on "Next" button. In the new screen, enter "hibernateexample" as project name and browse the extracted directory "C:\hibernateexample".

Click on "Next" button. In the next screen leave the output folder as default "hibernateexample/bin" .

Click on the "Finish" button.

Now Open the FirstExample.java in the editor as show below.

Copy contact.hbm.xml, and hibernate.cfg.xml in the bin directory of the project using windows explorer. To run the example select Run-> Run As -> Java Application from the menu bar as shown below.

This will run the Hibernate example program in Eclipse following output will displayed on the Eclipse Console.

In this section I showed you how to run the our first Hibernate 3.0 example.

In the last example we created contact.hbm.xml to map Contact Object to the Contact table in the database. Now let's understand the each component of the mapping file.

To recall here is the content of contact.hbm.xml:

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

Hibernate mapping documents are simple xml documents. Here are important elements of the mapping file:.

element
The first or root element of hibernate mapping document is element. Between the <hibernate-mapping> tag class element(s) are present.
element
The element maps the class object with corresponding entity in the database. It also tells what table in the database has to access and what column in that table it should use. Within one element, several mappings are possible.
element
The element in unique identifier to identify and object. In fact element map with the primary key of the table. In our code :

primary key maps to the ID field of the table CONTACT. The attributes of the id element are:

name: The property name used by the persistent class.
column: The column used to store the primary key value.
type: The Java data type used.
unsaved-value: This is the value used to determine if a class has been made persistent. If the value of the id attribute is null, then it means that this object has not been persisted.

element
The method is used to generate the primary key for the new record. Here is some of the commonly used generators :

* Increment - This is used to generate primary keys of type long, short or int that are unique only. It should not be used in the clustered deployment environment.

* Sequence - Hibernate can also use the sequences to generate the primary key. It can be used with DB2, PostgreSQL, Oracle, SAP DB databases.

* Assigned - Assigned method is used when application code generates the primary key.
element
The property elements define standard Java attributes and their mapping into database schema. The property element supports the column child element to specify additional properties, such as the index name on a column or a specific column type.

In this lesson you will learn about hibernate method in detail. Hibernate generator element generates the primary key for new record. There are many options provided by the generator method to be used in different situations.

The element

This is the optional element under element. The element is used to specify the class name to be used to generate the primary key for new record while saving a new record. The element is used to pass the parameter (s) to the class. Here is the example of generator element from our first application:

In this case element do not generate the primary key and it is required to set the primary key value before calling save() method.

Here are the list of some commonly used generators in hibernate:

Generator	Description
increment	It generates identifiers of type long, short or int that are unique only when no other process is inserting data into the same table. It should not the used in the clustered environment.
identity	It supports identity columns in DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL. The returned identifier is of type long, short or int.
sequence	The sequence generator uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in Interbase. The returned identifier is of type long, short or int
hilo	The hilo generator uses a hi/lo algorithm to efficiently generate identifiers of type long, short or int, given a table and column (by default hibernate_unique_key and next_hi respectively) as a source of hi values. The hi/lo algorithm generates identifiers that are unique only for a particular database. Do not use this generator with connections enlisted with JTA or with a user-supplied connection.
seqhilo	The seqhilo generator uses a hi/lo algorithm to efficiently generate identifiers of type long, short or int, given a named database sequence.
uuid	The uuid generator uses a 128-bit UUID algorithm to generate identifiers of type string, unique within a network (the IP address is used). The UUID is encoded as a string of hexadecimal digits of length 32.
guid	It uses a database-generated GUID string on MS SQL Server and MySQL.
native	It picks identity, sequence or hilo depending upon the capabilities of the underlying database.
assigned	lets the application to assign an identifier to the object before save() is called. This is the default strategy if no element is specified.
select	retrieves a primary key assigned by a database trigger by selecting the row by some unique key and retrieving the primary key value.
foreign	uses the identifier of another associated object. Usually used in conjunction with a primary key association.

As we have seen in the last section that the increment class generates identifiers of type long, short or int that are unique only when no other process is inserting data into the same table. In this lesson I will show you how to write running program to demonstrate it. You should not use this method to generate the primary key in case of clustured environment.

In this we will create a new table in database, add mappings in the contact.hbm.xml file, develop the POJO class (Book.java), write the program to test it out.

Create Table in the mysql database:
User the following sql statement to create a new table in the database.
CREATE TABLE `book` (
`id` int(11) NOT NULL default '0',
`bookname` varchar(50) default NULL,
PRIMARY KEY (`id`)
) TYPE=MyISAM

Developing POJO Class (Book.java)
Book.java is our POJO class which is to be persisted to the database table "book".

/**
* @author Deepak Kumar
*
* http://www.roseindia.net
* Java Class to map to the database Book table
*/
package roseindia.tutorial.hibernate;

public class Book {
private long lngBookId;
private String strBookName;

/**
* @return Returns the lngBookId.
*/
public long getLngBookId() {
return lngBookId;
}
/**
* @param lngBookId The lngBookId to set.
*/
public void setLngBookId(long lngBookId) {
this.lngBookId = lngBookId;
}
/**
* @return Returns the strBookName.
*/
public String getStrBookName() {
return strBookName;
}
/**
* @param strBookName The strBookName to set.
*/
public void setStrBookName(String strBookName) {
this.strBookName = strBookName;
}
}

Adding Mapping entries to contact.hbm.xml
Add the following mapping code into the contact.hbm.xml file

Note that we have used increment for the generator class. *After adding the entries to the xml file copy it to the bin directory of your hibernate eclipse project(this step is required if you are using eclipse).

Write the client program and test it out
Here is the code of our client program to test the application.

/**
* @author Deepak Kumar
*
* http://www.roseindia.net
* Example to show the increment class of hibernate generator element to
* automatically generate the primay key
*/
package roseindia.tutorial.hibernate;

//Hibernate Imports
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class IdIncrementExample {
public static void main(String[] args) {
Session session = null;

try{
// This step will read hibernate.cfg.xml and prepare hibernate for use
SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
session =sessionFactory.openSession();

org.hibernate.Transaction tx = session.beginTransaction();

//Create new instance of Contact and set values in it by reading them from form object
System.out.println("Inserting Book object into database..");
Book book = new Book();
book.setStrBookName("Hibernate Tutorial");
session.save(book);
System.out.println("Book object persisted to the database.");
tx.commit();
session.flush();
session.close();
}catch(Exception e){
System.out.println(e.getMessage());
}finally{
}

}
}

To test the program Select Run->Run As -> Java Application from the eclipse menu bar. This will create a new record into the book table.

In this tutorial we will show how to update a row with new information by retrieving data from the underlying database using the hibernate. Lets first write a java class to update a row to the database.

Create a java class:
Here is the code of our java file (UpdateExample.java), where we will update a field name "InsuranceName" with a value="Jivan Dhara" from a row of the insurance table.

Here is the code of delete query: UpdateExample .java

package roseindia.tutorial.hibernate;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class UpdateExample {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Session sess = null;
try {
SessionFactory fact = new Configuration().configure().buildSessionFactory();
sess = fact.openSession();
Transaction tr = sess.beginTransaction();
Insurance ins = (Insurance)sess.get(Insurance.class, new Long(1));
ins.setInsuranceName("Jivan Dhara");
ins.setInvestementAmount(20000);
ins.setInvestementDate(new Date());
sess.update(ins);
tr.commit();
sess.close();
System.out.println("Update successfully!");
}
catch(Exception e){
System.out.println(e.getMessage());
}
}
}

Download this code.

Output:

log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).

log4j:WARN Please initialize the log4j system properly.

Hibernate: select insurance0_.ID as ID0_0_, insurance0_.insurance_name as insurance2_0_0_, insurance0_.invested_amount as invested3_0_0_, insurance0_.investement_date as investem4_0_0_ from insurance insurance0_ where insurance0_.ID=?

Hibernate: update insurance set insurance_name=?, invested_amount=?, investement_date=? where ID=?

Update successfully!

Hibernate Query Language or HQL for short is extremely powerful query language. HQL is much like SQL and are case-insensitive, except for the names of the Java Classes and properties. Hibernate Query Language is used to execute queries against database. Hibernate automatically generates the sql query and execute it against underlying database if HQL is used in the application. HQL is based on the relational object models and makes the SQL object oriented. Hibernate Query Language uses Classes and properties instead of tables and columns. Hibernate Query Language is extremely powerful and it supports Polymorphism, Associations, Much less verbose than SQL.

There are other options that can be used while using Hibernate. These are Query By Criteria (QBC) and Query BY Example (QBE) using Criteria API and the Native SQL queries. In this lesson we will understand HQL in detail.

Why to use HQL?

Full support for relational operations: HQL allows representing SQL queries in the form of objects. Hibernate Query Language uses Classes and properties instead of tables and columns.
Return result as Object: The HQL queries return the query result(s) in the form of object(s), which is easy to use. This elemenates the need of creating the object and populate the data from result set.
Polymorphic Queries: HQL fully supports polymorphic queries. Polymorphic queries results the query results along with all the child objects if any.
Easy to Learn: Hibernate Queries are easy to learn and it can be easily implemented in the applications.
Support for Advance features: HQL contains many advance features such as pagination, fetch join with dynamic profiling, Inner/outer/full joins, Cartesian products. It also supports Projection, Aggregation (max, avg) and grouping, Ordering, Sub queries and SQL function calls.
Database independent: Queries written in HQL are database independent (If database supports the underlying feature).

Understanding HQL Syntax
Any Hibernate Query Language may consist of following elements:

Clauses
Aggregate functions
Subqueries

Clauses in the HQL are:

from
select
where
order by
group by

Aggregate functions are:

avg(...), sum(...), min(...), max(...)
count(*)
count(...), count(distinct ...), count(all...)

Subqueries
Subqueries are nothing but its a query within another query. Hibernate supports Subqueries if the underlying database supports it.

In this lesson we will create insurance table and populate it with the data. We will use insurance table for rest of the HQL tutorial.

To create the insurance table and insert the sample data, run the following sql query:

/*Table structure for table `insurance` */

drop table if exists `insurance`;

CREATE TABLE `insurance` (

  `ID` int(11) NOT NULL default '0',

  `insurance_name` varchar(50) default NULL,

  `invested_amount` int(11) default NULL,

  `investement_date` datetime default NULL,

  PRIMARY KEY  (`ID`)

) TYPE=MyISAM;

/*Data for the table `insurance` */

insert into `insurance` values (1,'Car Insurance',1000,'2005-01-05 00:00:00');

insert into `insurance` values (2,'Life Insurance',100,'2005-10-01 00:00:00');

insert into `insurance` values (3,'Life Insurance',500,'2005-10-15 00:00:00');

insert into `insurance` values (4,'Car Insurance',2500,'2005-01-01 00:00:00');

insert into `insurance` values (5,'Dental Insurance',500,'2004-01-01 00:00:00');

insert into `insurance` values (6,'Life Insurance',900,'2003-01-01 00:00:00');

insert into `insurance` values (7,'Travel Insurance',2000,'2005-02-02 00:00:00');

insert into `insurance` values (8,'Travel Insurance',600,'2005-03-03 00:00:00');

insert into `insurance` values (9,'Medical Insurance',700,'2005-04-04 00:00:00');

insert into `insurance` values (10,'Medical Insurance',900,'2005-03-03 00:00:00');

insert into `insurance` values (11,'Home Insurance',800,'2005-02-02 00:00:00');

insert into `insurance` values (12,'Home Insurance',750,'2004-09-09 00:00:00');

insert into `insurance` values (13,'Motorcycle Insurance',900,'2004-06-06 00:00:00');

insert into `insurance` values (14,'Motorcycle Insurance',780,'2005-03-03 00:00:00');

In this lesson we will write example code to select the data from Insurance table using Hibernate Select Clause. The select clause picks up objects and properties to return in the query result set. Here is the query:

Select insurance.lngInsuranceId, insurance.insuranceName, insurance.investementAmount, insurance.investementDate from Insurance insurance

which selects all the rows (insurance.lngInsuranceId, insurance.insuranceName, insurance.investementAmount, insurance.investementDate) from Insurance table.

Hibernate generates the necessary sql query and selects all the records from Insurance table. Here is the code of our java file which shows how select HQL can be used:

package roseindia.tutorial.hibernate;

import org.hibernate.Session;
import org.hibernate.*;
import org.hibernate.cfg.*;

import java.util.*;

/**
* @author Deepak Kumar
*
* http://www.roseindia.net
* HQL Select Clause Example
*/
public class SelectClauseExample {
public static void main(String[] args) {
Session session = null;

try{
// This step will read hibernate.cfg.xml and prepare hibernate for use
SessionFactory sessionFactory = new Configuration().configure()
.buildSessionFactory();
session =sessionFactory.openSession();

//Create Select Clause HQL
String SQL_QUERY ="Select insurance.lngInsuranceId,insurance.insuranceName," +
"insurance.investementAmount,insurance.investementDate from Insurance insurance";
Query query = session.createQuery(SQL_QUERY);
for(Iterator it=query.iterate();it.hasNext();){
Object[] row = (Object[]) it.next();
System.out.println("ID: " + row[0]);
System.out.println("Name: " + row[1]);
System.out.println("Amount: " + row[2]);
}

session.close();
}catch(Exception e){
System.out.println(e.getMessage());
}finally{
}
}
}

http://www.roseindia.net/hibernate/index.shtml

SCJP 1.5 Mocks

2007-08-20T00:54:00.000-07:00

John Meyer's SCJP 1.5 exam with GUI support for drag and drops.
WhizLabs SCJP Preparation Kit with free sample exam
EPractize Labs free demo: 25 questions
ENTHUWARE's JQPlus V5 - 11 Tests - Most Advanced Java Based Simulator - Free Sample Exam
eXamulator: 62 questions in total
eJavaGuru.com's quiz on Enums
JavaBlackBelt.com
Marcus Green's 1.5 exam
uCertify Java Preparation Kits with free Practice Test and Study Notes, Article and How Tos.
Cafe4Java's Collection of free SCJP 5.0 exam questions, arranged by (sub)objectives like collections, file I/O etc

SCJP Mock Exams

2007-08-07T22:09:00.000-07:00

http://www.akgupta.com/Java/mock_exam.htm

http://java.about.com/gi/dynamic/offsite.htm

http://www.javacertificate.net/scjp_1.htm

http://www.javaprepare.com/quests/test.html

http://www.javaranch.com/maha/_Mock_Exams/_mock_exams.html

http://www.javacertificationexams.com/scjp-mock-exams.php

Linux Files and Directories

2007-08-01T23:59:00.000-07:00

pwd - Display name of current directory

The command pwd is used to display the full path name of the current directory.

cd - Switch to another directory

To switch to another directory, the command cd is used.

Examples	What it does
cd	Will place you in your home directory
cd /	Will move you to the root directory
cd /etc	Will move you to the /etc directory
cd ../	Will move you back one directory

mkdir and rmdir - Create/Delete directories

The command mkdir is used to create a new directory.

The command rmdir or rm -r is used to delete a directory or directories. Be careful in testing the following delete commands. You will probably want to create sample directories first.

Examples	What it does
mkdir mydirectory	Will create a new directory named 'mydirectory'
rmdir existingdirectory	Will delete the existing directory named 'existingdirectory'
rm -r existingdirectories	Will delete the existing directory named 'existingdirectories' and all directories and files below it.

ls - List the Contents of a directory

The command ls is used to the contents of a directory.

Options	What it does
-l	long listing
-R	list current directory and all other directories within current directory
-a	list hidden files
-CF	list in column format and append '*' to executable files, '@' to symbolic linked files, '/' to directories
-r	list in reverse alphabetically order
-t	list more recent accessed files first
filename(s)	Values to match

Examples	What it does
ls	only list file/directory names in current directory
ls -l	list all file/directory information in current directory(long version)
ls -R	list all files in current directories and below
ls -lt	list all files, sorted by most recent accessed first
ls -lt /etc/rc*	list files in the '/etc/ directory, only starting with 'rc' and sort results by most recent

Wildcards

Wildcard characters are used to help find file or directory names

Options	What it does
*	asterisk symbol is used to represent any character(s)
?	question mark is used to represent any single character
[from-to ]	Values entered within square brackets represent a range (from-to) for a single character
[!from-to ]	Values entered within square brackets represent a range (from-to) to exclude for a single character

Examples	What it does
a*	all files starting with the letter 'a'
*z	all files where the last character is a 'z'
*am**	all files that start with the letter 'a' and end with 'm'
th??	all files that start with 'th' and are only four characters long
[a-c]*	all files that start with 'a, b or c'
x[A-C]*	all files that start with the letter 'x' and the second character contains 'A, B or C'
[!M-O]*	all files except those that start with 'M, N or O'

cp - Copy files

To copy a file, the command cp is used

Example: cp oldfile myfile - Will copy the existing file 'oldfile' to a new file 'myfile'

mv - Rename files

The command mv is used to rename a file

Example: mv myfile yourfile - Will rename the file 'myfile' to 'yourfile'

rm - Delete files

Examples	What it does
rm myfile	remove the file 'myfile'
rm -i abc*	prompt to remove each file in current directory starting with 'abc'
rm abc*	remove all files in current directory starting with 'abc' automatically

wc - Count the number of lines or characters

The command wc is used to count lines, words or characters in a file or piped results from another command.

Options	What it does
-c	Number of characters
-w	Number of words
-l
filename	file name(s) to use

Examples	What it does
wc /etc/sendmail.cf	Lists the number of lines, words and characters in the file 'sendmail.cf'
ls /etc \| wc -l	Lists the number of files and directories in the directory 'etc'

file - Display Type-of-File Description

Files can consist of several types. The command file is used to display a description for the type.

Example: file a* will list all files in the current directory that start with the letter "a" and provide a description for the file type.

cat - concatenate files

The command cat is a multi-purpose utility and is mostly used with TEXT files.

Create a new file and optionally allow the manual entry of contents

cat >[filename]
Example: cat >myfile will create a file named myfile and allow you to enter contents.
Press Control-D to exit entry mode.
WARNING: If "myfile" already existed, this command would replace the old file with the contents of the new file.

Combine text files

cat file1 file2 >newfile - This will combine file1 and file2 into newfile.

Dissplay the contents of a file

cat myfile

Delete the contents of a file

cat /dev/null >myfile

HIBERNATE - Relational Persistence for Idiomatic Java

2007-07-27T07:43:00.000-07:00

Introduction to Hibernate

1.1. Preface

This chapter is an introductory tutorial for new users of Hibernate. We start
with a simple command line application using an in-memory database and develop
it in easy to understand steps.

This tutorial is intended for new users of Hibernate but requires Java and
SQL knowledge. It is based on a tutorial by Michael Gloegl, the third-party
libraries we name are for JDK 1.4 and 5.0. You might need others for JDK 1.3.

The source code for the tutorial is included in the distribution in the
doc/reference/tutorial/ directory.

1.2. Part 1 - The first Hibernate Application

First, we'll create a simple console-based Hibernate application. We use an
Java database (HSQL DB), so we do not have to install any database server.

Let's assume we need a small database application that can store events we want to
attend, and information about the hosts of these events.

The first thing we do, is set up our development directory and put all the
Java libraries we need into it. Download the Hibernate distribution from the
Hibernate website. Extract the package and place all required libraries
found in /lib into into the /lib directory
of your new development working directory. It should look like this:

.
+lib
  antlr.jar
  cglib.jar
  asm.jar
  asm-attrs.jars
  commons-collections.jar
  commons-logging.jar
  hibernate3.jar
  jta.jar
  dom4j.jar
  log4j.jar

This is the minimum set of required libraries (note that we also copied
hibernate3.jar, the main archive) for Hibernate at the time of writing.
The Hibernate release you are using might require more or less libraries. See the
README.txt file in the lib/ directory of the
Hibernate distribution for more information about required and optional third-party
libraries. (Actually, Log4j is not required but preferred by many developers.)

Next we create a class that represents the event we want to store in database.

1.2.1. The first class

Our first persistent class is a simple JavaBean class with some properties:

package events;

import java.util.Date;

public class Event {
    private Long id;

    private String title;
    private Date date;

    public Event() {}

    public Long getId() {
        return id;
    }

    private void setId(Long id) {
        this.id = id;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
}

You can see that this class uses standard JavaBean naming conventions for property
getter and setter methods, as well as private visibility for the fields. This is
a recommended design - but not required. Hibernate can also access fields directly,
the benefit of accessor methods is robustness for refactoring. The no-argument
constructor is required to instantiate an object of this class through reflection.

The id property holds a unique identifier value for a particular event.
All persistent entity classes (there are less important dependent classes as well) will need
such an identifier property if we want to use the full feature set of Hibernate. In fact,
most applications (esp. web applications) need to distinguish objects by identifier, so you
should consider this a feature rather than a limitation. However, we usually don't manipulate
the identity of an object, hence the setter method should be private. Only Hibernate will assign
identifiers when an object is saved. You can see that Hibernate can access public, private,
and protected accessor methods, as well as (public, private, protected) fields directly. The
choice is up to you and you can match it to fit your application design.

The no-argument constructor is a requirement for all persistent classes; Hibernate
has to create objects for you, using Java Reflection. The constructor can be
private, however, package visibility is required for runtime proxy generation and
efficient data retrieval without bytecode instrumentation.

Place this Java source file in a directory called src in the
development folder, and in its correct package. The directory should now look like this:

.
+lib
  <Hibernate and third-party libraries>
+src
  +events
    Event.java

In the next step, we tell Hibernate about this persistent class.

1.2.2. The mapping file

Hibernate needs to know how to load and store objects of the persistent class.
This is where the Hibernate mapping file comes into play. The mapping file
tells Hibernate what table in the database it has to access, and what columns
in that table it should use.

The basic structure of a mapping file looks like this:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
[...]
</hibernate-mapping>

Note that the Hibernate DTD is very sophisticated. You can use it for
auto-completion of XML mapping elements and attributes in your editor or
IDE. You also should open up the DTD file in your text editor - it's the
easiest way to get an overview of all elements and attributes and to see
the defaults, as well as some comments. Note that Hibernate will not
load the DTD file from the web, but first look it up from the classpath
of the application. The DTD file is included in hibernate3.jar
as well as in the src/ directory of the Hibernate distribution.

We will omit the DTD declaration in future examples to shorten the code. It is
of course not optional.

Between the two hibernate-mapping tags, include a
class element. All persistent entity classes (again, there
might be dependent classes later on, which are not first-class entities) need
such a mapping, to a table in the SQL database:

<hibernate-mapping>

    <class name="events.Event" table="EVENTS">

    </class>

</hibernate-mapping>

So far we told Hibernate how to persist and load object of class Event
to the table EVENTS, each instance represented by a row in that table.
Now we continue with a mapping of the unique identifier property to the tables primary key.
In addition, as we don't want to care about handling this identifier, we configure Hibernate's
identifier generation strategy for a surrogate primary key column:

<hibernate-mapping>

    <class name="events.Event" table="EVENTS">
        <id name="id" column="EVENT_ID">
            <generator class="native"/>
        </id>
    </class>

</hibernate-mapping>

The id element is the declaration of the identifer property,
name="id" declares the name of the Java property -
Hibernate will use the getter and setter methods to access the property.
The column attribute tells Hibernate which column of the
EVENTS table we use for this primary key. The nested
generator element specifies the identifier generation strategy,
in this case we used native, which picks the best strategy depending
on the configured database (dialect). Hibernate supports database generated, globally
unique, as well as application assigned identifiers (or any strategy you have written
an extension for).

Finally we include declarations for the persistent properties of the class in
the mapping file. By default, no properties of the class are considered
persistent:


<hibernate-mapping>

    <class name="events.Event" table="EVENTS">
        <id name="id" column="EVENT_ID">
            <generator class="native"/>
        </id>
        <property name="date" type="timestamp" column="EVENT_DATE"/>
        <property name="title"/>
    </class>

</hibernate-mapping>

Just as with the id element, the name
attribute of the property element tells Hibernate which getter
and setter methods to use. So, in this case, Hibernate will look for
getDate()/setDate(), as well as getTitle()/setTitle().

Why does the date property mapping include the
column attribute, but the title
doesn't? Without the column attribute Hibernate
by default uses the property name as the column name. This works fine for
title. However, date is a reserved
keyword in most database, so we better map it to a different name.

The next interesting thing is that the title mapping also lacks
a type attribute. The types we declare and use in the mapping
files are not, as you might expect, Java data types. They are also not SQL
database types. These types are so called Hibernate mapping types,
converters which can translate from Java to SQL data types and vice versa. Again,
Hibernate will try to determine the correct conversion and mapping type itself if
the type attribute is not present in the mapping. In some cases this
automatic detection (using Reflection on the Java class) might not have the default you
expect or need. This is the case with the date property. Hibernate can't
know if the property (which is of java.util.Date) should map to a
SQL date, timestamp, or time column.
We preserve full date and time information by mapping the property with a
timestamp converter.

This mapping file should be saved as Event.hbm.xml, right in
the directory next to the Event Java class source file.
The naming of mapping files can be arbitrary, however the hbm.xml
suffix is a convention in the Hibernate developer community. The directory structure
should now look like this:

.
+lib
  <Hibernate and third-party libraries>
+src
  +events
    Event.java
    Event.hbm.xml

We continue with the main configuration of Hibernate.

1.2.3. Hibernate configuration

We now have a persistent class and its mapping file in place. It is time to configure
Hibernate. Before we do this, we will need a database. HSQL DB, a java-based SQL DBMS,
can be downloaded from the HSQL DB website. Actually, you only need the hsqldb.jar
from this download. Place this file in the lib/ directory of the
development folder.

Create a directory called data in the root of the development directory -
this is where HSQL DB will store its data files. Now start the database by running
java -classpath ../lib/hsqldb.jar org.hsqldb.Server in this data directory.
You can see it start up and bind to a TCP/IP socket, this is where our application
will connect later. If you want to start with a fresh database during this tutorial,
shutdown HSQL DB (press CTRL + C in the window), delete all files in the
data/ directory, and start HSQL DB again.

Hibernate is the layer in your application which connects to this database, so it needs
connection information. The connections are made through a JDBC connection pool, which we
also have to configure. The Hibernate distribution contains several open source JDBC connection
pooling tools, but will use the Hibernate built-in connection pool for this tutorial. Note that
you have to copy the required library into your classpath and use different
connection pooling settings if you want to use a production-quality third party
JDBC pooling software.

For Hibernate's configuration, we can use a simple hibernate.properties file, a
slightly more sophisticated hibernate.cfg.xml file, or even complete
programmatic setup. Most users prefer the XML configuration file:

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">org.hsqldb.jdbcDriver</property>
        <property name="connection.url">jdbc:hsqldb:hsql://localhost</property>
        <property name="connection.username">sa</property>
        <property name="connection.password"></property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.HSQLDialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">create</property>

        <mapping resource="events/Event.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

Note that this XML configuration uses a different DTD. We configure
Hibernate's SessionFactory - a global factory responsible
for a particular database. If you have several databases, use several
<session-factory> configurations, usually in
several configuration files (for easier startup).

The first four property elements contain the necessary
configuration for the JDBC connection. The dialect property
element specifies the particular SQL variant Hibernate generates.
Hibernate's automatic session management for persistence contexts will
come in handy as you will soon see.
The hbm2ddl.auto option turns on automatic generation of
database schemas - directly into the database. This can of course also be turned
off (by removing the config option) or redirected to a file with the help of
the SchemaExport Ant task. Finally, we add the mapping file(s)
for persistent classes to the configuration.

Copy this file into the source directory, so it will end up in the
root of the classpath. Hibernate automatically looks for a file called
hibernate.cfg.xml in the root of the classpath, on startup.

1.2.4. Building with Ant

We'll now build the tutorial with Ant. You will need to have Ant installed - get
it from the Ant download page.
How to install Ant will not be covered here. Please refer to the
Ant manual. After you
have installed Ant, we can start to create the buildfile. It will be called
build.xml and placed directly in the development directory.

A basic build file looks like this:

<project name="hibernate-tutorial" default="compile">

    <property name="sourcedir" value="${basedir}/src"/>
    <property name="targetdir" value="${basedir}/bin"/>
    <property name="librarydir" value="${basedir}/lib"/>

    <path id="libraries">
        <fileset dir="${librarydir}">
            <include name="*.jar"/>
        </fileset>
    </path>

    <target name="clean">
        <delete dir="${targetdir}"/>
        <mkdir dir="${targetdir}"/>
    </target>

    <target name="compile" depends="clean, copy-resources">
      <javac srcdir="${sourcedir}"
             destdir="${targetdir}"
             classpathref="libraries"/>
    </target>

    <target name="copy-resources">
        <copy todir="${targetdir}">
            <fileset dir="${sourcedir}">
                <exclude name="**/*.java"/>
            </fileset>
        </copy>
    </target>

</project>

This will tell Ant to add all files in the lib directory ending with .jar
to the classpath used for compilation. It will also copy all non-Java source files to the
target directory, e.g. configuration and Hibernate mapping files. If you now run Ant, you
should get this output:

C:\hibernateTutorial\>ant
Buildfile: build.xml

copy-resources:
     [copy] Copying 2 files to C:\hibernateTutorial\bin

compile:
    [javac] Compiling 1 source file to C:\hibernateTutorial\bin

BUILD SUCCESSFUL
Total time: 1 second

1.2.5. Startup and helpers

It's time to load and store some Event objects, but first
we have to complete the setup with some infrastructure code. We have to startup
Hibernate. This startup includes building a global SessionFactory
object and to store it somewhere for easy access in application code.
A SessionFactory can open up new Session's.
A Session represents a single-threaded unit of work, the
SessionFactory is a thread-safe global object, instantiated once.

We'll create a HibernateUtil helper class which takes care
of startup and makes accessing a SessionFactory convenient.
Let's have a look at the implementation:

package util;

import org.hibernate.*;
import org.hibernate.cfg.*;

public class HibernateUtil {

    private static final SessionFactory sessionFactory;

    static {
        try {
            // Create the SessionFactory from hibernate.cfg.xml
            sessionFactory = new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            // Make sure you log the exception, as it might be swallowed
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

}

This class does not only produce the global SessionFactory in
its static initializer (called once by the JVM when the class is loaded), but also
hides the fact that it uses a static singleton. It might as well lookup the
SessionFactory from JNDI in an application server.

If you give the SessionFactory a name in your configuration
file, Hibernate will in fact try to bind it to JNDI after it has been built.
To avoid this code completely you could also use JMX deployment and let the
JMX-capable container instantiate and bind a HibernateService
to JNDI. These advanced options are discussed in the Hibernate reference
documentation.

Place HibernateUtil.java in the development source directory, in
a package next to events:

.
+lib
  <Hibernate and third-party libraries>
+src
  +events
    Event.java
    Event.hbm.xml
  +util
    HibernateUtil.java
  hibernate.cfg.xml
+data
build.xml

This should again compile without problems. We finally need to configure a logging
system - Hibernate uses commons logging and leaves you the choice between Log4j and
JDK 1.4 logging. Most developers prefer Log4j: copy log4j.properties
from the Hibernate distribution (it's in the etc/ directory) to
your src directory, next to hibernate.cfg.xml.
Have a look at the example configuration and change the settings if you like to have
more verbose output. By default, only Hibernate startup message are shown on stdout.

The tutorial infrastructure is complete - and we are ready to do some real work with
Hibernate.

1.2.6. Loading and storing objects

Finally, we can use Hibernate to load and store objects. We write an
EventManager class with a main() method:

package events;
import org.hibernate.Session;

import java.util.Date;

import util.HibernateUtil;

public class EventManager {

    public static void main(String[] args) {
        EventManager mgr = new EventManager();

        if (args[0].equals("store")) {
            mgr.createAndStoreEvent("My Event", new Date());
        }

        HibernateUtil.getSessionFactory().close();
    }

    private void createAndStoreEvent(String title, Date theDate) {

        Session session = HibernateUtil.getSessionFactory().getCurrentSession();

        session.beginTransaction();

        Event theEvent = new Event();
        theEvent.setTitle(title);
        theEvent.setDate(theDate);

        session.save(theEvent);

        session.getTransaction().commit();
    }

}

We create a new Event object, and hand it over to Hibernate.
Hibernate now takes care of the SQL and executes INSERTs
on the database. Let's have a look at the Session and
Transaction-handling code before we run this.

A Session is a single unit of work. For now we'll keep things
simple and assume a one-to-one granularity between a Hibernate Session
and a database transaction. To shield our code from the actual underlying transaction
system (in this case plain JDBC, but it could also run with JTA) we use the
Transaction API that is available on the Hibernate Session.

What does sessionFactory.getCurrentSession() do? First, you can call it
as many times and anywhere you like, once you get hold of your SessionFactory
(easy thanks to HibernateUtil). The getCurrentSession()
method always returns the "current" unit of work. Remember that we switched the configuration
option for this mechanism to "thread" in hibernate.cfg.xml? Hence,
the current unit of work is bound to the current Java thread that executes our application.
However, this is not the full picture, you also have to consider scope, when a unit of work
begins and when it ends.

A Session begins when it is first needed, when the first call to
getCurrentSession() is made. It is then bound by Hibernate to the current
thread. When the transaction ends, either through commit or rollback, Hibernate automatically
unbinds the Session from the thread and closes it for you. If you call
getCurrentSession() again, you get a new Session and can
start a new unit of work. This thread-bound programming model is the most
popular way of using Hibernate, as it allows flexible layering of your code (transaction
demarcation code can be separated from data access code, we'll do this later in this tutorial).

Related to the unit of work scope, should the Hibernate Session be used to
execute one or several database operations? The above example uses one Session
for one operation. This is pure coincidence, the example is just not complex enough to show any
other approach. The scope of a Hibernate Session is flexible but you should
never design your application to use a new Hibernate Session for
every database operation. So even if you see it a few more times in
the following (very trivial) examples, consider session-per-operation
an anti-pattern. A real (web) application is shown later in this tutorial.

Have a look at Chapter 11, Transactions And Concurrency for more information
about transaction handling and demarcation. We also skipped any error handling and
rollback in the previous example.

To run this first routine we have to add a callable target to the Ant build file:

<target name="run" depends="compile">
    <java fork="true" classname="events.EventManager" classpathref="libraries">
        <classpath path="${targetdir}"/>
        <arg value="${action}"/>
    </java>
</target>

The value of the action argument is set on the command line when
calling the target:

C:\hibernateTutorial\>ant run -Daction=store

You should see, after compilation, Hibernate starting up and, depending on your
configuration, lots of log output. At the end you will find the following line:

[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)

This is the INSERT executed by Hibernate, the question marks
represent JDBC bind parameters. To see the values bound as arguments, or to reduce
the verbosity of the log, check your log4j.properties.

Now we'd like to list stored events as well, so we add an option to the main method:

if (args[0].equals("store")) {
    mgr.createAndStoreEvent("My Event", new Date());
}
else if (args[0].equals("list")) {
    List events = mgr.listEvents();
    for (int i = 0; i < events.size(); i++) {
        Event theEvent = (Event) events.get(i);
        System.out.println("Event: " + theEvent.getTitle() +
                           " Time: " + theEvent.getDate());
    }
}

We also add a new listEvents() method:

private List listEvents() {

    Session session = HibernateUtil.getSessionFactory().getCurrentSession();

    session.beginTransaction();

    List result = session.createQuery("from Event").list();

    session.getTransaction().commit();

    return result;
}

What we do here is use an HQL (Hibernate Query Language) query to load all existing
Event objects from the database. Hibernate will generate the
appropriate SQL, send it to the database and populate Event objects
with the data. You can create more complex queries with HQL, of course.

Now, to execute and test all of this, follow these steps:

Run ant run -Daction=store to store something into the database
and, of course, to generate the database schema before through hbm2ddl.
Now disable hbm2ddl by commenting out the property in your hibernate.cfg.xml
file. Usually you only leave it turned on in continous unit testing, but another
run of hbm2ddl would drop everything you have stored - the
create configuration setting actually translates into "drop all
tables from the schema, then re-create all tables, when the SessionFactory is build".

If you now call Ant with -Daction=list, you should see the events
you have stored so far. You can of course also call the store action a few
times more.

Note: Most new Hibernate users fail at this point and we see questions about
Table not found error messages regularly. However, if you follow the
steps outlined above you will not have this problem, as hbm2ddl creates the database
schema on the first run, and subsequent application restarts will use this schema. If
you change the mapping and/or database schema, you have to re-enable hbm2ddl once again.

1.3. Part 2 - Mapping associations

We mapped a persistent entity class to a table. Let's build on this and add some class associations.
First we'll add people to our application, and store a list of events they participate in.

1.3.1. Mapping the Person class

The first cut of the Person class is simple:

package events;

public class Person {

    private Long id;
    private int age;
    private String firstname;
    private String lastname;

    public Person() {}

    // Accessor methods for all properties, private setter for 'id'

}

Create a new mapping file called Person.hbm.xml (don't forget the
DTD reference at the top):

<hibernate-mapping>

    <class name="events.Person" table="PERSON">
        <id name="id" column="PERSON_ID">
            <generator class="native"/>
        </id>
        <property name="age"/>
        <property name="firstname"/>
        <property name="lastname"/>
    </class>

</hibernate-mapping>

Finally, add the new mapping to Hibernate's configuration:

<mapping resource="events/Event.hbm.xml"/>
<mapping resource="events/Person.hbm.xml"/>

We'll now create an association between these two entities. Obviously, persons
can participate in events, and events have participants. The design questions
we have to deal with are: directionality, multiplicity, and collection
behavior.

1.3.2. A unidirectional Set-based association

We'll add a collection of events to the Person class. That way we can
easily navigate to the events for a particular person, without executing an explicit query -
by calling aPerson.getEvents(). We use a Java collection, a Set,
because the collection will not contain duplicate elements and the ordering is not relevant for us.

We need a unidirectional, many-valued associations, implemented with a Set.
Let's write the code for this in the Java classes and then map it:

public class Person {

    private Set events = new HashSet();

    public Set getEvents() {
        return events;
    }

    public void setEvents(Set events) {
        this.events = events;
    }
}

Before we map this association, think about the other side. Clearly, we could just keep this
unidirectional. Or, we could create another collection on the Event, if we
want to be able to navigate it bi-directional, i.e. anEvent.getParticipants().
This is not necessary, from a functional perspective. You could always execute an explicit query
to retrieve the participants for a particular event. This is a design choice left to you, but what
is clear from this discussion is the multiplicity of the association: "many" valued on both sides,
we call this a many-to-many association. Hence, we use Hibernate's
many-to-many mapping:

<class name="events.Person" table="PERSON">
    <id name="id" column="PERSON_ID">
        <generator class="native"/>
    </id>
    <property name="age"/>
    <property name="firstname"/>
    <property name="lastname"/>

    <set name="events" table="PERSON_EVENT">
        <key column="PERSON_ID"/>
        <many-to-many column="EVENT_ID" class="events.Event"/>
    </set>

</class>

Hibernate supports all kinds of collection mappings, a <set> being most
common. For a many-to-many association (or n:m entity relationship), an
association table is needed. Each row in this table represents a link between a person and an event.
The table name is configured with the table attribute of the set
element. The identifier column name in the association, for the person's side, is defined with the
<key> element, the column name for the event's side with the
column attribute of the <many-to-many>. You also
have to tell Hibernate the class of the objects in your collection (correct: the class on the
other side of the collection of references).

The database schema for this mapping is therefore:


    _____________        __________________
   |             |      |                  |       _____________
   |   EVENTS    |      |   PERSON_EVENT   |      |             |
   |_____________|      |__________________|      |    PERSON   |
   |             |      |                  |      |_____________|
   | *EVENT_ID   | <--> | *EVENT_ID        |      |             |
   |  EVENT_DATE |      | *PERSON_ID       | <--> | *PERSON_ID  |
   |  TITLE      |      |__________________|      |  AGE        |
   |_____________|                                |  FIRSTNAME  |
                                                  |  LASTNAME   |
                                                  |_____________|

1.3.3. Working the association

Let's bring some people and events together in a new method in EventManager:

private void addPersonToEvent(Long personId, Long eventId) {

    Session session = HibernateUtil.getSessionFactory().getCurrentSession();
    session.beginTransaction();

    Person aPerson = (Person) session.load(Person.class, personId);
    Event anEvent = (Event) session.load(Event.class, eventId);

    aPerson.getEvents().add(anEvent);

    session.getTransaction().commit();
}

After loading a Person and an Event, simply
modify the collection using the normal collection methods. As you can see, there is no explicit call
to update() or save(), Hibernate automatically
detects that the collection has been modified and needs to be updated. This is called automatic
dirty checking, and you can also try it by modifying the name or the date property of
any of your objects. As long as they are in persistent state, that is, bound
to a particular Hibernate Session (i.e. they have been just loaded or saved in
a unit of work), Hibernate monitors any changes and executes SQL in a write-behind fashion. The
process of synchronizing the memory state with the database, usually only at the end of a unit of
work, is called flushing. In our code, the unit of work ends with a commit
(or rollback) of the database transaction - as defined by the thread configuration
option for the CurrentSessionContext class.

You might of course load person and event in different units of work. Or you modify an object
outside of a Session, when it is not in persistent state (if it was persistent
before, we call this state detached). You can even modify a collection when
it is detached:

private void addPersonToEvent(Long personId, Long eventId) {

    Session session = HibernateUtil.getSessionFactory().getCurrentSession();
    session.beginTransaction();

    Person aPerson = (Person) session
            .createQuery("select p from Person p left join fetch p.events where p.id = :pid")
            .setParameter("pid", personId)
            .uniqueResult(); // Eager fetch the collection so we can use it detached

    Event anEvent = (Event) session.load(Event.class, eventId);

    session.getTransaction().commit();

    // End of first unit of work

    aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached

    // Begin second unit of work

    Session session2 = HibernateUtil.getSessionFactory().getCurrentSession();
    session2.beginTransaction();

    session2.update(aPerson); // Reattachment of aPerson

    session2.getTransaction().commit();
}

The call to update makes a detached object persistent again, you could
say it binds it to a new unit of work, so any modifications you made to it while detached
can be saved to the database. This includes any modifications (additions/deletions) you
made to a collection of that entity object.

Well, this is not much use in our current situation, but it's an important concept you can
design into your own application. For now, complete this exercise by adding a new action
to the EventManager's main method and call it from the command line. If
you need the identifiers of a person and an event - the save() method
returns it (you might have to modify some of the previous methods to return that identifier):

else if (args[0].equals("addpersontoevent")) {
    Long eventId = mgr.createAndStoreEvent("My Event", new Date());
    Long personId = mgr.createAndStorePerson("Foo", "Bar");
    mgr.addPersonToEvent(personId, eventId);
    System.out.println("Added person " + personId + " to event " + eventId);

This was an example of an association between two equally important classes, two entities.
As mentioned earlier, there are other classes and types in a typical model, usually "less
important". Some you have already seen, like an int or a String.
We call these classes value types, and their instances depend
on a particular entity. Instances of these types don't have their own identity, nor are they
shared between entities (two persons don't reference the same firstname
object, even if they have the same first name). Of course, value types can not only be found in
the JDK (in fact, in a Hibernate application all JDK classes are considered value types), but
you can also write dependent classes yourself, Address or MonetaryAmount,
for example.

You can also design a collection of value types. This is conceptually very different from a
collection of references to other entities, but looks almost the same in Java.

1.3.4. Collection of values

We add a collection of value typed objects to the Person entity. We want to
store email addresses, so the type we use is String, and the collection is
again a Set:

private Set emailAddresses = new HashSet();

public Set getEmailAddresses() {
    return emailAddresses;
}

public void setEmailAddresses(Set emailAddresses) {
    this.emailAddresses = emailAddresses;
}

The mapping of this Set:

<set name="emailAddresses" table="PERSON_EMAIL_ADDR">
    <key column="PERSON_ID"/>
    <element type="string" column="EMAIL_ADDR"/>
</set>

The difference compared with the earlier mapping is the element part, which tells Hibernate that the collection
does not contain references to another entity, but a collection of elements of type
String (the lowercase name tells you it's a Hibernate mapping type/converter).
Once again, the table attribute of the set element determines
the table name for the collection. The key element defines the foreign-key column
name in the collection table. The column attribute in the element
element defines the column name where the String values will actually be stored.

Have a look at the updated schema:


  _____________        __________________
 |             |      |                  |       _____________
 |   EVENTS    |      |   PERSON_EVENT   |      |             |       ___________________
 |_____________|      |__________________|      |    PERSON   |      |                   |
 |             |      |                  |      |_____________|      | PERSON_EMAIL_ADDR |
 | *EVENT_ID   | <--> | *EVENT_ID        |      |             |      |___________________|
 |  EVENT_DATE |      | *PERSON_ID       | <--> | *PERSON_ID  | <--> |  *PERSON_ID       |
 |  TITLE      |      |__________________|      |  AGE        |      |  *EMAIL_ADDR      |
 |_____________|                                |  FIRSTNAME  |      |___________________|
                                                |  LASTNAME   |
                                                |_____________|

You can see that the primary key of the collection table is in fact a composite key,
using both columns. This also implies that there can't be duplicate email addresses
per person, which is exactly the semantics we need for a set in Java.

You can now try and add elements to this collection, just like we did before by
linking persons and events. It's the same code in Java:

private void addEmailToPerson(Long personId, String emailAddress) {

    Session session = HibernateUtil.getSessionFactory().getCurrentSession();
    session.beginTransaction();

    Person aPerson = (Person) session.load(Person.class, personId);

    // The getEmailAddresses() might trigger a lazy load of the collection
    aPerson.getEmailAddresses().add(emailAddress);

    session.getTransaction().commit();
}

This time we didnt' use a fetch query to initialize the collection.
Hence, the call to its getter method will trigger an additional select to initialize
it, so we can add an element to it. Monitor the SQL log and try to optimize this with
an eager fetch.

1.3.5. Bi-directional associations

Next we are going to map a bi-directional association - making the association between
person and event work from both sides in Java. Of course, the database schema doesn't
change, we still have many-to-many multiplicity. A relational database is more flexible
than a network programming language, so it doesn't need anything like a navigation
direction - data can be viewed and retrieved in any possible way.

First, add a collection of participants to the Event Event class:

private Set participants = new HashSet();

public Set getParticipants() {
    return participants;
}

public void setParticipants(Set participants) {
    this.participants = participants;
}

Now map this side of the association too, in Event.hbm.xml.

<set name="participants" table="PERSON_EVENT" inverse="true">
    <key column="EVENT_ID"/>
    <many-to-many column="PERSON_ID" class="events.Person"/>
</set>

As you see, these are normal set mappings in both mapping documents.
Notice that the column names in key and many-to-many are
swapped in both mapping documents. The most important addition here is the
inverse="true" attribute in the set element of the
Event's collection mapping.

What this means is that Hibernate should take the other side - the Person class -
when it needs to find out information about the link between the two. This will be a lot easier to
understand once you see how the bi-directional link between our two entities is created .

1.3.6. Working bi-directional links

First, keep in mind that Hibernate does not affect normal Java semantics. How did we create a
link between a Person and an Event in the unidirectional
example? We added an instance of Event to the collection of event references,
of an instance of Person. So, obviously, if we want to make this link working
bi-directional, we have to do the same on the other side - adding a Person
reference to the collection in an Event. This "setting the link on both sides"
is absolutely necessary and you should never forget doing it.

Many developers program defensive and create a link management methods to
correctly set both sides, e.g. in Person:

protected Set getEvents() {
    return events;
}

protected void setEvents(Set events) {
    this.events = events;
}

public void addToEvent(Event event) {
    this.getEvents().add(event);
    event.getParticipants().add(this);
}

public void removeFromEvent(Event event) {
    this.getEvents().remove(event);
    event.getParticipants().remove(this);
}

Notice that the get and set methods for the collection are now protected - this allows classes in the
same package and subclasses to still access the methods, but prevents everybody else from messing
with the collections directly (well, almost). You should probably do the same with the collection
on the other side.

What about the inverse mapping attribute? For you, and for Java, a bi-directional
link is simply a matter of setting the references on both sides correctly. Hibernate however doesn't
have enough information to correctly arrange SQL INSERT and UPDATE
statements (to avoid constraint violations), and needs some help to handle bi-directional associations
properly. Making one side of the association inverse tells Hibernate to basically
ignore it, to consider it a mirror of the other side. That's all that is necessary
for Hibernate to work out all of the issues when transformation a directional navigation model to
a SQL database schema. The rules you have to remember are straightforward: All bi-directional associations
need one side as inverse. In a one-to-many association it has to be the many-side,
in many-to-many association you can pick either side, there is no difference.

Let's turn this into a small web application.

1.4. Part 3 - The EventManager web application

A Hibernate web application uses Session and Transaction
almost like a standalone application. However, some common patterns are useful. We now write
an EventManagerServlet. This servlet can list all events stored in the
database, and it provides an HTML form to enter new events.

1.4.1. Writing the basic servlet

Create a new class in your source directory, in the events
package:

package events;

// Imports

public class EventManagerServlet extends HttpServlet {

    // Servlet code
}

The servlet handles HTTP GET requests only, hence, the method
we implement is doGet():

protected void doGet(HttpServletRequest request,
                     HttpServletResponse response)
        throws ServletException, IOException {

    SimpleDateFormat dateFormatter = new SimpleDateFormat("dd.MM.yyyy");

    try {
        // Begin unit of work
        HibernateUtil.getSessionFactory()
                .getCurrentSession().beginTransaction();

        // Process request and render page...

        // End unit of work
        HibernateUtil.getSessionFactory()
                .getCurrentSession().getTransaction().commit();

    } catch (Exception ex) {
        HibernateUtil.getSessionFactory()
                .getCurrentSession().getTransaction().rollback();
        throw new ServletException(ex);
    }

}

The pattern we are applying here is called session-per-request.
When a request hits the servlet, a new Hibernate Session is
opened through the first call to getCurrentSession() on the
SessionFactory. Then a database transaction is started—all
data access as to occur inside a transaction, no matter if data is read or written
(we don't use the auto-commit mode in applications).

Do not use a new Hibernate Session for
every database operation. Use one Hibernate Session that is
scoped to the whole request. Use getCurrentSession(), so that
it is automatically bound to the current Java thread.

Next, the possible actions of the request are processed and the response HTML
is rendered. We'll get to that part soon.

Finally, the unit of work ends when processing and rendering is complete. If any
problem occured during processing or rendering, an exception will be thrown
and the database transaction rolled back. This completes the
session-per-request pattern. Instead of the transaction
demarcation code in every servlet you could also write a servlet filter.
See the Hibernate website and Wiki for more information about this pattern,
called Open Session in View—you'll need it as soon
as you consider rendering your view in JSP, not in a servlet.

1.4.2. Processing and rendering

Let's implement the processing of the request and rendering of the page.

// Write HTML header
PrintWriter out = response.getWriter();
out.println("<html><head><title>Event Manager</title></head><body>");

// Handle actions
if ( "store".equals(request.getParameter("action")) ) {

    String eventTitle = request.getParameter("eventTitle");
    String eventDate = request.getParameter("eventDate");

    if ( "".equals(eventTitle) || "".equals(eventDate) ) {
        out.println("<b><i>Please enter event title and date.</i></b>");
    } else {
        createAndStoreEvent(eventTitle, dateFormatter.parse(eventDate));
        out.println("<b><i>Added event.</i></b>");
    }
}

// Print page
printEventForm(out);
listEvents(out, dateFormatter);

// Write HTML footer
out.println("</body></html>");
out.flush();
out.close();

Granted, this coding style with a mix of Java and HTML would not scale
in a more complex application—keep in mind that we are only illustrating
basic Hibernate concepts in this tutorial. The code prints an HTML
header and a footer. Inside this page, an HTML form for event entry and
a list of all events in the database are printed. The first method is
trivial and only outputs HTML:

private void printEventForm(PrintWriter out) {
    out.println("<h2>Add new event:</h2>");
    out.println("<form>");
    out.println("Title: <input name='eventTitle' length='50'/><br/>");
    out.println("Date (e.g. 24.12.2009): <input name='eventDate' length='10'/><br/>");
    out.println("<input type='submit' name='action' value='store'/>");
    out.println("</form>");
}

The listEvents() method uses the Hibernate
Session bound to the current thread to execute
a query:

private void listEvents(PrintWriter out, SimpleDateFormat dateFormatter) {

    List result = HibernateUtil.getSessionFactory()
                    .getCurrentSession().createCriteria(Event.class).list();
    if (result.size() > 0) {
        out.println("<h2>Events in database:</h2>");
        out.println("<table border='1'>");
        out.println("<tr>");
        out.println("<th>Event title</th>");
        out.println("<th>Event date</th>");
        out.println("</tr>");
        for (Iterator it = result.iterator(); it.hasNext();) {
            Event event = (Event) it.next();
            out.println("<tr>");
            out.println("<td>" + event.getTitle() + "</td>");
            out.println("<td>" + dateFormatter.format(event.getDate()) + "</td>");
            out.println("</tr>");
        }
        out.println("</table>");
    }
}

Finally, the store action is dispatched to the
createAndStoreEvent() method, which also uses
the Session of the current thread:

protected void createAndStoreEvent(String title, Date theDate) {
    Event theEvent = new Event();
    theEvent.setTitle(title);
    theEvent.setDate(theDate);

    HibernateUtil.getSessionFactory()
                    .getCurrentSession().save(theEvent);
}

That's it, the servlet is complete. A request to the servlet will be processed
in a single Session and Transaction. As
earlier in the standalone application, Hibernate can automatically bind these
ojects to the current thread of execution. This gives you the freedom to layer
your code and access the SessionFactory in any way you like.
Usually you'd use a more sophisticated design and move the data access code
into data access objects (the DAO pattern). See the Hibernate Wiki for more
examples.

1.4.3. Deploying and testing

To deploy this application you have to create a web archive, a WAR. Add the
following Ant target to your build.xml:

<target name="war" depends="compile">
    <war destfile="hibernate-tutorial.war" webxml="web.xml">
        <lib dir="${librarydir}">
          <exclude name="jsdk*.jar"/>
        </lib>

        <classes dir="${targetdir}"/>
    </war>
</target>

This target creates a file called hibernate-tutorial.war
in your project directory. It packages all libraries and the web.xml
descriptor, which is expected in the base directory of your project:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
    xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

    <servlet>
        <servlet-name>Event Manager</servlet-name>
        <servlet-class>events.EventManagerServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>Event Manager</servlet-name>
        <url-pattern>/eventmanager</url-pattern>
    </servlet-mapping>
</web-app>

Before you compile and deploy the web application, note that an additional library
is required: jsdk.jar. This is the Java servlet development kit,
if you don't have this library already, get it from the Sun website and copy it to
your library directory. However, it will be only used for compliation and excluded
from the WAR package.

To build and deploy call ant war in your project directory
and copy the hibernate-tutorial.war file into your Tomcat
webapp directory. If you don't have Tomcat installed, download
it and follow the installation instructions. You don't have to change any Tomcat
configuration to deploy this application though.

Once deployed and Tomcat is running, access the application at
http://localhost:8080/hibernate-tutorial/eventmanager. Make
sure you watch the Tomcat log to see Hibernate initialize when the first
request hits your servlet (the static initializer in HibernateUtil
is called) and to get the detailed output if any exceptions occurs.

1.5. Summary

This tutorial covered the basics of writing a simple standalone Hibernate application
and a small web application.

If you already feel confident with Hibernate, continue browsing through the reference
documentation table of contents for topics you find interesting - most asked are
transactional processing (Chapter 11, Transactions And Concurrency), fetch
performance (Chapter 19, Improving performance), or the usage of the API (Chapter 10, Working with objects)
and the query features (Section 10.4, “Querying”).

Don't forget to check the Hibernate website for more (specialized) tutorials.

Useful URLsfor Freshers

2007-07-24T07:03:00.000-07:00

www.naukri.com
www.jobsassist.com
www.jobstreet.com
www.monster.com
www.jobsahead.com

www.sansite.com
www.efreshers.com
www.todaysfresher.com
www.careermirchi.com
www.chetanafresherjobs.com

www.fresherstreet. com
www.freshersworld.com
www.haikeralam.com
www.yuvajobs.com
www.mindjobs.com
www.chetanaS.com
www.careerenclave.com

2007-07-21T21:38:00.000-07:00

Starting point for Sun's Java technology certification.

JCertify - http://www.enterprisedeveloper.com/jcertify/ Java Certification exam simulator with tutorials and integrated training content. [Commercial]

Whizlabs - http://www.whizlabs.com/jwhiz.html Provides exam simulators and online training for Sun Java Certification exams: SCJP, SCWCD, SCBCD and SCEA [Commercial].

Levteck.com - http://www.levteck.com/ Includes list of certification books, study aides, links for mock exams and salary surveys.

Java certification success, Part 1: SCJP - http://www-106.ibm.com/developerworks/edu/j-dw-java-scjp-i.html A tutorial designed to prepare programmers for SCJP 1.4 exam, providing a detailed overview of the exam's main objectives.

Marcus Green's Java Certification - http://www.jchq.net/ SCJP exam resource with tutorials, mock exam and community features.

Wah! Java - http://www.geocities.com/wahjava/ Contains topic-wise mock tests, tips from those who passed, recommended books and links to other testing/java resources.

JavaPrepare - http://www.javaprepare.com/ Tutorials, mock exams and other preparation material for SCJP and SCWCD.

Java Certification Study Group - http://groups.yahoo.com/group/javacertstudy/ Study community with forums, chat and resources.

SCWCD Certification Resources - http://resources.corejsp.com/scwcd.html Contains links to study guides, exam simulators and other resources for SCWCD examination.

SCWCD Exam Review - http://courses.coreservlets.com/Course-Materials/pdf/msajsp/15-Web-Component-Certification.pdf Review notes for the Sun Certified Web Component Developer exam.

Certified Java Programmer Mock Exam (310-025, 310-035) - http://www.danchisholm.net/ Contains mock exams and tutorials for SCJP exam.

Absolute Java - http://www.absolutejava.com/ Collection of tidbits to prepare for SCJP exam.

Jiris - http://www.jiris.com/ Contains mock exams, links, forum, code examples and other SCJP/SCWCD resources.

JavaCertificate - http://www.javacertificate.com/ A free online training centre that will help prepare for the Sun Certified Programmer for Java(tm) 2 Platform exam (SCJP 1.4).

Anilbachi Java Certification Resources - http://www.anilbachi.8m.com/ SCJP tutorial, mock exams, objectives, mock exam links and discussion forum.

Java certification success, Part 1: SCJP - http://www.whizlabs.com/tutorial/scjp/index.html A SCJP Tutorial to test the knowledge of Java fundamentals and requires in-depth knowledge of the syntax and semantics.

Certification: The Java Mock Test - http://www.aniyog.com/java/certification.htm Offers free applet based mock exam for SCJP2.

Java Certification (SCJP) - http://www.akgupta.com/Java/certification.htm Contains SCJP mock exam, tidbits, exam notes and links to other resources.

Java Certification Study Notes - http://www.geocities.com/velmurugan_p/ SCJP & SCWCD study notes, resources and tips.

Java Guru: Java Certification Forum Home Page - http://www.jguru.com/forums/JavaCertification Forum to pose and view the who, what, where, why and how questions on Java certification.

Sun Java 4 U - http://www.geocities.com/sunjava4u/ Links and resources useful for SCJP aspirants includes exam simulators, mock exams, study guides.

Java.CertifiedProgrammer.com - http://java.certifiedprogrammer.com/ Contains study aides, news and mock exams.

The Java Skinny - http://www.acmerocket.com/skinny/ Contains sample questions, SCJP exam objectives with code examples and other resources.

Sun Certified Java Programmer sample test paper! - http://www.geocities.com/skmajji/Main.html A practice test for SCJP comprising of 30 questions with answers.

Enthuware - http://www.enthuware.com/ Test simulators for Sun certification exams. [Commercial]

Java Quick Reference - http://www.janeg.ca/index.html Comprises of concise study notes for SCJP exam and other links.

JavaBeat - http://www.javabeat.net/ Java certification resources.

About.com - Java Certifications - http://certification.about.com/cs/freequestions/index.htm Explore information and links for Java and Sun certifications. Includes articles, practice tests, software reviews, book reviews, and forums.

CertGear Systems - Java - http://www.certgear.com/products/vendor/java.htm Java certification resources, including practice tests (SCJP SCWCD SCBCD ), free quizzes, and study aids.

Exams guide - http://www.examsguide.com Java certification resources.

SCJP Tiger Study Guide - http://java.boot.by/scjp-tiger/ Study Guide for exam CX-310-055 (Sun Certified Programmer for the Java 2 Platform, Standard Edition 5.0).

VoodooExam - http://www.geocities.com/gnashes30/java/mock.htm SCJP mock exam engine with facility to add new question/answers. Needs jdk1.2.1 or higher [download].

Inesystem's Java Certification - http://www.inesystems.com Provides exam simulators and online training for Sun Java Certification exams.

Prasks Resources - http://prasks.webahn.com/architect/scja.html Sun Certified Java Architect resources and experiences.

Java Certification Resources - http://www.javadeveloper.co.in Includes tutorials, mock exams, study notes and exam simulators for SCJP and SCWCD exams.

Tipsmart.com - http://www.tipsmart.com/ Contains interactive quizzes, pitfalls, FAQs by programmers, list of integrated development tools.

Mock Exam - http://www.valoxo.ch/jr/mocks/mock01a.html Javascript based SCJP Mock Exam.

Java Certification Exam Questions - http://home-1.tiscali.nl/~bmc88/java/javacert/ SCJP mock tests, exam notes and other resources.

SCJP2 MockExam - http://www.geocities.com/rraje_2000/MockExam.html 60 questions mock test [Download].

Radhika Palwai's Web Development Resources - http://www.geocities.com/r_palwai/scjp.htm Contains links to SCJP resources.

Free Java Certification Training - http://www.michael-thomas.com/ Contains mock tests, source code, resources for Sun Certifications, resources on Web-development and UML.

Everything you want to know about SCJP - http://dreamjava.blogspot.com A Blog to help SCJP aspirants with links and daily question.

Learn + play Java - http://www.jai.ch/ Interactive, downloadable course for SCJP with built-in Java source interpreter. Work and experiment with class libraries using the tests and JLS Summary.

Sun Java Certification Resource Center - http://www.certlobby.com/sun-java-certification.html Contains concise details on various Sun certification exams and links to resources.

Dallas SCJD Study Group - http://www.geocities.com/developergrp/ Developer exam resources including FAQs, guidelines, presentations, free books and discussion forum.

Sun Java Certification SCJP, Java Tutorials and ebooks - http://www.javaprogrammingworld.com The contents of this page are intended for SCJP 1.2 exam (310-025) and resources specific to SCJP 1.4 exam (310-035).

Java Mock Exams, Practice Questions, Tutorails, Articles - http://www.javacertificate.net Contains practice questions and mock exams for various Sun and IBM certifications.

JavaQuestion Bank - http://javaquestion.tripod.com/ Includes general and certification questions and other java resources.

SUN Certification Study Materials - http://www.xyzws.com Provides study guides & mock exams (needs registration) for SCJP 5.0 (CX-310-055) and SCDJWS (CX-311-220) tests.

JavaQueries - http://www.javaqueries.com/ SCEA Mock Exam, Solutions for JavaQueries.

SoftLearn Systems - http://www.softlearn-systems.com/ Provides simulators for SCBCD and SCJD exams. [Commercial]

Universal teacher - http://www.geocities.com/rameshchhabra2002/Java/certification.htm SCJP exam simulator containing 600 questions [Download].

SCJP Simulator - http://www.examsguide.com/scjp/freesimulator.html Offers an exam simulator with provision to add more questions.

Quick Java - http://home.worldonline.dk/qjava/ Contains a Java lookup reference and test-simulator based on a book.

Java Certification Guide - http://rohitgeorge.netfirms.com/scjp.html Contains tutorial on SCJP. Also contains a downloadable PDF version.

SCJP 1.4 certification primer - http://www-106.ibm.com/developerworks/java/library/j-scjp/ Outlines the new programmer certification exam with suggestions for preparation, sample questions and links to resources.

Abhilash's java quiz site - http://www.angelfire.com/or/abhilash/ Comprises of set of nine practice quizzes for SCJP exam with answers.

Oracle Certified Java Developer - http://otn.oracle.com/training/certification/jdeveloper_ocpds.html Starting point for Oracle Certified Java Developer OCP program.

Home Page of Koray Guclu - http://www.korayguclu.de/ Contains excerpts from an ongoing SCJP book, exam information, notes and links to Mock exams/resources. Also publications, resume, photography, banner art.

go4java- Java Certification Site - http://www.mycgiserver.com/~go4java/ Includes SCJP experiences, FAQs, mock exams, tutorials and links to other resources.

Java Programmer Certification - http://www.geocities.com/technofundo/tech/scjp/scjp.html SCJP Revision notes, links and other resources.

Java Certification Webring - http://www.webring.com/hub?ring=javacert Web-ring of sites involved with certification.

Sun Certified Programmer Examination Revision Book - http://home.worldonline.nl/~bmc88/java/javacert/revision.html SCJP Tutorial based on Sun's Objectives.

j-think
Contains SCJP notes.

Concentrated Guide to SCJP2 - A zip archive consisting of SCJP Notes (PDF) and Questions and Answers (Word document) compiled by Ashraf Fouad Ayoub and Ashraf Samir Helmy.

Passing the Java Programmer Certification Exam - Article discusses how to prepare for the Java Programmer certification. Includes suggestions on how to study for the exam.

Java certification forum - A discussion forum dedicated to Java certification exams.