JSP(JAVA Server

Pages)
Introduction

 JavaServer Pages (JSP) is a technology for developing Webpages that supports

dynamic content.
 This helps developers insert java code in HTML pages by making use of special
JSP tags, most of which start with .
 A JavaServer Pages component is a type of Java servlet that is designed to fulfill
the role of a user interface for a Java web application.
 Web developers write JSPs as text files that combine HTML or XHTML code, XML
elements, and embedded JSP actions and commands.
 Using JSP,user can collect input from users through Webpage forms, present
records from a database or another source, and create Webpages dynamically.
 JSP tags can be used for a variety of purposes, such as retrieving information
from a database or registering user preferences, accessing JavaBeans
components, passing control between pages, and sharing information between
requests, pages etc.
Why?

 JavaServer Pages often serve the same purpose as programs implemented using the
Common Gateway Interface (CGI).
 But JSP offers several advantages in comparison with the CGI.
 Performance is significantly better because JSP allows embedding Dynamic Elements in
HTML Pages itself instead of having separate CGI files.
 JSP are always compiled before they are processed by the server unlike CGI/Perl which
requires the server to load an interpreter and the target script each time the page is
requested.
 JavaServer Pages are built on top of the Java Servlets API, so like Servlets, JSP also has
access to all the powerful Enterprise Java APIs, including JDBC, JNDI, EJB, JAXP, etc.
 JSP pages can be used in combination with servlets that handle the business logic, the
model supported by Java servlet template engines.
 Finally, JSP is an integral part of Java EE, a complete platform for enterprise class
applications. This means that JSP can play a part in the simplest applications to the most
complex and demanding.
advantages

 vs. Active Server Pages (ASP) The advantages of JSP are twofold.
 First, the dynamic part is written in Java, not Visual Basic or other MS specific
language, so it is more powerful and easier to use.
 Second, it is portable to other operating systems and non-Microsoft Web servers.
 vs. Pure Servlets It is more convenient to write (and to modify!) regular HTML
than to have plenty of println statements that generate the HTML.
 vs. Server-Side Includes (SSI) SSI is really only intended for simple inclusions, not
for "real" programs that use form data, make database connections, and the like.
 vs. JavaScript JavaScript can generate HTML dynamically on the client but can
hardly interact with the web server to perform complex tasks like database
access and image processing etc.
 vs. Static HTML Regular HTML, of course, cannot contain dynamic information.
JSP ─ ARCHITECTURE
Processing

 The following steps explain how the web server creates the Webpage using JSP:
 As with a normal page, your browser sends an HTTP request to the web server.
 The web server recognizes that the HTTP request is for a JSP page and forwards it to a JSP
engine. This is done by using the URL or JSP page which ends with .jsp instead of .html.
 The JSP engine loads the JSP page from disk and converts it into a servlet content. This
conversion is very simple in which all template text is converted to println( ) statements and all
JSP elements are converted to Java code. This code implements the corresponding dynamic
behavior of the page.
 The JSP engine compiles the servlet into an executable class and forwards the original request
to a servlet engine. A part of the web server called the servlet engine loads the Servlet class
and executes it.
 During execution, the servlet produces an output in HTML format. This output is further passed
on to the web server by the servlet engine inside an HTTP response.
 The web server forwards the HTTP response to your browser in terms of static HTML content.
 Finally, the web browser handles the dynamically-generated HTML page inside the HTTP
response exactly as if it were a static page.
Life Cycle

 A JSP life cycle is defined as the process from its creation till the
destruction.
 This is similar to a servlet life cycle with an additional step which is
required to compile a JSP into servlet.
 The following are the paths followed by a JSP
 Compilation
 Initialization
 Execution
 Cleanup
 The four major phases of a JSP life cycle are very similar to the
Servlet Life Cycle. The four phases have been described below:
Java Server Pages (JSP)
Fundamentals
 Java Server Pages are HTML pages embedded with snippets of
Java code.
 It is an inverse of a Java Servlet
 Four different elements are used in constructing JSPs
 Scripting Elements
 Implicit Objects
 Directives
 Actions
Java Server Pages (JSP)
Architecture
 JSPs run in two phases Receive HTTP Server
Request
 Translation Phase
 JSP Container
Execution Phase
Page Compiler Servlet
 In translation phase JSP page JSP Servlet No
Parse JSP
is compiled into a servlet Current?

 Yes
called JSP Page
JSP Servlet Generate JSP
Implementation class Loaded? Servlet Source
 In execution phase the Yes No
compliled JSP is processed Load Servlet
Compile JSP
Servlet

JSP Page Servlet

Generate
Response

Send
Response
Scripting Elements
Types
 There are three kinds of scripting elements
 Declarations
 Scriptlets
 Expressions
Declarations
Basics
 Declarations are used to define methods & instance variables
 Do not produce any output that is sent to client
 Embedded in <%! and %> delimiters
Example:
<%!
Public void jspDestroy() {
System.out.println(“JSP Destroyed”);
}
Public void jspInit() {
System.out.println(“JSP Loaded”);
}
int myVar = 123;
%>
 The functions and variables defined are available to the JSP Page
as well as to the servlet in which it is compiled
Scriptlets
Basics
 Used to embed java code in JSP pages.
 Contents of JSP go into _JSPpageservice() method
 Code should comply with syntactical and semantic constuct of java
 Embedded in <% and %> delimiters
Example:
<%
int x = 5;
int y = 7;
int z = x + y;
%>
Expressions
Basics
 Used to write dynamic content back to the browser.
 If the output of expression is Java primitive the value is printed
back to the browser
 If the output is an object then the result of calling toString on the
object is output to the browser
 Embedded in <%= and %> delimiters
Example:
 <%=“Fred”+ “ “ + “Flintstone %>
prints “Fred Flintstone” to the browser
 <%=Math.sqrt(100)%>
prints 10 to the browser
Java Implicit Objects
Scope
 Implicit objects provide access to server side objects
 e.g. request, response, session etc.
 There are four scopes of the objects
 Page: Objects can only be accessed in the page where they are
referenced
 Request: Objects can be accessed within all pages that serve
the current request.
(Including the pages that are forwarded to and included in
the original jsp page)
 Session: Objects can be accessed within the JSP pages for which
the objects are defined
 Application: Objects can be accessed by all JSP pages in a given
context
Java Implicit Objects
List
 request: Reference to the current request
 response: Response to the request
 session: session associated worth current request
 application: Servlet context to which a page belongs
 pageContext: Object to access request, response, session and
application associated with a page
 config: Servlet configuration for the page
 out: Object that writes to the response output stream
 page: instance of the page implementation class (this)
 exception: Available with JSP pages which are error pages
 Java Implicit Objects
Example
<html> <p>
<head> Storing a string to the application...<br>
<title>Implicit Objects</title> <% application.setAttribute("name", "Meeraj"); %>
Retrieving the string from application...<br>
</head>
<b>Name:</b>
<body style="font-family:verdana;font-size:10pt">
<%= application.getAttribute("name") %>
<p>
</p>
Using Request parameters...<br>
<p>
<b>Name:</b> <%= request.getParameter("name") %>
Storing a string to the page context...<br>
</p> <% pageContext.setAttribute("name", "Meeraj"); %>
<p> Retrieving the string from page context...</br>
<% out.println("This is printed using the out implicit <b>Name:</b>
variable"); %>
<%= pageContext.getAttribute("name") %>
</p> </p>
<p> </body>
Storing a string to the session...<br> </html>
<% session.setAttribute("name", "Meeraj"); %>
Retrieving the string from session...<br>
<b>Name:</b> <%= session.getAttribute("name") %>
</p>
Example Implicit Objects
Deploy & Run
 Save file:
 $TOMCAT_HOME/webapps/jsp/Implicit.jsp
 Access file
 http://localhost:8080/jsp/Implicit.jsp?name=Sanjay
 Results of the execution

Using Request parameters...

Name: sanjay
This is printed using the out implicit variable
Storing a string to the session...
Retrieving the string from session...
Name: Meeraj
Storing a string to the application...
Retrieving the string from application...
Name: Meeraj
Storing a string to the page context...
Retrieving the string from page context...
Name: Meeraj
Directives
Basics & Types
 Messages sent to the JSP container
 Aids the container in page translation
 Used for
 Importing tag libraries
 Import required classes
 Set output buffering options
 Include content from external files
 The jsp specification defines three directives
 Page: provder information about page, such as scripting
language that is used, content type, or buffer size
 Include – used to include the content of external files
 Taglib – used to import custom actions defined in tag
libraries
Page Directives
Basics & Types
 Page directive sets page properties used during
translation
 JSP Page can have any number of directives
 Import directive can only occur once
 Embedded in <%@ and %> delimiters
 Different directives are
 Language: (Default Java) Defines server side scripting
language (e.g. java)
 Extends: Declares the class which the servlet compiled
from JSP needs to extend
 Import: Declares the packages and classes that need to be
imported for using in the java code (comma separated list)
 Session: (Default true) Boolean which says if the session
implicit variable is allowed or not
 Buffer: defines buffer size of the jsp in kilobytes (if set to
none no buffering is done)
Page Directives
Types con’t.
 Different directives are (cont’d.)
 autoFlush:When true the buffer is flushed when max
buffer size is reached (if set to false an exception is
thrown when buffer exceeds the limit)
 isThreadSafe: (default true) If false the compiled
servlet implements SingleThreadModel interface
 Info: String returned by the getServletInfo() of the
compiled servlet
 errorPage: Defines the relative URI of web resource
to which the response should be forwarded in case of
an exception
 contentType: (Default text/html) Defines MIME type
for the output response
 isErrorPage: True for JSP pages that are defined as
error pages
Page Directives
Example
<%@
page language=“java”
buffer=“10kb”
autoflush=“true”
errorPage=“/error.jsp”
import=“java.util.*, javax.sql.RowSet”
%>
Include Directive
Basics
 Used to insert template text and JSP code
during the translation phase.
 The content of the included file specified by the
directive is included in the including JSP page
 Example
 <%@ include file=“included.jsp” %>
JSP Actions
Basics & Types
 Processed during the request processing phase.
 As opposed to JSP directives which are processed during
translation
 Standard actions should be supported by J2EE compliant
web servers
 Custom actions can be created using tag libraries
 The different actions are
 Include action
 Forward action
 Param action
 useBean action
 getProperty action
 setProperty action
 plugIn action
JSP Actions
Include
 Include action used for including resources in a
JSP page
 Include directive includes resources in a JSP page at
translation time
 Include action includes response of a resource into
the response of the JSP page
 Same as including resources using
RequestDispatcher interface
 Changes in the included resource reflected while
accessing the page.
 Normally used for including dynamic resources
 Example
 <jsp:include page=“inlcudedPage.jsp”>
 Includes the the output of includedPage.jsp into the
JSP Actions
Forward
 Forwards the response to other web
specification resources
 Same as forwarding to resources using
RequestDispatcher interface
 Forwarded only when content is not committed
to other web application resources
 Otherwise an IllegalStateException is thrown
 Can be avoided by setting a high buffer size for the
forwarding jsp page
 Example
 <jsp:forward page=“Forwarded.html”>
 Forwards the request to Forwarded.html
JSP Actions
Param
 Used in conjunction with Include & Forward
actions to include additional request
parameters to the included or forwarded
resource
 Example
<jsp:forward page=“Param2.jsp”>
<jsp:param name=“FirstName” value=“Sanjay”>
</jsp:forward>
 This will result in the forwarded resource having an
additional parameter FirstName with a value of
Sanjay
JSP Actions
useBean
 Creates or finds a Java object with the defined scope.
 Object is also available in the current JSP as a scripting variable
 Syntax:
<jsp:useBean id=“name”
scope=“page | request | session | application”
class=“className” type=“typeName” |
bean=“beanName” type=“typeName” |
type=“typeName” />
 At least one of the type and class attributes must be present
 We can’t specify values for bith the class and bean name.
 Example
<jsp:useBean id=“myName” scope=“request”
class=“java.lang.String”>
<% firstName=“Sanjay”; %>
</jsp:useBean>
JSP Actions
get/setProperty
 getProperty is used in conjunction with useBean to get
property values of the bean defined by the useBean
action
 Example (getProperty)
 <jsp:getProperty name=“myBean” property=“firstName” />
 Name corresponds to the id value in the useBean
 Property refers to the name of the bean property
 setProperty is used to set bean properties
 Example (setProperty)
 <jsp:setProperty name=“myBean” property=“firstName”
value=“Sanjay”/>
 Sets the name property of myBean to SanjayExample (setProperty)
 <jsp:setProperty name=“myBean” property=“firstName”
param=“fname”/>
 Sets the name property of myBean to the request parameter fname
 <jsp:setProperty name=“myBean” property=“*”>
JSP Actions
plugIn
 Enables the JSP container to render appropriate HTML
(based on the browser type) to:
 Initiate the download of the Java plugin
 Execution of the specified applet or bean
 plugIn standard action allows the applet to be embedded
in a browser neutral fashion
 Example
<jsp: plugin type=“applet” code=“MyApplet.class”
codebase=“/”>
<jsp:params>
<jsp:param name=“myParam” value=“122”/>
</jsp:params>
<jsp:fallback><b>Unable to load applet</b></jsp:fallback>
</jsp:plugin>
 Example
Loan Calculator
Header.jsp
Gets input to compute loan from index.jsp Footer.jsp
user 

Selects the right jsp for calculating controller.jsp

loan 

Computes loan Header.jsp Computes loan

based on simple simple.jsp Footer.jsp compound.jsp based on simple
interest interest

error.jsp Calculate loan error.jsp Calculate loan

Handles error if Handles error if
exception is thrown exception is thrown
 Loan Calculator
index.jsp
<html> <tr>
<head> <td>Simple:</td>
<title>Include</title> <td><input type="radio" name="type" value="S" /></td>
</head> </tr>
<body style="font-family:verdana;font-size:10pt;"> <tr>
<%@ include file="header.html" %> <td>Period:</td>
<form action="controller.jsp"> <td><input type="text" name="period"/></td>
<table border="0" style="font-family:verdana;font-size:10pt;"> </tr>
<tr> </table>
<td>Amount:</td> <input type="submit" value="Calculate"/>
<td><input type="text" name="amount" /> </form>
</tr> <jsp:include page="footer.jsp"/>

<tr> </body>

<td>Interest in %:</td> </html>

<td><input type="text" name="interest"/></td>

</tr>
<tr>
<td>Compound:</td>
<td><input type="radio" name="type" value="C"
checked/></td>
</tr>
 Loan Calculator
Miscelaneous
controller.jsp error.jsp
<% <%@ page isErrorPage="true" %>
String type = request.getParameter("type"); <html>
<head>
if(type.equals("S")) {
<title>Simple</title>
%>
</head>
<jsp:forward page="/simple.jsp"/>
<body style="font-family:verdana;font-size:10pt;">
<%
<%@ include file="header.html" %>
} else {
<p style="color=#FF0000"><b><%=
%> exception.getMessage() %></b></p>
<jsp:forward page="/compound.jsp"/> <jsp:include page="footer.jsp"/>
<% </body>
} </html>
header.jsp
%>
<h3>Loan Calculator</h3>
footer.jsp
<%= new java.util.Date() %>
 Loan Calculator
simple.jsp
<%@ page errorPage="error.jsp" %> <html>
<%! <head>
public double calculate(double amount, double <title>Simple</title>
interest, int period) { </head>
if(amount <= 0) { <body style="font-family:verdana;font-size:10pt;">
throw new IllegalArgumentException("Amount <%@ include file="header.html" %>
should be greater than 0: " + amount); <%
} double amount =
Double.parseDouble(request.getParameter("amount"
if(interest <= 0) { ));
throw new IllegalArgumentException("Interest double interest =
should be greater than 0: " + interest); Double.parseDouble(request.getParameter("interest"
} ));
int period =
if(period <= 0) {
Integer.parseInt(request.getParameter("period"));
throw new IllegalArgumentException("Period should %>
be greater than 0: " + period);
<b>Pincipal using simple interest:</b>
}
<%= calculate(amount, interest, period) %>
return amount*(1 + period*interest/100);
<br/><br/>
} <jsp:include page="footer.jsp"/>
%> </body>
</html>
 Loan Calculator
compound.jsp
<%@ page errorPage="error.jsp" %> <html>
<%! <head>
public double calculate(double amount, double <title>Compound</title>
interest, int period) { </head>
if(amount <= 0) { <body style="font-family:verdana;font-size:10pt;">
throw new IllegalArgumentException("Amount <%@ include file="header.html" %>
should be greater than 0: " + amount); <%
} double amount =
Double.parseDouble(request.getParameter("amount
if(interest <= 0) { "));
throw new IllegalArgumentException("Interest double interest =
should be greater than 0: " + interest); Double.parseDouble(request.getParameter("interest
} "));
int period =
if(period <= 0) {
Integer.parseInt(request.getParameter("period"));
throw new IllegalArgumentException("Period should %>
be greater than 0: " + period);
<b>Pincipal using compound interest:</b>
}
<%= calculate(amount, interest, period) %>
return amount*Math.pow(1 + interest/100, period);
<br/><br/>
} <jsp:include page="footer.jsp"/>
%> </body>
</html>
 Example
Inventory
Runs the SQL query
for listing inventory ListServlet

Takes the RowSet in the

context and renders it List.jsp

Renders form for new item

Runs SQL query to get a Deletes a record
record from item from the item table
EditServlet New.html DeleteServlet

Takes a RowSet and

renders a form for
editing Edit.jsp CreateServlet
Runs SQL query to
Runs SQL query to create new record
update the data in the
item table after editing UpdateServlet
 Inventory
ListServlet
package edu.albany.mis.goel.servlets; public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException {
import javax.servlet.ServletException;
try {
import javax.servlet.ServletConfig;
// Load the driver class
import javax.servlet.http.HttpServlet; Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
import javax.servlet.http.HttpServletRequest; // Define the data source for the driver
import javax.servlet.http.HttpServletResponse; String sourceURL = "jdbc:odbc:inventoryDB";
import javax.sql.DataSource; RowSet rs = new CachedRowSet();
import javax.sql.RowSet; rs.setUrl(sourceURL);
import sun.jdbc.rowset.CachedRowSet; rs.setCommand("select * from item");
public class ListServlet extends HttpServlet { rs.execute();
public void init(ServletConfig config) throws req.setAttribute("rs", rs);
ServletException { getServletContext().getRequestDispatcher("/List.jsp").
super.init(config); forward(req, res);
} } catch(Exception ex) {
public void doPost(HttpServletRequest req, throw new ServletException(ex);
HttpServletResponse res) }
throws ServletException { }
doGet(req, res); }
}
 Inventory
EditServlet
package edu.albany.mis.goel.servlets; public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException {
import javax.servlet.ServletException;
try {
import javax.servlet.ServletConfig;
// Load the driver class
import javax.servlet.http.HttpServlet;
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
import javax.servlet.http.HttpServletRequest;
// Define the data source for the driver
import javax.servlet.http.HttpServletResponse;
String sourceURL = "jdbc:odbc:inventoryDB";
import java.sql.DriverManager;
RowSet rs = new CachedRowSet();
import javax.sql.DataSource;
rs.setUrl(sourceURL);
import javax.sql.RowSet;
rs.setCommand("select * from item where id = ?");
import sun.jdbc.rowset.CachedRowSet;
rs.setInt(1, Integer.parseInt(req.getParameter("id")));
rs.execute();
public class EditServlet extends HttpServlet { req.setAttribute("rs", rs);
public void init(ServletConfig config) throws ServletException {
super.init(config); getServletContext().getRequestDispatcher("/Edit.jsp
").forward(req, res);
}
} catch(Exception ex) {
public void doPost(HttpServletRequest req,
HttpServletResponse res) throw new ServletException(ex);

throws ServletException { }

doGet(req, res);
}
}
}
 Inventory
UpdateServlet
package edu.albany.mis.goel.servlets; // Create a connection through the DriverManager class
con = DriverManager.getConnection(sourceURL);
import javax.servlet.ServletException; System.out.println("Connected Connection");
import javax.servlet.ServletConfig; PreparedStatement stmt= con.prepareStatement
import javax.servlet.http.HttpServlet; ("update item " + "set name = ?, " + "description = ?, " + "price = ?, "

import javax.servlet.http.HttpServletRequest; + "stock = ? " + "where id = ?");

stmt.setString(1, req.getParameter("name"));
import javax.servlet.http.HttpServletResponse;
stmt.setString(2, req.getParameter("description"));
import javax.sql.DataSource;
stmt.setDouble(3, Double.parseDouble(req.getParameter("price")));
import javax.naming.InitialContext;
stmt.setInt(4, Integer.parseInt(req.getParameter("stock")));
import java.sql.DriverManager;
stmt.setInt(5, Integer.parseInt(req.getParameter("id")));
import java.sql.Connection;
stmt.executeUpdate();
import java.sql.PreparedStatement;
stmt.close();
import java.sql.ResultSet;
getServletContext().getRequestDispatcher("/List").
public class UpdateServlet extends HttpServlet {
forward(req, res);
public void init(ServletConfig config) throws ServletException {
} catch(Exception ex) {
super.init(config); throw new ServletException(ex);
} } finally {
public void doPost(HttpServletRequest req, HttpServletResponse res) try {
throws ServletException { if(con != null) {
doGet(req, res); con.close();
} }
public void doGet(HttpServletRequest req, HttpServletResponse res) } catch(Exception ex) {
throws ServletException { throw new ServletException(ex);
Connection con = null; }
try { }
// Load the driver class }
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); }

// Define the data source for the driver

String sourceURL = "jdbc:odbc:inventoryDB";
 Inventory
DeleteServlet
package edu.albany.mis.goel.servlets; try {
// Load the driver class
import javax.servlet.ServletException; Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
import javax.servlet.ServletConfig; // Define the data source for the driver
import javax.servlet.http.HttpServlet; String sourceURL = "jdbc:odbc:inventoryDB";

import javax.servlet.http.HttpServletRequest; // Create a connection through the DriverManager class

con = DriverManager.getConnection(sourceURL);
import javax.servlet.http.HttpServletResponse;
System.out.println("Connected Connection");
import javax.sql.DataSource;
// Create Statement
import javax.naming.InitialContext;
PreparedStatement stmt =
import java.sql.Connection;
con.prepareStatement("delete from item where id = ?");
import java.sql.DriverManager;
stmt.setInt(1, Integer.parseInt(req.getParameter("id")));
import java.sql.PreparedStatement;
stmt.executeUpdate();
import java.sql.ResultSet;
stmt.close();
public class DeleteServlet extends HttpServlet {
getServletContext().getRequestDispatcher("/List").
public void init(ServletConfig config) throws ServletException {
forward(req, res);
super.init(config); } catch(Exception ex) {
} throw new ServletException(ex);
public void doPost(HttpServletRequest req, HttpServletResponse res) } finally {
throws ServletException { try {
doGet(req, res); if(con != null) con.close();
} } catch(Exception ex) {
public void doGet(HttpServletRequest req, HttpServletResponse res) throw new ServletException(ex);
throws ServletException { }
Connection con = null; }
}
}
 Inventory
CreateServlet
package edu.albany.mis.goel.servlets; // Define the data source for the driver
String sourceURL = "jdbc:odbc:inventoryDB";
import javax.servlet.ServletException; // Create a connection through the DriverManager class
import javax.servlet.ServletConfig; con = DriverManager.getConnection(sourceURL);
import javax.servlet.http.HttpServlet; System.out.println("Connected Connection");

import javax.servlet.http.HttpServletRequest; PreparedStatement stmt = con.prepareStatement

("insert into item " + "(name,description,price,stock) " +
import javax.servlet.http.HttpServletResponse;
"values (?, ?, ?, ?)");
import javax.sql.DataSource;
stmt.setString(1, req.getParameter("name"));
import javax.naming.InitialContext;
stmt.setString(2, req.getParameter("description"));
import java.sql.DriverManager;
stmt.setDouble(3, Double.parseDouble(req.getParameter("price")));
import java.sql.Connection;
stmt.setInt(4, Integer.parseInt(req.getParameter("stock")));
import java.sql.PreparedStatement;
stmt.executeUpdate();
import java.sql.ResultSet;
stmt.close();
public class CreateServlet extends HttpServlet {
getServletContext().getRequestDispatcher("/List").forward(req, res);
public void init(ServletConfig config) throws ServletException {
super.init(config); } catch(Exception ex) {
} throw new ServletException(ex);
public void doPost(HttpServletRequest req, HttpServletResponse res) } finally {
throws ServletException { try {
doGet(req, res); if(con != null) con.close();

} } catch(Exception ex) {
throw new ServletException(ex);
public void doGet(HttpServletRequest req, HttpServletResponse res)
}
throws ServletException {
}
Connection con = null;
}
try { // Load the driver class
}
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
 Inventory
Edit.jsp
<%@page contentType="text/html"%> <tr>
<jsp:useBean id="rs" scope="request" type="javax.sql.RowSet" /> <td><b>Price:</b></td>
<html> <td>
<head> <input name="price" type="text" value="<%= rs.getString(4) %>"/>
<title>Inventory - Edit</title> </td>
</head> </tr>
<body style="font-family:verdana;font-size:10pt;"> <tr>

<% <td><b>Stock:</b></td>

if(rs.next()) {
<td>
<input name="stock" type="text" value="<%= rs.getString(5) %>"/>
%>
</td>
<form action="Update">
</tr>
<input name="id" type="hidden" value="<%= rs.getString(1) %>"/>
<tr>
<table cellpadding="5" style="font-family:verdana;font-size:10pt;">
<td></td>
<tr>
<td>
<td><b>Name:</b></td>
<input type="submit" value="Update"/>
<td>
</td>
<input name="name" type="text" value="<%= rs.getString(2) %>"/>
</tr>
</td>
</table>
</tr>
<%
<tr>
}
<td><b>Description:</b></td>
%>
<td> </body>
<input name="description" type="text" value="<%= rs.getString(3) </html>
%>"/>
</td>
</tr>
 Inventory
Edit.jsp
<%@page contentType="text/html"%> <tr>
<jsp:useBean id="rs" scope="request" type="javax.sql.RowSet" /> <td><%= rs.getString(2) %></td>
<td><%= rs.getString(3) %></td>
<td><%= rs.getString(4) %></td>
<html>
<td><%= rs.getString(5) %></td>
<head>
<td>
<title>Inventory - List</title>
<a href="Delete?id=<%= rs.getString(1) %>">
</head>
Delete
<body style="font-family:verdana;font-size:10pt;">
</a>
<table cellpadding="5" style="font-family:verdana;font-size:10pt;"> </td>
<tr> <td>
<th>Name</th> <a href="Edit?id=<%= rs.getString(1) %>">
<th>Description</th> Edit
<th>Price</th> </a>
<th>Stock</th> </td>
<th></th> </tr>
<th></th> <%
}
</tr>
%>
<%
</table>
while(rs.next()) {
<a href="New.html">New Item</a>
%>
</body>
</html>
 Inventory
New.html
<html> <tr>
<head> <td></td>
<title>Inventory - Add New Item</title> <td><input type="submit" value="Create"/></td>

</head> </tr>

<body style="font-family:verdana;font-size:10pt;">
</table>

<form action="Create">
</body>
<table cellpadding="5" style="font-family:verdana;font-size:10pt;">
</html>
<tr>
<td><b>Name:</b></td>
<td><input name="name" type="text"/></td>
</tr>
<tr>
<td><b>Description:</b></td>
<td><input name="description" type="text"/></td>
</tr>
<tr>
<td><b>Price:</b></td>
<td><input name="price" type="text"/></td>
</tr>
<tr>
<td><b>Stock:</b></td>
<td><input name="stock" type="text"/></td>
</tr>