TABLE DESCRIPTION

Login Table
ATTRIBUTE
UNAME
PWORD

DATATYPE
Varchar(10)
Varchar(10)

CONSTRAINT
NotNull
NotNull

DESCRIPTION
Username
Password

The login table of the consumer database has two attributes namely the uname
and pword. The datatype has been specified for these two attributes as varchar.
The maximum size given for this attributes are 10 respectively. The constraints
represents the restriction in this table. The uname represents the username of
the user and the pword represents the password of the user.

Bank Details
ATTRIBUTE
CreditCard

DATATYPE
Varchar(10)

CONSTRAINT
NotNull

Pincode
Amount

Varchar(10)
Varchar(20)

NotNull
NotNull

DESCRIPTION
Consumer credit
card
Consumer pincode
Amount

The bankdetails table of the consumer database has three attributes namely the
creditcard, pincode and amount.

The datatype has been specified for these

three attributes as varchar. The maximum size given for this attributes are 10 for
creditcard and pincode and 20 for amount respectively.

The constraints

represents the restriction in this table. The creditcard represents the consumer
credit card number, the pincode represents the pincode for the credit card and
the amount represents the amount available in that credit card.

SOFTWARE DESCRIPTION
2.3.1 Web Page Designing using JSP/HTML
JavaServer Pages (JSP) is a Java technology that allows software
developers to dynamically generate HTML, XML or other types of documents in
response to a Web client request. The technology allows Java code and certain
pre-defined actions to be embedded into static content. The JSP syntax adds
additional XML-like tags, called JSP actions, to be used to invoke built-in
functionality. Additionally, the technology allows for the creation of JSP tag
libraries that act as extensions to the standard HTML or XML tags. Tag libraries
provide a platform independent way of extending the capabilities of a Web
server. JSPs are compiled into Java Servlets by a JSP compiler. A JSP compiler
may generate a servlet in Java code that is then compiled by the Java compiler,
or it may generate byte code for the servlet directly. "JavaServer Pages" is a
technology released by Sun
2.3.2. Java Script Validations
JavaScript

is

Netscapes

cross-platform,

object-oriented

scripting

language, Core JavaScript contains a core set of objects, such as Array, Date,
and Math, and a core set of language elements such as operators, control
structures and statements. Core JavaScript can be extended for a variety of
purposes by supplementing it with additional objects; Client-side JavaScript
statements embedded in an HTML page can respond to user events such as
mouse clicks, form input and page navigation. For example, you can write a
JavaScript function to verify that users enter valid information into a form
requesting a telephone number or zip code. Without any network transmisson,

the embedded JavaScript on the HTML page can check the entered data and
display a dialogbox if the user enters invalid data. This module is involved in
basic form validations before submitting the page to the server.
2.3.3 Servlet Implementation
The Java Servlet API allows a software developer to add dynamic content
to a Web server using the Java platform. The generated content is commonly
HTML, but may be other data such as XML. Servlets with JavaServer Pages are
the Java counterpart to dynamic Web content technologies such as CGI/PHP or
ASP.NET/VBScript,JScript,C#. Servlets can maintain state across many server
transactions by using HTTP cookies, session variables or URL rewriting. The
Servlet API, contained in the Java package hierarchy javax.servlet, defines the
expected interactions of a Web container and a servlet.
A Web container is essentially the component of a Web server that
interacts with the servlets. The Web container is responsible for managing the
lifecycle of servlets, mapping a URL to a particular servlet and ensuring that the
URL requester has the correct access rights. A Servlet is an object that receives
a request (ServletRequest) and generates a response (ServletResponse) based
on the request. The API package javax.servlet.http defines HTTP subclasses of
the generic servlet (HttpServlet) request (HttpServletRequest) and response
(HttpServletResponse) as well as a session (HttpSession) that tracks multiple
requests and responses between the Web server and a client.
Servlets may be packaged in a WAR file as a Web application. Moreover,
servlets can be generated automatically by JavaServer Pages (JSP), or
alternately by template engines such as WebMacro. Often servlets are used in
conjunction with JSPs in a pattern called "Model 2", which is a flavor of the
model-view-controller pattern.

Life Cycle of a Servlet

The Servlet life cycle consists of the following steps:
1. The Servlet class is loaded by the container during start-up.
2. The container calls the init() method. This method initializes the servlet and
must be called before the servlet can service any requests. In the entire life of
a servlet, the init method is called only once.
3. After initialization, the servlet can service client-requests. Each request is
serviced in its own separate thread. The container calls the service() method
of the servlet for every request. The service() method determines the kind of
HTTP request (GET, POST etc) and accordingly calls the methods doGet(),
doPost(), doTrace() etc. The developer of the servlet must provide
implementation for these methods. If an implementation for doPost() has not
been provided, it means that the servlet cannot handle POST requests. A
developer must never overload the service() method.
4. Finally, the container calls the destroy() method which takes the servlet out of
service. The destroy() method like init() is called only once in the life-cycle of
a Servlet.
ServletConfig and ServletContext
There is only one ServletContext in every application. This object can be
used by all the servlets to obtain application level information or container details.
Every servlet, on the other hand, gets its own ServletConfig object. This object
provides initialization parameters for a servlet. A developer can obtain the
reference to ServletContext using the ServletConfig object.

2.3.4. Java Bean Design

The component model for JSP technology is based on JavaBeans
component architecture. JavaBeans components are nothing but Java classes
that can be easily reused and composed together into applications which follow a
well-defined design/naming pattern: the bean encapsulates its properties by
declaring them private and provides public accessor(getter/setter) methods for
reading and modifying their values. JavaBeans component design conventions
govern the properties of the class and govern the public methods that give
access

to

the

properties. A JavaBeans

component

property can

be

Read/Write/read-only/write-only or simple, which means it contains a single

value, or indexed, which means it represents an array of values.
A property does not have to be implemented by an instance variable. It
must simply be accesible using public methods. In addition to the property
methods, a JavaBeans component must define a constructor that takes no
parameters. In the project, a JSP page uses the JavaBeans components.
JavaBeans component provides front end to the access database object.
2.3.5 JDBC
JDBC is an API for the Java programming language that defines how a
client may access a database. It provides methods for querying and updating
data in a database. JDBC is oriented towards relational databases. The Java
Platform, Standard Edition includes the JDBC API together with an ODBC
implementation of the API enabling connections to any relational database that
supports ODBC. This driver is native code and not Java, and is closed source.

Overview
JDBC allows multiple implementations to exist and be used by the same
application. The API provides a mechanism for dynamically loading the correct
Java packages and registering them with the JDBC Driver Manager. The Driver
Manager is used as a connection factory for creating JDBC connections. JDBC
connections support creating and executing statements. These statements may
be update statements such as SQL INSERT, UPDATE and DELETE or they may
be query statements using the SELECT statement. Additionally, stored
procedures may be invoked through a statement. Statements are one of the
following types:

Statement the statement is sent to the database server each and every
time.

PreparedStatement the statement is cached and then the execution path

is pre determined on the database server allowing it to be executed
multiple times in an efficient manner.

CallableStatement used for executing stored procedures on the

database.

Update statements such as INSERT, UPDATE and DELETE return an update

count that indicates how many rows were affected in the database. These
statements do not return any other information. Query statements return a JDBC
row result set. The row result set is used to walk over the result set. Individual
columns in a row are retrieved either by name or by column number. There may
be any number of rows in the result set. The row result set has metadata that
describes the names of the columns and their types. There is an extension to the
basic JDBC API in the javax.sql package that allows for scrollable result sets and
cursor support among other things.

2.3.6 Model View Controller

Model-view-controller (MVC) is an architectural pattern used in software
engineering. In complex computer applications that present lots of data to the
user, one often wishes to separate data (model) and user interface (view)
concerns, so that changes to the user interface do not impact the data handling,
and that the data can be reorganized without changing the user interface. The
model-view-controller solves this problem by decoupling data access and
business logic from data presentation and user interaction, by introducing an
intermediate component: the controller. Pattern description It is common to split
an application into separate layers: presentation (UI), domain, and data access.
In MVC the presentation layer is further separated into View and Controller. MVC
encompasses more of the architecture of an application than is typical for a
design pattern.
Model
The domain-specific representation of the information on which the
application operates. The model is another name for the domain layer. Domain
logic adds meaning to raw data (e.g., calculating if today is the user's birthday, or
the totals, taxes and shipping charges for shopping cart items). Many
applications use a persistent storage mechanism (such as a database) to store
data. MVC does not specifically mention the data access layer because it is
understood to be underneath or encapsulated by the Model.
View
Renders the model into a form suitable for interaction, typically a user
interface element. MVC is often seen in web applications, where the view is the
HTML page and the code which gathers dynamic data for the page.

Controller
Processes and responds to events, typically user actions, and may invoke
changes on the model. Though MVC comes in different flavors, control flow
generally works as follows:

The user interacts with the user interface in some way (e.g., user presses
a button)

A controller handles the input event from the user interface, often via a
registered handler or callback.

The controller accesses the model, possibly updating it in a way

appropriate to the user's action (e.g., controller updates user's shopping
cart).

A view uses the model to generate an appropriate user interface (e.g.,

view produces a screen listing the shopping cart contents). The view gets
its own data from the model. The model has no direct knowledge of the
view. (However, the observer pattern can be used to allow the model to
indirectly notify interested parties potentially including views of a
change.)

The user interface waits for further user interactions, which begins the
cycle anew.

Figure 1
2.3.7 Auto Execution of Database Schema:
This module aims in creating the database schema when the software
loads for the first time. The database schemas table creation statements (SQL
Scripts) will be read from the properties file and the SQL statements are
executed on the connected database automatically. Also the initial values for
some of the database tables are automatically inserted into the database.

2.3.8 Apache Tomcat 5.5 Server

Apache Tomcat is a webcontainer developed at the ApacheSoftware
Foundation(ASF). Tomcat implements the servlet and the JavaServer Pages
(JSP) specifications from SunMicrosystems, providing an environment for Java
code to run in cooperation with a webserver. It adds tools for configuration and
management but can also be configured by editing configuration files that are
normally XML-formatted. Tomcat includes its own HTTP server internally.
Environment
Tomcat is a web server that supports servlets and JSPs. The
accompanying TomcatJasper compiler compiles JSPs into servlets.The Tomcat
servlet engine is often used in combination with an Apache HTTP Server or other
web servers. Tomcat can also function as an independent web server. Earlier in
its development, the perception existed that standalone Tomcat was only suitable
for

development

environments

and

other

environments

with

minimal

requirements for speed and transaction handling. However, that perception no

longer exists; Tomcat is increasingly used as a standalone web server in hightraffic, high-availability environments. Tomcat is cross platform, running on any
operating system that has a Java Runtime Environment.

Development status
Members of the aASF and independent volunteers develop and maintain
Tomcat. Users have free access to the source code and to the binary form of
Tomcat under the Apache Licence. The initial Tomcat release appeared with
versions 3.0.x (previous releases were Sun internal releases, and were not
publicly released). Tomcat 6.8 is the latest production quality release of the 6.8
trunk (the branch for the 2.5 servlet specification), as of 2011.

Figure 2
2.3.9 Net Beans IDE:
NetBeans refers to both a platform for the development of Java desktop
applications, and an integrated development environment (IDE) developed using
the NetBeans Platform. The NetBeans Platform allows applications to be
developed from a set of modular software components called modules. A module
is a Java archive file that contains Java classes written to interact with the
NetBeans Open APIs and a manifest file that identifies it as a module.
Applications built on modules can be extended by adding new modules. Since

modules can be developed independently, applications based on the NetBeans

platform can be easily and powerfully extended by third-party developers.
The NetBeans Platform
The NetBeans Platform is a reusable framework for simplifying the
development of other desktop applications. When an application based on the
NetBeans Platform is run, the platform's Main class is executed. Available
modules are located, placed in an in-memory registry, and the modules startup
tasks are executed. Generally, a module's code is loaded into memory only as it
is needed. Applications can install modules dynamically. Any application can
include the Update Center module to allow users of the application to download
digitally signed upgrades and new features directly into the running application.
Installing an upgrade or a new release does not force users to download the
entire application again. The platform offers services common to desktop
applications, allowing developers to focus on the logic specific to their
application.
Among the features of the platform are:
User interface management (e.g. menus and toolbars)
User settings management
Storage management (saving and loading any kind of data)
Window management
Wizard framework (supports step-by-step dialogs)
The NetBeans IDE
The NetBeans IDE

is an

open source

integrated

development

environment written entirely in Java using the NetBeans Platform. NetBeans IDE
supports development of all Java application types (J2SE, web, EJB and mobile

applications) out of the box. Among other features are an Ant-based project
system, version control and refactoring. The current version is NetBeans IDE 6.1,
which was released in October
2007.
NetBeans IDE 6.1 extends the existing Java EE features (including Java
Persistence support, EJB 3 and JAX-WS). Additionally, the NetBeans Enterprise
Pack supports development of Java EE 5 enterprise applications, including SOA
visual design tools, XML schema tools, web services orchestration (for BPEL),
and UML modeling. The NetBeansC/C++ Pack supports C/C++ projects.
NetBeans IDE 6.1 builds upon the previous version 5.0, which introduced
comprehensive support for developing IDE modules and rich client applications
based on the NetBeans platform, a new GUI builder (formerly known as "Project
Matisse"), new and redesigned CVS support, Weblogic 9 and JBoss 4 support,
and many editor enhancements. Modularity: All the functions of the IDE are
provided by modules. Each module provides a well defined function, such as
support for the Java language, editing, or support for the CVS versioning system.
NetBeans contains all the modules needed for Java development in a single
download, allowing the user to start working immediately. Modules also allow
NetBeans to be extended. New features, such as support for other
programming languages, can be added by installing additional modules. For
instance, Sun Studio, Sun Java Studio Enterprise, and Sun Java Studio Creator
from Sun Microsystems are all based on the NetBeans IDE.

MY SQL SERVER
he MySQL development project has made its source code available under the
terms of the GNU General Public License, as well as under a variety of
proprietary agreements. MySQL was owned and sponsored by a single for-profit
firm, the Swedish company MySQL AB, now owned by Oracle Corporation. For
proprietary use, several paid editions are available, and offer additional

functionality. MySQL is a popular choice of database for use in web applications,

and is a central component of the widely used LAMP open-source web
application software stack (and other "AMP" stacks). LAMP is an acronym for
"Linux, Apache, MySQL, Perl/PHP/Python". Free-software open-source projects
that require a full-featured database management system often use MySQL.
On all platforms except Windows, MySQL ships with no GUI tools to administer
MySQL databases or manage data contained within the databases. Users may
use the included command line tools, or install MySQL Workbench via a separate
download. Many third party GUI tools are also available.
MySQL can be built and installed manually from source code, but it is more
commonly installed from a binary package unless special customizations are
required. On most Linux distributions, the package management system can
download and install MySQL with minimal effort, though further configuration is
often required to adjust security and optimization settings.