Building Java Servlets with JBuilder

import java.io.*; import javax.servlet.*; public class SimpleServlet extends GenericServlet { public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { ServletOutputStream out = res.getOutputStream(); out.println("<HEAD><TITLE> SimpleServlet Output "); out.println("</TITLE></HEAD><BODY>"); out.println("<h1> SimpleServlet Output </h1>"); out.println("</BODY>"); } }

package JBExamples.database.servlets.simple; import javax.servlet.*; import javax.servlet.http.*; import java.io.*; import java.util.*; public class SimpleServlet extends HttpServlet { //Initialize global variables public void init(ServletConfig config) throws ServletException { super.init(config); } //Service the request public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String dbQuery = ""; try { dbQuery = request.getParameter("dbQuery"); } catch (Exception e) { e.printStackTrace(); } } //Get Servlet information public String getServletInfo() { return "JBExamples.database.servlets.simple.SimpleServlet Information"; } }


package JBExamples.database.servlets.simple;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import borland.sql.dataset.*;

public class SimpleServlet extends HttpServlet 
{
   Database database1 = new Database();
   QueryDataSet queryDataSet1 = new QueryDataSet();

   //Initialize global variables
   public void init(ServletConfig config) throws ServletException
   {
      super.init(config);
   }

   //Service the request
   public void service(HttpServletRequest request, HttpServletResponse 
      response) throws ServletException, IOException
   {
      //A database query
      String dbQuery = "";
      
      try  { 
         dbQuery = request.getParameter("dbQuery"); 
      } 
      catch (Exception e)  { 
         e.printStackTrace(); 
      }
  }

  //Get Servlet information
  public String getServletInfo() 
  {
     return "JBExamples.database.servlets.simple.SimpleServlet Information";
  }

  public SimpleServlet() 
  {
     try {
      jbInit();
     }
     catch (Exception e) {
        e.printStackTrace();
     }
  }

  private void jbInit() throws Exception
  {
     database1.setConnection(new borland.sql.dataset.ConnectionDescriptor(  
     "jdbc:odbc:DemoDatabase",  "",  "",  false,   "sun.jdbc.odbc.JdbcOdbcDriver"));

     queryDataSet1.setQuery(new borland.sql.dataset.QueryDescriptor(database1,  "", 
     null,  true, Load.ALL));
  }

}

Preparing SimpleServlet for multi-threaded situations
LetÆs examine our new SimpleServlet. Basically a constructor with no arguments has been created along with a method called jbInit(). If you are familiar with servlets, you may question the call to jbInit() in the empty constructor. By convention, servlet developers should implement their initialization of data in the servletÆs init method. The init method is called once by the servlet runner when the servlet is loaded to run. On the other hand, the release of resources should be implemented in the servletÆs destroy method. The destroy method is called by the servlet runner when the web server is stopped, or before the servlet is to be reloaded. Because we are dealing with a class of whoÆs entire existence will be within a multi-threaded environment, a few adjustments must also be made for SimpleServlet to handle concurrent database queries correctly. The following code shows the completed SimpleServlet adjusted to handle itÆs database connection correctly.

Example 1-3: SimpleServlet.java
Completed SimpleServlet


package JBExamples.database.servlets.simple;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import borland.sql.dataset.*;

import borland.jbcl.dataset.DataSetException;

public class SimpleServlet extends HttpServlet {
  Database database1 = new Database();

  //Initialize global variables
  public void init(ServletConfig config) throws ServletException{
    super.init(config);

    try {
      jbInit();
    }
    catch(Exception e) {
      e.printStackTrace();
    }
  }

  //Close the database connection
  public void destroy() {
   try {
      System.out.println("SimpleServlet closing database connection.");
      database1.closeConnection();
    }
    catch(DataSetException e) {
      System.out.println("Error in closing the database connection");
    }
  }

  /**
   * Returns a data table containing the results of
   */
  public IDataTable getResultTable(String dbQuery) {
    IDataTable dataTable = null;
    try {
      QueryDataSet queryDataSet = new QueryDataSet();
      queryDataSet.setQuery(new borland.sql.dataset.QueryDescriptor(database1,
      dbQuery, null, true, Load.ALL));

      
      //Query will be executed when QueryDataSet is open
      queryDataSet.open();
      dataTable = new DataTableImpl(queryDataSet);
      queryDataSet.close();
    }
    catch(Exception e) {
      e.printStackTrace();
    }
    return dataTable;
  }

  //Service the request
  public void service(HttpServletRequest request, HttpServletResponse
 response) throws ServletException, IOException {
    //Set content type
    response.setContentType("text/html");

    //A database query
    String dbQuery = "";
    try { dbQuery = request.getParameter("dbQuery"); } catch (Exception e) { e.printStackTrace(); }

    //Get a result table from the dbQuery
    IDataTable dataTable = getResultTable(dbQuery);

    //Get a print stream to the client
    PrintWriter out = response.getWriter();

    //Print out results in html format to the client
    out.println("<CENTER>");

    out.println("<TABLE width=\"80%\" cellpadding=\"0\" border=\"2\"
 cellspacing=\"0\">");
    out.println("<TR bgcolor=\"#000000\">");    out.println("<TD align=\"center\">");
    out.println("<FONT color=\"ffffff\"
 face=\"Arial\" size=\"3\"><B>Database Results</B></FONT>");
    out.println("</TD>");    out.println("</TR>");    out.println("<TR bgcolor=\"#ffffff\">");
    out.println("<TD align=\"center\">");
    //Fetch the data in HTML format
    out.println( dataTable.toHTMLString() );

    //Close tags
    out.println("</TABLE>");
    out.println("</TD>");    out.println("</TR>");
    out.println("</TABLE>");    out.println("</CENTER>");  }

  //Get Servlet information
  public String getServletInfo() {
    return "JBExamples.database.servlets.simple.SimpleServlet Information";
  }

  /*
  public SimpleServlet() {
    try {
      jbInit();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }
  */

  //Set the database connection
  private void jbInit() throws Exception{
    database1.setConnection(new
 borland.sql.dataset.ConnectionDescriptor("jdbc:odbc:DemoDatabase", "",
 "", false, "sun.jdbc.odbc.JdbcOdbcDriver"));
  }
}

The Changes to SimpleServlet
The modified, and final SimpleServlet should be all ready to go. Lets compare the differences between the new SimpleServlet with the old one. By making the above changes, SimpleServlet now allows its concurrent threads to use the same database connection, although tying each query to its particular request. If you take a look at SimpleServletÆs empty constructor, it has been commented out. The call to the database initialization jbinit is now called from within the init method. Notice that the class DataQuerySet is no longer an instance variable, and itÆs instantiation has been moved to within the getResultTable method. The setting of DataQuerySetÆs query poperty was cut out of the jbinit method, and placed within the getResultTable method as well. Moving the instance of DataQuerySet confines it to the scope of the getResultTable method. This is to ensure that every concurrent request will be using a unique instance of QueryDataSet, eventually keeping the requests thread safe.

The getResultTable method executes the given query string by simply calling the open method of the QueryDataSet instance. Once opened, the QueryDataSet instance is passed to a constructor of a convenience class DataTableImpl. DataTableImpl is responsible for formatting the query results into an HTML formatted table, or, a tab/newline delimited string.

An implementation of the destroy method has also been added. The destroy method is used to close the database connection.

The service method now has the code to get the results of the database query back to the client. The method call req.setContentType("text/html") tells the client browser to expect html text. This gives the client browser a chance to interpret the data as specified. A stream to the client is obtained by a call to out.getWriter(). A PrintWriter object is returned and eventually used to write the results of the query in an HTML formatted table which is obtained through the method call dataTable.toHTMLString().

The code for DataTableImpl and its interface IDataTable is shown below.

Example 1-4a: DataTableImpl..java


package JBExamples.database.servlets.simple;

import borland.sql.dataset.QueryDataSet;
import borland.jbcl.dataset.DataRow;
import borland.jbcl.dataset.DataSetException;
import java.util.Vector;

public class DataTableImpl implements IDataTable {
/*
 *  A convenience class that copies the data from QueryDataSet
 *  into a table of Strings.
 */
  private String[] columnNames;
  private Vector tableData;
  private int columnCount;
  private int rowCount;

  public DataTableImpl() {
    super();
  }

  public DataTableImpl(QueryDataSet queryDataSet) throws DataSetException
  {
      DataRow dataRow   = new DataRow(queryDataSet);
      this.columnCount  = dataRow.getColumnCount();
      this.rowCount     = queryDataSet.getRowCount();
      this.columnNames  = dataRow.getColumnNames( columnCount );
      copyQueryData(queryDataSet, dataRow);
  }

  private void copyQueryData(QueryDataSet queryDataSet, DataRow dataRow)
    throws DataSetException
  {
    tableData = new Vector();

    for(int i=0; i<rowCount; i++) {
      String[] data = new String[columnCount];
      queryDataSet.getDataRow(i, dataRow);
      for(int j=0; j<columnCount; j++) {
        data[j] = dataRow.format(j);
      }
      tableData.addElement(data);
    }
  }

  public String[] getColumnNames() {
    return this.columnNames;
  }

  public int getRowCount() {
    return this.rowCount;
  }

  public int getColumnCount() {
    return this.columnCount;
  }

  public String getDataAt(int row, int column) {
    return ((String[])tableData.elementAt(row))[column];
  }

  //Return a tab/newline delimited String
  public String toTableString()
  {
    return toTableString("","\n","","\n","","\t");
  }

  //Return an HTML String representation of this object
  public String toHTMLString()
  {
    return toTableString(
       "<table width=\"80%\" height=\"80%\"border=\"1\">",
       "</table>\n","<tr align=center>","</tr>\n","<td>","</td>");
  }

  // Convert the table data of this object to a String using the given table
  // delimiters.
  private String toTableString(String tblStart, String tblEnd, 
    String rowStart, String rowEnd, String dataStart, String dataEnd )
  {
    StringBuffer results = new StringBuffer();

    try {
    results.append(tblStart);
    //Column names
    results.append(rowStart);
    for(int i=0; i"+e.toString();  }

    return results.toString();
  }
}

Example 1-4b: IDataTable.java


package JBExamples.database.servlets.simple;

  public interface IDataTable {
  public String[] getColumnNames();
  public int getRowCount();
  public int getColumnCount();
  public String getDataAt(int row, int column);
  public String toHTMLString();
  public String toTableString();
}

In DataTableImpl, an instance of DataRow is used to get the column names, and the column count of the QueryDataSet object. The row count is obtained from the QueryDataSet object. The method copyQueryData, does just that. It traverses through the QueryDataSet and copies them into a Vector. Each element of the Vector will consist of a String[] containing the data of one row. The row data is obtained from the method call queryDataSet.getDataRow(i, dataRow). This populates dataRow with the data at the specified row i, in queryDataSet. The method call dataRow.format(j) returns the data at the specified column j as a String type.

Right about now you are probably wondering, why we need an interface for DataTableImpl. The reason for this will become clear in the next section when we expand SimpleServlet to be an RMI server.

Invoking SimpleServlet
To invoke SimpleServlet you must first have a servlet capable web server. If your web-server does not support servlets. You can obtain a third party servlet runner plugin for your web server. A product such as Live SoftwareÆs JRun can be obtained at http://www.livesoftware.com/. Once youÆve obtained a servlet runner and installed it, you will have to copy SimpleServletÆs class files into the <servlet_runner_home>/servlets directory.

Note: If youÆve created SimpleServlet within a package, you will have to create your directory structure that maps to the package name under the servlets directory. So if SimpleServlet belonged to a package foo.bar. You will have to create the directory structure foo/bar under the servlets directory, and copy your SimpleServlet class files into the bar directory. In short:


	Class name: foo.bar.SimpleServlet
	Location:     /servlets/foo/bar/SimpleServlet.java

Setting the servlet runnerÆs user classpath
Before the servlet is to be envoked, the servlet runner has to know the location of Borland specific classes. This is done by setting the user classpath in the servlet runnerÆs admin. The Borland specifi class files used in SimpleServlet are in the jar file called jbcl2.0.jar under the <jbuilder_root>/lib directory. The following screen shot illustrates where the path to the jar file should be set in JRunÆs Admin. The field, User Classpath:

In order for this change to take affect, you will have to stop and restart your web server. If this classpath was already specified, there is no need to stop and restart your web server.

Once youÆve done this, the next step is to call the SimpleServlet. Since SimpleServlet handles requests through its service method, you can call SimpleServlet in four popular ways.

through the <servlet> tag
through post
through get
from a java applet

Calling SimpleServlet through the <servlet> tag

Follow the steps to call a servlet with the servlet tag.

Create a new file and name it SimpleServlet.shtml
Type the following inside the file:

<HTML>

<BODY>

</servlet>

</BODY>

</HTML>

Save the SimpleServlet.shtml into your <web_server_root> directory.
Start your web server.
Open a browser, and request the SimpleServlet.shtml file.

http://localhost/SimpleServlet.shtml

For cases where you have created SimpleServlet in a package, the full class name is required in the <servlet> tag. So, if SimpleServlet belonged to a package foo.bar, the servlet tag would be <servlet code=foo.bar.SimpleServlet>.

Calling SimpleServlet through POST

To call SimpleServlet using post, try the following.

Create a new file, and name it SimpleServlet.html
Type the following into your file:

<HTML>

<BODY>

<PRE>

Enter Query: <input type="text" size=80 name="dbQuery">

</PRE>

</FORM>

</BODY>

</HTML>

Save SimpleServlet.html into your <web_server_root> directory
In your web browser reguest the page.

http://localhost/SimpleServlet.html

For cases where you have created SimpleServlet in a package, the full class name is required in the <FORM> tag. So, if SimpleServlet belonged to a package foo.bar, the <FORM> tag would be <FORM method="post" action="/servlet/foo.bar.SimpleServlet">.

Calling SimpleServlet through GET

To call SimpleServlet with get, try the following.

In your web browser request the page by typing the following.

http://localhost/servlet/SimpleServlet?dbQuery=select+*+from+mydatabase

Note: Just like the prior SimpleServlet calls, the full class name of SimpleServlet is required.

Calling SimpleServlet from an applet

The following class is responsible for connecting to and querying a database servlet.


package JBExamples.database.applets;

import java.util.*;
import java.net.*;
import java.io.*;

public class HTTPTransportClient implements ITransportClient {
  String servletLoc;

  public HTTPTransportClient(String servletLoc) {
    this.servletLoc = servletLoc;
  }

  public String executeQuery(String queryString) throws Exception {
    StringBuffer results = new StringBuffer();

    //The value of dbquery has to be urlencoded to be passed through 
    //http.
    String postData   = "dbquery="+URLEncoder.encode(queryString);

    URL action = new URL(servletLoc);
    URLConnection url = action.openConnection();

    url.setDoInput(true);
    url.setDoOutput(true);
    url.setUseCaches(false);
    url.setRequestProperty("Content-type", "application/x-www-form-urlencoded");
    url.setRequestProperty("Content-length", "" + postData.length());

    // Write out post data
    DataOutputStream out = new DataOutputStream(url.getOutputStream());
    out.writeBytes(postData);
    out.flush();
    out.close();

    // Get response
    DataInputStream in = new DataInputStream(new BufferedInputStream(url.getInputStream()));

    String line;
    while(null != ((line = in.readLine())))
      results.append(line + "\n");

    return results.toString();
  }

}

The executeQuery() method illustrates how to communicate to the JDBC servlet using the HTTP transport. This method also illustrates how general applet to servlet communication can be carried out. A simple test applet in later examples will illustrate using the above class to display the results of a query.

Continue to Part II

Example: Creating a JDBC Servlet as RMI server

Example: Creating a JDBC Servlet as CORBA Server