A
MAIN PROJECT REPORT ON
“E-FEE MASTER”
Submitted in partial fulfillment of the requirements for the award of the
Degree of
BACHELOR OF TECHNOLOGY
IN
INFORMATION TECHNOLOGY
BY
CH MAHESH KUMAR
07D31A1237
CH.GOWTHAM
07D31A1217
B.CHANDRAKANTH
07D31A1209
ARUN KUMAR MISHRA
07D31A1205
Under the guidance of
T.BENARJI
M.Tech(Ph.D)
Department of Information Technology,
INDUR INSTITUTE OF ENGINEERING & TECHNOLOGY
(Approved by AICTE)
(Affiliated to JNTUH ,Hyderabad)
PONNAL(V), Siddipet(M), Medak(Dist)-502103
Andhra Pradesh
2011
INDUR INSTITUTE OF ENGINEERING & TECHNOLOGY
(Approved by AICTE)
(Affiliated to JNTU,Hyderabad)
PONNAL(V), Siddipet(M), Medak(Dist)-502103
Andhra Pradesh.
CERTIFICATE
Certificate that dissertation entitled
“E-FEE MASTER”
Submitted by
CH MAHESH KUMAR
07D31A1237
CH.GOWTHAM
07D31A1217
B.CHANDRAKANTH
07D31A1209
ARUN KUMAR MISHRA
07D31A1205
For partial fulfillment for the award of Bachelor of Technology in Information Technology to
the Jawaharlal Nehru Technological University is a record of bona fide work carried out by
them under the guidance and supervision.
The results embodies in this dissertation have not been submitted to any other University or
Institute for the award of any degree or diploma.
Internal Guide
T.BENERJI
M.Tech (Ph .D )
Head of the Department
prof . M.BALRAJU
M.Tech(Ph.D)
ACKNOWLEDGEMENT
Determination and dedication with sincerity and hard work will lead us to the height of success.
In spite of the obstacles faced , the valuable suggestions and their best wishes helped us to
complete project “E-FEE MASTER”
success fully. As a mark of gratitude, we would like to express our heartfelt thanks to each of
them involved.
We are highly indebted to M.Balraju, Head of the department of Information
Technology for his unusual co-operation during the course of the project.
We express our gratitude and owe a special thanks to our internal guide T.Benerji for his
valuable suggestions and guidance through out the project.
We would like to express our sincere appreciation thanks to the people who have helped
us directly or indirectly in completion of the project.
Finally we take this opportunity to express our sincere thanks to our parents and friends
with out their immense and encouragement this would not have been achieved.
Thank you one and all. . . . . . . .
CONTENTS
Chapter-1.System Requirements Specification
1.1 Introduction
1.2 System Features and Module Specification
1.3 SRS (System Requirements Specification)
1.4 Organizational Profile
Chapter-2 Software Development Environment
(Literature Survey)
2.1 Introduction to Incremental Model1
2.2 Introduction to JAVA
2.3 Introduction to JDBC
2.4 Introduction to JSP
2.5 Introduction to UML
2.6
Introduction to NETBEANS
2.7 Introduction to DREAMWEAVER
Chapter-3 System Analysis
3.1 Analysis of project
3.2 Requirement gathering
3.3 Model Description
3.4 Feasibility study
Chapter-4 System Design
4.1
Design Issues
4.2
User Documentation
4.3
Introduction to UML (Rational Rose)
4. 4
UML Diagrams
Chapter-5
System Implementation
5.1
Testing
5.2
GUI screens
Chapter-6
Conclusion
Chapter-7
Bibliography
CHAPTER-1
SYSTEM REQUIRMENTS
SPECIFICATIONS
1.1
Introduction
E-fee master provides flexible fee management systems by maintaining a ledger for each student.
Student ledger will have the credit and debit transaction made by the student on a semester/
annual basis. It manages and monitors the student fee, dues, Fines and related costs. The
application provides easy to maintain functionality in the educational environment.
The system addresses the staff and students department wise. Appropriate dept staff and students
have access to functionalities in this application. The modules are accessible based on the staff
and student logged in. The administrator tracks staff and students about their fee collection and
fee paid by students respectively .
The application is an integrated fee collection system whereby it can monitor different
educational institute under one administrator. In this application different educational institutes
are first registered by the administrator, after that different employees send their request to
administrator to work under the one of the educational institute. When administrator received the
working request of employees he can assign them to educational institutes or reject them based
on their profile.
Existing system is ineffective in addressing the key issues like integrated view of students for an
administrator and fee collection of all departments are non coherent with other departments and
intimating the students about their fee details.
The student has to register with the application and he can update his details like year of
study and password.
After requesting administrator about working as employee, employee should watch for login his
account. If he successfully logged in his account it means he is authorized by administrator.
After login into his account he can update his profile and he can view students of his educational
institute, he can collect fee from the students, he can view the reports of student fee details.
Administrator has to register the appropriate colleges and he has to assign the employees for the
colleges, and he has to monitor the every college employee and college students and their fee
details and dues.
1.2 Scope
In this subsection:
(1) The system ensures the flawless communication between all personnel included in the
process
(2)Emergency situation handling was so sophisticated that we can avert any kind of
catastrophes
(3) The automatic report generation can be done this enable us to assess instantaneous
performances
1.3 Definitions, Acronyms, and Abbreviations.
AAAS (Airport authority administration system )-the system handles all the functionalities of
the airport right from flight takeoff to reaching the destination
GMS (Ground Monitoring system )-keeps an eye on all the ground processes any problem can
be easily detected and handled
1.4 References
In this subsection:
(1) www.google.com
(2) Text book-complete reference html), 2nd Edition.
1.2 System Features and Module Specification
1. Take off & Landing Scheduler
A detailed schedule is prepared for the take off and landing. Different airlines have sources
and destinations across a day. This module allows the integration of all the airlines to have
their own independent chart. The airport authority on the other hand maintains the total
schedule.
2. Parking Bay Management
The module allows the aircraft to be parked and maintained. A schedule of the bay is
provided by the operator. He identifies which aircraft is towed to the parking slot. The details
of the available parking and occupied parking are generated.
3. Staff & role maintenance
As the entities in the airport are different we need appropriate personnel to login and perform
the above tasks. The module maintains the staff.
4. Service Controller
Every aircraft is re-fuelled after a trip. This module monitors the usage of fuel and the
payment information of it. The catering unit, luggage and scheduled maintenance are scheduled
and monitored.
1.1 SRS (System Specification Requirements)
Hardware Requirements:
System
:
Pentium IV 2.4 GHZ
Hard Disk
:
40GB
Floppy Drive :
1.44MB
Monitor
: 15VGA colour
Mouse
:
Logitech
Ram
:
256MB
Software Requirements:
Operating system: Windows XP Professional
Front End
: JSP and JDBC
Coding Language: JAVA
Back End
: MySql
CHAPTER-2
SOFTWARE
DEVELOPMENT
ENVIRONMENT
(Literature survey)
2.1 Introduction to Incremental Model
 Incremental model
The incremental approach attempts to combine the waterfall sequence with some of the
advantages of prototyping. This approach is favored by many object-oriented practitioners. It
basically divides the overall project into a number of increments. Then it applies the waterfall
model to each increment. The system is put into production when the first increment is delivered.
As time passes additional increments are completed and added to the working system. This
approach is favored by many object-oriented practitioners.
Incremental Phases

Inception
During the inception phase, the purpose, business rationale, and scope of the project is
determined. This is similar to the feasibility analysis that is done in other life cycles.

Elaboration
During the elaboration phase, more detailed requirements are collected, high level
analysis is performed, and a general architecture is determined. This phase divides the
requirements into increments that can be built separately. As we will see, each increment
consists of a subset of high level use cases that capture the user's requirements.

Construction
The construction phase builds increments of the system. Each increment is developed
using a waterfall approach. This includes detailed analysis and design for the use cases in
the increment and coding and testing of the event processors that implement the sequence
of events defined by the use cases. The result is production quality software that satisfies
a subset of the requirements and is delivered to the end users. Work on different
increments may be done in parallel.

Transition
The transition phase (not shown in the figure) is the last phase in the project. This may
include such things a performance tuning and rollout to all users.
2.2 Introduction to Java
Literature survey includes the brief introduction about the programming languages being used,
any protocols used is the development of product.
STS uses the following:
JAVA technologies like
Applet
Swings
Java is an object-oriented programming language developed by Sun Microsystems in the early
1990s. Java applications are compiled to byte code, which at runtime is either interpreted or
compiled to native machine code f
or execution.
The language itself derives much of its syntax from C and C++ but has a simpler object model
and fewer low-level facilities. JavaScript, a scripting language, shares a similar name and has
similar syntax, but is not directly related to Java.
What is Applet?
An applet is a software component that runs in the context of another program, for example a
web browser. An applet usually performs a very narrow function that has no independent use.
The term was introduced in AppleScript in 1993. An applet is distinguished from "subroutine"
by several features. First, it executes only on the "client" platform environment of a system, as
contrasted from "servlet." As such, an applet provides functionality or performance beyond the
default capabilities of its container (the browser). Also, in contrast with a subroutine, certain
capabilities are restricted by the container. An applet is written in a language that is different
from the scripting or HTML language which invokes it. The applet is written in a compiled
language, while the scripting language of the container is an interpreted language, hence the
greater performance or functionality of the applet. Unlike a "subroutine," a complete web
component can be implemented as an applet.
What is Swing?
Swing is a GUI toolkit for Java. It is one part of the Java Foundation Classes (JFC).
Swing includes graphical user interface (GUI) widgets such as text boxes, buttons, split-panes,
and tables.
Swing widgets provide more sophisticated GUI components than the earlier Abstract Window
Toolkit. Since they are written in pure Java, they run the same on all platforms, unlike the AWT
which is tied to the underlying platform's windowing system. Swing supports plug
gable look and feel – not by using the native platform's facilities, but by roughly emulating them.
This means you can get any supported look and feel on any platform. The disadvantage of
lightweight components is slower execution. The advantage is uniform behavior on all platforms.
2.3 Introduction to JDBC:
JDBC:
What is JDBC?
Java Database Connectivity (JDBC) is a programming framework for Java developers writing
programs that access information stored in databases, spreadsheets, and flat files. JDBC is
commonly used to connect a user program to a "behind the scenes" database, regardless of what
database management software is used to control the database.
JDBC Architecture:
Two-tier and Three-tier Processing Models:
The JDBC API supports both two-tier and three-tier processing models for database access.
Fig-5. JDBC Two-tier Architecture
In the two-tier model, a Java applet or application talks directly to the data source. This requires
a JDBC driver that can communicate with the particular data source being accessed. A user's
commands are delivered to the database or other data source, and the results of those statements
are sent back to the user. The data source may be located on another machine to which the user is
connected via a network. This is referred to as a client/server configuration, with the user's
machine as the client, and the machine housing the data source as the server. The network can be
an intranet, which, for example, connects employees within a corporation, or it can be the
Internet.
In the three-tier model, commands are sent to a "middle tier" of services, which then sends the
commands to the data source. The data source processes the commands and sends the results
back to the middle tier, which then sends them to the user. MIS directors find the three-tier
model very attractive because the middle tier makes it possible to maintain control over access
and the kinds of updates that can be made to corporate data. Another advantage is that it
simplifies the deployment of applications. Finally, in many cases, the three-tier architecture can
provide performance advantages.
Fig-6 JDBC Three-tier Architecture
JDBC API :
The JDBC API lets you invoke SQL commands from Java programming language methods. You
use the JDBC API in an enterprise bean when you override the default container-managed
persistence or have a session bean access the database. With container-managed persistence,
database access operations are handled by the container, and your enterprise bean
implementation contains no JDBC code or SQL commands. You can also use the JDBC API
from a servlet or JSP page to access the database directly without going through an enterprise
bean.
The JDBC API has two parts: an application-level interface used by the application components
to access a database, and a service provider interface to attach a JDBC driver to the J2EE
platform.
JDBC accomplishes its goals through a set of Java interfaces, each implemented differently by
individual vendors. The set of classes that implement the JDBC interfaces for a particular
database engine is called a JDBC driver. In building a database application, you do not have to
think about the implementation of these underlying classes at all; the whole point of JDBC is to
hide the specifics of each database and let you worry about just your application. shows the
JDBC classes and interfaces.
Fig – 7 JDBC classes and interfaces.
The API interface is made up of 4 main interfaces:

java.sql DriverManager

java. sql .Connection

java. sql. Statement

java.sql.Resultset
In addition to these, the following support interfaces are also available to the developer:

java.sql.Callablestatement

java. sql. DatabaseMetaData

java.sql.Driver

java. sql. PreparedStatement

java. sql .ResultSetMetaData

java. sql. DriverPropertymfo

java.sql.Date

java.sql.Time

java. sql. Timestamp

java.sql.Types

java. sql. Numeric
Application Areas:
JDBC has been designed and implemented for use in connecting to databases. Fortunately, JDBC
has made no restrictions, over and above the standard Java security mechanisms, for complete
systems. To this end, a number of overall system configurations are feasible for accessing
databases.
1. Java application which accesses local database
2. Java applet accesses server-based database
3. Database access from an applet via a stepping stone
Using a JDBC driver:
JavaSoft has defined the following driver categorization system:
Type 1
These drivers use a bridging technology to access a database. The JDBC-ODBC
bridge that comes with the JDK 1.1 is a good example of this kind of driver. It
provides a gateway to the ODBC API. Implementations of that API in turn do the
actual database access. Bridge solutions generally require software to be installed
on client systems, meaning that they are not good solutions for applications that
do not allow you to install software on the client.
Type 2
The type 2 drivers are native API drivers. This means that the driver contains Java
code that calls native C or C++ methods provided by the individual database
vendors that perform the database access. Again, this solution requires software
on the client system.
Type 3
Type 3 drivers provide a client with a generic network API that is then translated
into database specific access at the server level. In other words, the JDBC driver
on the client uses sockets to call a middleware application on the server that
translates the client requests into an API specific to the desired driver. As it turns
out, this kind of driver is extremely flexible since it requires no code installed on
the client and a single driver can actually provide access to multiple databases.
Type 4
Using network protocols built into the database engine, type 4 drivers talk directly
to the database using Java sockets. This is the most direct pure Java solution. In
nearly every case, this type of driver will come only from the database vendor.
Regardless of data source location, platform, or driver (Oracle, Microsoft, etc.), JDBC makes
connecting to a data source less difficult by providing a collection of classes that abstract details
of the database interaction. Software engineering with JDBC is also conducive to module reuse.
Programs can easily be ported to a different infrastructure for which you have data stored
(whatever platform you choose to use in the future) with only a driver substitution.
As long as you stick with the more popular database platforms (Oracle, Informix, Microsoft,
MySQL, etc.), there is almost certainly a JDBC driver written to let your programs connect and
manipulate data. You can download a specific JDBC driver from the manufacturer of your
database management system (DBMS) or from a third party (in the case of less popular open
source products). The JDBC driver for your database will come with specific instructions to
make the class files of the driver available to the Java Virtual Machine, which your program is
going to run. JDBC drivers use Java's built-in DriverManager to open and access a database
from within your Java program.
To begin connecting to a data source, you first need to instantiate an object of your JDBC driver.
This essentially requires only one line of code, a command to the DriverManager, telling the
Java Virtual Machine to load the bytecode of your driver into memory, where its methods will be
available to your program. The String parameter below is the fully qualified class name of the
driver you are using for your platform combination:
Class.forName("org.gjt.mm.mysql.Driver").newInstance();
Connecting to a database
In order to connect to a database, you need to perform some initialization first. Your JDBC
driver has to be loaded by the Java Virtual Machine classloader, and your application needs to
check to see that the driver was successfully loaded. We'll be using the ODBC bridge driver, but
if your database vendor supplies a JDBC driver, feel free to use it instead.
To connect to the database, we create a string representation of the database. We take the name
of the datasource from the command line, and attempt to connect as user "dba", whose password
is "sql".
// Create a URL that identifies database
String url = "jdbc:odbc:" + args[0];
// Now attempt to create a database connection
Connection db_connection =
DriverManager.getConnection (url, "dba", "sql");
As you can see, connecting to a database doesn't take much code.
Executing database queries
In JDBC, we use a statement object to execute queries. A statement object is responsible for
sending the SQL statement, and returning a set of results, if needed, from the query. Statement
objects support two main types of statements - an update statement that is normally used for
operations which don't generate a response, and a query statement that returns data.
// Create a statement to send SQL
Statement db_statement = db_connection.createStatement();
Once you have an instance of a statement object, you can call its executeUpdate and
executeQuery methods. To illustrate the executeUpdate command, we'll create a table that stores
information about employees. We'll keep things simple and limit it to name and employee ID.
// Create a simple table, which stores an employee ID and name
db_statement.executeUpdate
("create table employee { int id, char(50) name };");
// Insert an employee, so the table contains data
db_statement.executeUpdate
("insert into employee values (1, 'John Doe');");
// Commit changes
db_connection.commit();
Now that there's data in the table, we can execute queries. The response to a query will be
returned by the executeQuery method as a ResultSet object. ResultSet objects store the last
response to a query for a given statement object. Instances of ResultSet have methods following
the pattern of getXX where XX is the name of a data type. Such data types include numbers
(bytes, ints, shorts, longs, doubles, big-decimals), as well as strings, booleans, timestamps and
binary data.
// Execute query
ResultSet result = db_statement.executeQuery
("select * from employee");
// While more rows exist, print them
while (result.next() )
{
// Use the getInt method to obtain emp. id
System.out.println ("ID : " + result.getInt("ID"));
// Use the getString method to obtain emp. name
System.out.println ("Name : " + result.getString("Name"));
System.out.println ();
}
2.4 Introduction to JSP:
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.
Architecture OF JSP:
Fig – 8 Architecture of JSP
What are the Advantages of JSP?

Active Server Pages (ASP). ASP is a similar technology from Microsoft. 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.

Pure Servlets. JSP doesn't give you anything that you couldn't in principle do with a
servlet. But it is more convenient to write (and to modify!) regular HTML than to have a
zillion println statements that generate the HTML. Plus, by separating the look from the
content you can put different people on different tasks: your Web page design experts can
build the HTML, leaving places for your servlet programmers to insert the dynamic
content.

Server-Side Includes (SSI). SSI is a widely-supported technology for including
externally-defined pieces into a static Web page. JSP is better because it lets you use
servlets instead of a separate program to generate that dynamic part. Besides, SSI is really
only intended for simple inclusions, not for "real" programs that use form data, make
database connections, and the like.

JavaScript. JavaScript can generate HTML dynamically on the client. This is a useful
capability, but only handles situations where the dynamic information is based on the
client's environment. With the exception of cookies, HTTP and form submission data is
not available to JavaScript. And, since it runs on the client, JavaScript can't access serverside resources like databases, catalogs, pricing information, and the like.

Static HTML. Regular HTML, of course, cannot contain dynamic information. JSP is so
easy and convenient that it is quite feasible to augment HTML pages that only benefit
marginally by the insertion of small amounts of dynamic data. Previously, the cost of
using dynamic data would preclude its use in all but the most valuable instances.
JSP syntax:

A JavaServer Page may be broken down into the following pieces:

static data such as HTML

JSP directives such as the include directive

JSP scripting elements and variables

JSP actions

custom tags with correct library

JSP directives control how the JSP compiler generates the servlet. The following
directives are available:
Include : The include directive informs the JSP compiler to include a complete file into
the current file. It is as if the contents of the included file were pasted directly into
the original file. This functionality is similar to the one provided by the C
preprocessor. Included files generally have the extension "jspf" (for JSP Fragment)
<%@ include file="somefile.jspf" %>
Page: There are several options to the page directive.
import : results in a Java import statement being inserted into the resulting file.
contentType : specifies the content that is generated. This should be used if HTML is
not used or if the character set is not the default character set.
errorPage : Indicates the page that will be shown if an exception occurs while processing the
HTTP request.
isErrorPage: If set to true, it indicates that this is the error page. Default value is false.
isThreadSafe : Indicates if the resulting servlet is thread safe.
autoFlush : To autoflush the contents.A value of true, the default, indicates that buffer should
be flushed when it is full. A value of false, rarely used, indicates that an exception should be
thrown when the buffer overflows. s will be used, and attempts to access variable session will
result in errors at the time the JSP page is translated into a servlet.
buffer :
To set Buffer Size. The default is 8k and it is advisable that you increase it.
isELIgnored : Defines whether EL expressions are ignored when the JSP is translated.
language : Defines the scripting language used in scriptlets, expressions and declarations. Right
now, the only possible value is "java".
extends : Defines the superclass of the class this JSP will become. You won't use this unless you
REALLY know what you're doing - it overrides the class hierarchy provided by the Container.
info : Defines a String that gets put into the translated page, just so that you can get it using the
generated servlet's inherited getServletInfo() method.
pageEncoding : Defines the character encoding for the JSP. The default is "ISO-8859-1"(unless
the contentType attribute already defines a character encoding, or the page uses XML document
syntax).
<%@ page import="java.util.*" %> //example import
<%@ page contentType="text/html" %> //example contentType
<%@ page isErrorPage=false %> //example for non error page
<%@ page isThreadSafe=true %> //example for a thread safe JSP
<%@ page session=true %> //example for using session binding
<%@ page autoFlush=true %> //example for setting autoFlush
<%@ page buffer=20 %> //example for setting Buffer Size
Note: Only the "import" page directive can be used multiple times in the same JSP.
taglib:
The taglib directive indicates that a JSP tag library is to be used. The directive requires that a
prefix be specified (much like a namespace in C++) and the URI for the tag library description.
<%@ taglib prefix="myprefix" uri="taglib/mytag.tld" %>
JSP scripting elements and objects:
JSP implicit objects:
The following JSP implicit objects are exposed by the JSP container and can be referenced by
the programmer:
out : The JSPWriter used to write the data to the response stream.
page : The servlet itself.
pageContext : A PageContext instance that contains data associated with the whole page. A
given HTML page may be passed among multiple JSPs.
request : The HttpServletRequest object that provides HTTP request information.
response : The HTTP response object that can be used to send data back to the client.
session : The HTTP session object that can be used to track information about a user from one
request to another.
config : Provides servlet configuration data.
application : Data shared by all JSPs and servlets in the application.
exception : Exceptions not caught by application code .
Scripting elements:
There are three basic kinds of scripting elements that allow java code to be inserted directly into
the servlet.A declaration tag places a variable definition inside body of java servlet class. Static
data members may be defined as well. Also inner classes should be defined here.
<%! int serverInstanceVariable = 1; %>
Declaration tags also allow methods to be defined.
<%!
/**
* Converts the Object into a string or if
* the Object is null, it returns the empty string.
*/
public String toStringOrBlank( Object obj ){
if(obj != null){
return obj.toString();
}
return ""; }%>
A scriptlet tag places the contained statements inside the _jspService() method of the java servlet
class.
<% int localStackBasedVariable = 1;
out.println(localStackBasedVariable); %>
An expression tag places an expression to be evaluated inside the java servlet class. Expressions
should not be terminated with a semi-colon .
<%= "expanded inline data " + 1 %>
Also we can use the following tag to give comments in jsp:
<%-- give your comments here --%>
JSP actions:
JSP actions are XML tags that invoke built-in web server functionality. They are executed at
runtime. Some are standard and some are custom (which are developed by Java developers). The
following list contains the standard ones:
jsp:include : Similar to a subroutine, the Java servlet temporarily hands the request and response
off to the specified JavaServer Page. Control will then return to the current JSP, once the other
JSP has finished. Using this, JSP code will be shared between multiple other JSPs, rather than
duplicated.
jsp:param: Can be used inside a jsp:include, jsp:forward or jsp:params block. Specifies a
parameter that will be added to the request's current parameters.
jsp:forward: Used to hand off the request and response to another JSP or servlet. Control will
never return to the current JSP.
jsp:plugin: Older versions of Netscape Navigator and Internet Explorer used different tags to
embed an applet. This action generates the browser specific tag needed to include an applet.
jsp:fallback: The content to show if the browser does not support applets.
jsp:getProperty: Gets a property from the specified JavaBean.
jsp:setProperty: Sets a property in the specified JavaBean.
jsp:useBean: Creates or re-uses a JavaBean available to the JSP page. The scope attribute can be
request, page, session or application. It has the following meanings:
request : The attribute is available for the lifetime of the request. Once the request has been
processed by all of the JSPs, the attribute will be de-referenced.
page : the attribute is available for the current page only.
session : The attribute is available for the lifetime of the user's session.
application : The attribute is available to every instance and is never de-referenced. Same as a
global variable: The example above will use a Bean Manager to create an instance of the class
com.foo.MyBean and store the instance in the attribute named "myBean". The attribute will be
available for the life-time of the request. It can be shared among all of the JSPs that were
included or forwarded-to from the main JSP that first received the request.
JSP Tag Libraries:
In addition to the pre-defined JSP actions, developers may add their own custom actions using
the JSP Tag Extension API. Developers write a Java class that implements one of the Tag
interfaces and provide a tag library XML description file that specifies the tags and the java
classes that implement the tags.
Consider the following JSP.
<%@ taglib uri="mytaglib.tld" prefix="myprefix" %>...
<myprefix:myaction> <%-- the start tag %>...
</myprefix:myaction> <%-- the end tag %>...
The JSP compiler will load the mytaglib.tld XML file and see that the tag 'myaction' is
implemented by the java class 'MyActionTag'. The first time the tag is used in the file, it will
create an instance of 'MyActionTag'. Then (and each additional time that the tag is used), it will
invoke the method doStartTag() when it encounters the starting tag. It looks at the result of the
start tag, and determines how to process the body of the tag. The body is the text between the
start tag and the end tag. The doStartTag() method may return one of the following:
SKIP_BODY
The body between the tag is not processed.
EVAL_BODY_INCLUDE
Evaluate the body of the tag.
EVAL_BODY_TAG
Evaluate the body of the tag and push the result onto stream (stored in the body content property
of the tag).
Note: If tag extends the BodyTagSupport class, the method doAfterBody() will be called when
the body has been processed just prior to calling the doEndTag(). This method is used to
implement looping constructs.
When it encounters the end tag, it invokes the doEndTag() method. The method may return one
of two values:
EVAL_PAGE
This indicates that the rest of the JSP file should be processed.
SKIP_PAGE
This indicates that no further processing should be done. Control leaves the JSP page. This is
what is used for the forwarding action.
JSP Standard Tag Library (JSTL):
The JavaServer Pages Standard Tag Library (JSTL), is a component of the Java EE Web
application development platform. It extends the JSP specification by adding a tag library of JSP
tags for common tasks, such as XML data processing, conditional execution, loops and
internationalization.
Java Servlet Technology :
Java Servlet technology lets you define HTTP-specific servlet classes. A servlet class extends the
capabilities of servers that host applications accessed by way of a request-response programming
model. Although servlets can respond to any type of request, they are commonly used to extend
the applications hosted by Web servers.
Java Server Pages Technology :
JavaServer Pages technology lets you put snippets of servlet code directly into a text-based
document. A JSP page is a text-based document that contains two types of text: static template
data, which can be expressed in any text-based format such as HTML, WML, and XML, and JSP
elements, which determine how the page constructs dynamic content.
2.5 Introduction to UML
In the field of software engineering, the Unified Modeling Language (UML) is a standardized
specification language for object modeling. UML is a general-purpose modeling language that
includes a graphical notation used to create an abstract model of a system, referred to as a UML
model.UML is officially defined at the Object Management Group (OMG) by the UML meta
model, a Meta-Object Facility meta model (MOF). Like other MOF-based specifications, the
UML meta model and UML models may be serialized in XMI. UML was designed to specify,
visualize, construct, and document software-intensive systems.
UML is not restricted to modeling software. UML is also used for business process modeling,
systems engineering modeling, and representing organizational structures. The Systems
Modeling Language (SysML) is a Domain-Specific Modeling language for systems engineering
that is defined as a UML 2.0 profile.
UML has been a catalyst for the evolution of model-driven technologies, which include Model
Driven Development (MDD), Model Driven Engineering (MDE), and Model Driven
Architecture (MDA). By establishing an industry consensus on a graphic notation to represent
common concepts like classes, components, generalization, aggregation, and behaviors, UML
has allowed software developers to concentrate more on design and architecture.
UML models may be automatically transformed to other representations (e.g. Java) by means of
QVT-like transformation languages, supported by the OMG.UML is extensible, offering the
following mechanisms for customization: profiles and stereotype. The semantics of extension by
profiles has been improved with the UML 2.0 major revision.
2.6 NETBEANS
NetBeans refers to both a platform framework for Java desktop applications, and an integrated
development environment (IDE) for developing with Java, JavaScript, PHP, Python, Ruby,
Groovy, C, C++, Scala, Clojure, and others.
The NetBeans IDE is written in Java and can run anywhere a JVM is installed, including
Windows, Mac OS, Linux, and Solaris. A JDK is required for Java development functionality,
but is not required for development in other programming languages.
The NetBeans Platform allows applications to be developed from a set of modular software
components called modules. Applications based on the NetBeans platform (including the
NetBeans IDE) can be extended by third party developers.[1]
Early history
NetBeans began in 1996 as Xelfi (word play on Delphi),[3][4] a Java IDE student project under the
guidance of the Faculty of Mathematics and Physics at Charles University in Prague. In 1997
Roman Staněk formed a company around the project and produced commercial versions of the
NetBeans IDE until it was bought by Sun Microsystems in 1999. Sun open-sourced the
NetBeans IDE in June of the following year. Since then, the NetBeans community has continued
to grow.[5]
[edit] Current versions
NetBeans IDE 6.0 introduced support for developing IDE modules and rich client applications
based on the NetBeans platform, a Java Swing GUI builder (formerly known as "Project
Matisse"), improved CVS support, WebLogic 9 and JBoss 4 support, and many editor
enhancements. NetBeans 6 is available in official repositories of major Linux distributions.
NetBeans IDE 6.5, released in November 2008, extended 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
NetBeans IDE Bundle for C/C++ supports C/C++ development.
The NetBeans IDE 6.8 is the first IDE to provide complete support of Java EE 6 and the
GlassFish Enterprise Server v3. Developers hosting their open-source projects on kenai.com
additionally benefit from instant messaging and issue tracking integration and navigation right in
the IDE, support for web application development with PHP 5.3 and the Symfony framework,
and improved code completion, layouting, hints and navigation in JavaFX projects.
NetBeans IDE 6.9, released in June 2010, added support for OSGi, Spring Framework 3.0, Java
EE dependency injection (JSR-299), Zend Framework for PHP, and easier code navigation (such
as "Is Overridden/Implemented" annotations), formatting, hints, and refactoring across several
languages.
NetBeans Platform
The NetBeans Platform is a reusable framework for simplifying the development of Java Swing
desktop applications. The NetBeans IDE bundle for Java SE contains what is needed to start
developing NetBeans plugins and NetBeans Platform based applications; no additional SDK is
required.
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. Reinstalling an upgrade or a new release does not force
users to download the entire application again.
The platform offers reusable 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)

NetBeans Visual Library

Integrated Development Tools
NetBeans IDE Bundle for Web & Java EE
The NetBeans IDE Bundle for Web & Java EE[11] provides complete tools for all the latest
Java EE 6 standards, including the new Java EE 6 Web Profile, Enterprise Java Beans (EJBs),
servlets, Java Persistence API, web services, and annotations. NetBeans also supports the JSF 2.0
(Facelets), JavaServer Pages (JSP), Hibernate, Spring, and Struts frameworks, and the Java EE 5
and J2EE 1.4 platforms. It includes GlassFish and Apache Tomcat.
NetBeans IDE Complete Bundle:
Sun Microsystems also releases a version of NetBeans that includes all of the features of the
above bundles. This bundle includes:

NetBeans Base IDE

Java SE, JavaFX

Web & Java EE

Java ME

Ruby

C/C++

PHP (Version 6.5 and later)

GlassFish

Apache Tomcat
NetBeans IDE
The NetBeans IDE is an open-source integrated development environment. NetBeans IDE
supports development of all Java application types (Java SE including JavaFX, (Java ME, web,
EJB and mobile applications) out of the box. Among other features are an Ant-based project
system, Maven support, refactorings, version control (supporting CVS, Subversion, Mercurial
and Clearcase).
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, and SVN. 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.
License: From July 2006 through 2007, NetBeans IDE was licensed under Sun's Common
Development and Distribution License (CDDL), a license based on the Mozilla Public License
(MPL). In October 2007, Sun announced that NetBeans would henceforth be offered under a
dual license of the CDDL and the GPL version 2 licenses, with the GPL linking exception for
GNU Classpath
Integrated modules
These modules are part of the NetBeans IDE.
NetBeans Profiler
The NetBeans Profiler is a tool for the monitoring of Java applications: It helps developers find
memory leaks and optimize speed. Formerly downloaded separately, it is integrated into the core
IDE since version 6.0.
The Profiler is based on a Sun Laboratories research project that was named JFluid. That
research uncovered specific techniques that can be used to lower the overhead of profiling a Java
application. One of those techniques is dynamic bytecode instrumentation, which is particularly
useful for profiling large Java applications. Using dynamic bytecode instrumentation and
additional algorithms, the NetBeans Profiler is able to obtain runtime information on applications
that are too large or complex for other profilers. NetBeans also support Profiling Points that let
you profile precise points of execution and measure execution time.
GUI design tool
Formerly known as project Matisse, the GUI design-tool enables developers to prototype and
design Swing GUIs by dragging and positioning GUI component
The GUI builder also has built-in support for JSR 296 (Swing Application Framework), and JSR
295 (Beans Binding technology).
NetBeans JavaScript editor
The NetBeans JavaScript editor provides extended support for JavaScript, Ajax, and CSS.
JavaScript editor features comprise syntax highlighting, refactoring, code completion for native
objects and functions, generation of JavaScript class skeletons, generation of Ajax callbacks
from a template; and automatic browser compatibility checks.
CSS editor features comprise code completion for styles names, quick navigation through the
navigator panel, displaying the CSS rule declaration in a List View and file structure in a Tree
View, sorting the outline view by name, type or declaration order (List & Tree), creating rule
declarations (Tree only), refactoring a part of a rule name (Tree only).
2.7 INTRODUCTION TO HTML
HTML, or HyperText Markup Language is designed to specify the logical organisation of
adocument, with important hypertext extensions. It is not designed to be the language of a
WYSIWYG word processor such as Word or WordPerfect. This choice was made because the
same HTML document may be viewed by many different "browsers", of very different abilities.
Thus, for example, HTML allows you to mark selections of text as titles or paragraphs, and then
leaves the interpretation of these marked elements up to the browser. For example one browser
may indent the beginning of a paragraph, while another may only leave a blank line.
HTML instructions divide the text of a document into blocks called elements. These can be
divided into two broad categories -- those that define how the BODY of the document is to be
displayed by the browser, and those that define information `about' the document, such as the
title or relationships to other documents. The vocabulary of these elements and a description of
the overall design of HTML documents is given in the rest of Section 2. The Last part of the
section also describes standard naming schemes for HTML documents and related files.
The detailed rules for HTML (the names of the tags/elements, how they can be used) are defined
using another language known as the standard generalized markup language, or SGML. SGML
is wickedly difficult, and was designed for massive document collections, such as repair manuals
for F-16 fighters, or maintenance plans for nuclear submarines. Fortunately, HTML is much
simpler!
However, SGML has useful features that HTML lacks. For this reason, markup language and
software experts have developed a new language, called XML (the eXtensible markup language)
which has most of the most useful features of HTML and SGML.
URL: Uniform Resource Locator
If you watch television, read magazines and newspapers, or receive mail at your home, you have
probably seen a "URL" (uniform resource locator). When someone has information they want
you to access via the Web, they'll give you its electronic address, its URL. URLs are unique to
each document and are a relatively easy way to navigate between the millions of online
documents.
Knowing a documents URL allows you to go directly to it; from most browsers you can go to the
tool bar and click on the "open" button or go to the "File" menu and choose the option "Open
URL" or "Open file". Regardless of which method you choose, a box will appear on your screen
where you can enter the URL of the information you wish to access.
For example, to access information on using a web conferencing system called NetForum , I
would provide its URL:
http://www.biostat.wisc.edu/nf_home/
You would then enter this in its entirety and click on "open." Be sure to enter a URL exactly as it
appears since they are case sensitive.
In this tutorial, we show you how to add links to other Web pages from your own home page.
Methods of preparing an HTML document
There are several ways an HTML document can be prepared:
use an HTML editor such as HTML Assistant (used in this class; basic HTML tags are
already built in and you select the text and just point and click on the desired tag located on the
tool bar)
use an HTML editor provided in your Word Processor (Microsoft Internet Assisstant for Word
for Windows 6.0)
create an ASCII text file (using a text editor such as TED, BBEdit, DOS edit, or any word
processor that can save ASCII text)
convert a Rich Text Format (RTF) file to HTML (most word processors give you an option of
saving a file as RTF).
There are dozens of HTML editors and converters available, both free and commercial. Our
philosophy is that no matter how good the HTML editor or converter, you'll have to do some
tweaking at some time, so knowing what all the HTML tags mean is important. We make no
recommendations on editors, but we will mention that Netscape Gold comes with its own editor
and many word processors are now coming "HTML ready" (ie, have mechanisms for adding
tags).
Regardless of what editor you use, most of them have a toolbar with the different tags available
and you select your text and then point and click on the appropriate tag.
HTML file extensions and the source document
When naming HTML files, keep in mind that some clients require your file name to have a
".html" extension (for DOS/Windows users, this is a ".htm" extension). To be safe, all HTML
files you create should use the ".html" naming convention.
You can view the HTML tags for any HTML document by looking at the "source" document that
contains the HTML tags, usually called "View Source" or "View Document Source" from the
"View" menu on most clients. Using this option is a nice way to learn new things as well as
refresh your memory when working with HTML tags.
The HTML tag
Although not currently required by all clients, the <html> tag signals the point where text should
start being interpreted as HTML code. It's probably a good idea to include it in all your
documents now, so you don't have to go back to your files and add it later.
The <html> tag is usually placed on the first line of your document. At the end of your document
you should close with the </html> tag.
The head tag
Just like the header of a memo, the head of an HTML document contains special information,
like its title. The head of a document is demarcated by <head> and </head> respectively.For the
purposes of this class, only the title tag, below, should be included in the document head. A
typical head section might look like
<html>
<head>
<title>My First HTML Document</title>
</head>
Titles
A title tag allows you to specify a Document Title in your browser window. When people make
hotlists, this title is what they see in their list after they add your document. The format is:
<title>My First HTML Document</title>
Remember, the title usually doesn't appear in the document itself, but in a title box or bar at the
top of the window.
The body tag
Like you might expect, the body tags <body> and </body> define the beginning and end of the
bulk of your document. All your text, images, and links will be in the body of the document.
The body should start after the head. A typical page might begin like
<html>
<head>
<title>My First HTML Document</title>
</head>
<body>
2.8 DREAMWEAVER
Adobe Dreamweaver (formerly Macromedia Dreamweaver) is a web development
application originally created by Macromedia, and is now developed by Adobe Systems, which
acquired Macromedia in 2005.
Dreamweaver is available for both Mac and Windows operating systems. Recent versions have
incorporated support for web technologies such as CSS, JavaScript, and various server-side
scripting languages and frameworks including ASP, ColdFusion, and PHP.
Features
Dreamweaver allows users to preview websites in locally installed web browsers. It provides
transfer and synchronization features, the ability to find and replace lines of text or code by
search terms and regular expressions across the entire site, and a templating feature that allows
single-source update of shared code and layout across entire sites without server-side includes or
scripting. The behaviours panel also enables use of basic JavaScript without any coding
knowledge, and integration with Adobe's Spry Ajax framework offers easy access to
dynamically-generated content and interfaces.
Dreamweaver can use third-party "Extensions" to extend core functionality of the application,
which any web developer can write (largely in HTML and JavaScript). Dreamweaver is
supported by a large community of extension developers who make extensions available (both
commercial and free) for most web development tasks from simple rollover effects to fullfeatured shopping carts.
Dreamweaver, like other HTML editors, edits files locally then uploads them to the remote web
server using FTP, SFTP, or WebDAV. Dreamweaver CS4 now supports the Subversion (SVN)
version control system.
Syntax highlighting
As of version 6, Dreamweaver supports syntax highlighting for the following languages out of
the box:

ActionScript

Active Server Pages (ASP).

ASP.NET (no longer supported as of version CS4 http://kb2.adobe.com/cps/402/kb402489.html)

C#

Cascading Style Sheets (CSS)

ColdFusion

EDML

Extensible HyperText Markup Language (XHTML)

Extensible Markup Language (XML)

Extensible Stylesheet Language Transformations (XSLT)

HyperText Markup Language (HTML)

Java

JavaScript

JavaServer Pages (JSP) (no longer supported as of version CS4 http://kb2.adobe.com/cps/402/kb402489.html)

PHP: Hypertext Preprocessor (PHP)

Visual Basic (VB)

Visual Basic Script Edition (VBScript)

Wireless Markup Language (WML)
It is also possible to add your own language syntax highlighting. In addition, code completion is
available for many of these languages.
Internationalization and localization
Language availability
Adobe Dreamweaver CS5 is available in the following languages: Brazilian Portuguese, Chinese
Simplified, Chinese Traditional, Czech, Dutch, English, French, German, Italian, Japanese,
Korean, Polish, Russian, Spanish Swedish and Turkish.
Specific Features for Arabic and Hebrew languages
The older Adobe Dreamweaver CS3 also features a Middle Eastern version that allows typing
Arabic, Persian or Hebrew text (written from right to left) within the code view. Whether the text
is fully Middle Eastern (written from right to left) or includes both English and Middle Eastern
text (written left to right and right to left), it will be displayed properly in the browser.
CHAPTER-3
SYSTEM
ANALYSIS
3.1 Analysis of project
Now a day the usage of credit cards has dramatically increased. As credit card becomes the most
popular mode of payment for both online as well as regular purchase, cases of fraud associated
with it are also rising. In this paper, we model the sequence of operations in credit card
transaction processing using a Hidden Markov Model (HMM) and show how it can be used for
the detection of frauds. An HMM is initially trained with the normal behavior of a card holder. If
an incoming credit card transaction is not accepted by the trained HMM with sufficiently high
probability, it is consider to the fraudulent. At the same time, we try to ensure that genuine
transactions are not rejected. We present detailed experimental results to show the effectiveness
of our approach and compare it with other techniques available in the literature.
EXISTING SYSTEM:
The system addresses the staff department wise. Appropriate dept staff has access to
functionalities in this application. The modules are accessible based on the staff logged in. The
administrator tracks staff, schedules, parking bay information, traffic flow (landing & takeoff)
Existing system effectively performs the tasks like staff management ,scheduling management,
parking bay management, traffic flow etc and usage of fuel.
PROPOSED SYSTEM:
Malfunctioning can lead to severe life and property loss especially in the systems like flight
monitoring system . The proposed system imbibes all the tasks of the existing system. But
attempt was made to give the instantaneous report to the respective departments .
this was implemented by continuously monitoring the tasks which is achieved by advanced
ground monitoring system. Effective steps were taken to manage the critical situtations
ADVANTAGES
1. The detection of the fraud use of the card is found much faster that the existing system.
2. In case of the existing system even the original card holder is also checked for fraud
detection. But in this system no need to check the original user as we maintain a log.
3. The log which is maintained will also be a proof for the bank for the transaction made.
4. We can find the most accurate detection using this technique.
5. This reduce the tedious work of an employee in the bank.
3.4
Feasibility Study
The most important thing in the software engineering is the feasibility study. It is a study of the
applicability or practicability of a proposed action or plan. It determines if the information
system makes STS for the organization from an economic and operational standpoint. It is a
detailed investigation and analysis of a proposed development project to determine whether it is
viable technically and economically.
It has been defined as a study designed to determine if the system proposed would be feasible or
not, system analysis is performed basis on the policies and plans of the steering committees on
the requirement. Once the problem is clearly understood the next step is to conduct feasibility
study which is a high level capsule version of the system analysis and design process.
Feasibility study is categorized as follows:
Economic feasibility
Technical feasibility
Operational feasibility
1. Economical feasibility
Economic analysis more commonly known as cost/benefit analysis is used to measure the
effectiveness of the proposed system. In economic feasibility study we determine things such as
whether the cost of establishing the proposed system is more than that incurred in maintaining
the present system, benefits and saving associated with the system are identified and analyzed. If
benefits outweigh cost, then the steps are taken for the further development of system.
Otherwise, revisions and alterations are done in the proposed system to make it economically
feasible.
STS is economically feasible in following ways:
The cost of developing and deploying STS is very low.
STS is developed using open source technology and results in low developing cost.
STS is platform independent and the user of STS does not need to invest huge amount on
purchasing the licensed versions.
As STS is a general architecture which can be accustomed on any domain very easily hence
reduces the installation charges also as only a little or no modifications are to be done to STS
while deploying on various domains.
2. Technical feasibility
Technical feasibility focuses on the extent of the reusability of the existing system in the
proposed system, including hardware, software etc. it is the study whether reliable hardware and
software, technical resources capable of meeting the needs of a proposed system can be acquired
or developed by an organization in the required time.
STS is technically feasible in following ways:
STS is technically feasible because each module in STS can be deployed individually.
STS can be reused efficiently and effectively.
3. Operational Feasibility
Proposed system is beneficial only if they can be turned into information system that will meet
the organizations operating system. Operational feasibility is defined as the process of assessing
the degree to which a proposed system solves business problems or takes advantage of business
opportunities. The key issue that arises here is that whether the employees need any training
before shifting to the proposed system.
STS is easy to use as no special training is needed to use it. STS is a GUI application and is
highly user friendly. Also, no need to recruit any special staff to maintain STS, besides STS
provides an inbuilt help file which can be understood at ease.
CHAPTER-4
SYSTEM ANALYSIS
Introduction to Web Application Development (Tomcat):
With J Builder, you can build and deploy server-side Java applications that deliver dynamically
generated HTML to any client running a browser.
TOMCAT :
Apache Tomcat is a web container, or application server developed at the Apache Software
Foundation (ASF). Tomcat implements the Java Servlet and the JavaServer Pages (JSP)
specifications from Sun Microsystems, providing an environment for Java code to run in
cooperation with a web server. 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 internal HTTP server.
An overview of the different versions can be found on the Apache website.
Tomcat 3.x (initial release)
Tomcat 4.x

implements the Servlet 2.3 and JSP 1.2 specifications

servlet container redesigned as Catalina

JSP engine redesigned as Jasper

Coyote HTTP connector

Java Management Extensions (JMX), JSP and Struts-based administration
Tomcat 5.x

implements the Servlet 2.4 and JSP 2.0 specifications

reduced garbage collection, improved performance and scalability

native Windows and Unix wrappers for platform integration

faster JSP parsing
Tomcat 6.x

implements the Servlet 2.5 and JSP 2.1 specifications

support for Unified Expression Language 2.1

designed to run on Java SE 5.0 and later

support for Comet through the CometProcessor interface
History
Tomcat started off as a servlet reference implementation by James Duncan Davidson, a software
architect at Sun Microsystems. He later helped make the project open source and played a key
role in its donation by Sun to the Apache Software Foundation. The Apache Ant software build
automation tool was developed as a side-effect of the creation of Tomcat as an open source
project.
Davidson had initially hoped that the project would become open sourced and, since most open
source projects had O'Reilly books associated with them featuring an animal on the cover, he
wanted to name the project after an animal.[3] He came up with Tomcat since he reasoned the
animal represented something that could fend for itself. Although the tomcat was already in use
for another O'Reilly title, his wish to see an animal cover eventually came true when O'Reilly
published their Tomcat book with a snow leopard on the cover
Configuring & Using Apache Tomcat 6
A Tutorial on Installing and Using
Jakarta Tomcat for Servlet and JSP Development
Following is a guide to installing and configuring Apache Tomcat 6 for use as a standalone Web
server (for development) that supports servlets 2.5 and JSP 2.1. (Note: Apache Tomcat is
sometimes referred to as "Jakarta Tomcat" since the Apache Java effort is known as "The
Jakarta Project"). This Tomcat tutorial covers version 6.0.10, but the steps are almost the same
for any Tomcat 6.0.x version. For coverage of Tomcat 5.5, see the separate Tomcat 5.5 tutorial.
For coverage of very old Tomcat versions (Tomcat 5.0.x and Tomcat 4.0.x), please see the
Apache Tomcat 5.0 and 4.0 tutorial.
Using Tomcat as a deployment server or integrating Tomcat as a plugin within the regular
Apache server or a commercial Web server is more complicated than what is described in this
tutorial. Although such integration is valuable for a deployment scenario (see
http://tomcat.apache.org/tomcat-6.0-doc/), my goal here is to show how to use Tomcat as a
development server on your desktop. Regardless of what deployment server you use, you'll want
a standalone server on your desktop to use for development.
The examples here assume you are using Windows, but they can be easily adapted for MacOS,
Linux, Solaris, and other versions of Unix. Except when I refer to specific Windows paths (e.g.,
C:\blah\blah), I use URL-style forward slashes for path separators (e.g.,
install_dir/webapps/ROOT). Adapt as necessary.
Details of each step are given below. If Tomcat is already running, restart it after performing
these steps.
Download the Apache Tomcat Software:
Go to http://tomcat.apache.org/download-60.cgi and download and unpack the zip file for the
current release build of Tomcat 6. You specify the top-level directory (e.g., C:\) and the zip file
has embedded subdirectories (e.g., apache-tomcat-6.0.10). Thus, C:\apache-tomcat-6.0.10 is a
common resultant installation directory. Note: from this point forward, I'll refer to that location
as install_dir. For Windows, there is also a .exe installer; I prefer the .zip file, but see the .exe
installer section for notes on the differences between the two.
Alternatively, you can use my preconfigured Jakarta Tomcat version. This version already has
the port changed to 80, servlet reloading enabled, and the invoker servlet turned on. It also comes
with a sample development directory, autoexec.bat file, startup/shutdown shortcuts, and
shortcuts for deploying applications.
Set the JAVA_HOME Variable:
Next, you must set the JAVA_HOME environment variable to tell Tomcat where to find Java.
Failing to properly set this variable prevents Tomcat from compiling JSP pages. This variable
should list the base JDK installation directory, not the bin subdirectory. For example, on almost
any version of Windows, if you use JDK 1.5_08, you might put the following line in your
C:\autoexec.bat file.
set JAVA_HOME=C:\Program Files\Java\jdk1.5.0_08
On Windows XP, you could also go to the Start menu, select Control Panel, choose System, click
on the advanced tab, press the Environment Variables button at the bottom, and enter the
JAVA_HOME
variable and value directly. On Windows 2000 and NT, you do Start, Settings,
Control Panel, System, then Environment. However, you can use C:\autoexec.bat on those
versions of Windows also (unless a system administrator h as set your PC to ignore it).
Change the Port to 80:
Assuming you have no other server already running on port 80, you'll find it convenient to
configure Tomcat to run on the default HTTP port (80) instead of the out-of-the-box port of
8080. Making this change lets you use URLs of the form http://localhost/blah instead of
http://localhost:8080/blah. Note that you need admin privileges to make this change on
Unix/Linux. Also note that some versions of Windows XP automatically start IIS on port 80. So,
if you use XP and want to use port 80 for Tomcat, you may need to disable IIS (see the
Administrative Tools section of the Control Panel).
To change the port, edit install_dir/conf/server.xml and change the port attribute of the
Connector
element from 8080 to 80, yielding a result similar to that below.
<Connector port="80" ...
maxThreads="150" ...
You can also:

Use my preconfigured Jakarta Tomcat version. Apache Tomcat 6.0.10 with all
server.xml, context.xml, and web.xml changes, plus the sample HTML, JSP, and Java
files.

Download my modified server.xml for Tomcat 6.0. From Apache Tomcat 6.0.10, but
should work on most versions of Tomcat 6.0. Right-click or shift-click on the link to
download the file.
Turn on Servlet Reloading:
The next step is to tell Tomcat to check the modification dates of the class files of requested
servlets, and reload ones that have changed since they were loaded into the server's memory.
This slightly degrades performance in deployment situations, so is turned off by default.
However, if you fail to turn it on for your development server, you'll have to restart the server
every time you recompile a servlet that has already been loaded into the server's memory. Since
this tutorial discusses the use of Tomcat for development, this change is strongly recommended.
To turn on servlet reloading, edit Edit install_dir/conf/context.xml and change
<Context>
to
<Context reloadable="true" privileged="true">
Note that the privileged entry is really to support the invoker servlet (see the following
section), so you can omit that entry if you do not use the invoker.
You can also:

Use my preconfigured Tomcat version. Tomcat 6.0.10 with all server.xml, context.xml,
and web.xml changes, plus the sample HTML, JSP, and Java files.

Download my modified context.xml for Tomcat 6.0. From Tomcat 6.0.10, but should
work on most versions of Tomcat 6.0. Right-click or shift-click on the link to download
the file.
Enable the Invoker Servlet:
The invoker servlet lets you run servlets without first making changes to your Web application's
deployment descriptor (i.e., the WEB-INF/web.xml file). Instead, you just drop your servlet into
WEB-INF/classes and use the URL http://host/servlet/ServletName (or
http://host/webAppName/servlet/ServletName once you start using your own Web applications.
The invoker servlet is extremely convenient when you are learning and even when you are
testing things doing your initial development. You almost certainly want to enable it when
learning, but you should disable it again before deploying any real applications.
In Tomcat 6 (but not Tomcat 5.5), you also need the privileged="true" entry in the Context
element of context.xml. See the previous section for an example.
You can also:

Use my preconfigured Tomcat version. Tomcat 6.0 with all server.xml, context.xml, and
web.xml changes, plus the sample HTML, JSP, and Java files.

Download my modified web.xml for Tomcat 6.0. From Tomcat 6.0.10, but should work
on most versions of Tomcat 6.0. Right-click or shift-click on the link to download the
file.
Turn on Directory Listings (Optional)
In previous Tomcat versions, if you entered a URL ending in a slash (/) and there was no
welcome-file in the directory (or servlet-mapping that matched the URL), Tomcat displayed a
directory listing. In Tomcat 6, the default was changed from true to false for these directory
listings. Many developers find it convenient to turn directory listings back on. To make this
change, edit install_dir/conf/web.xml and change the init-param value of listings for the default
servlet, as below. Do not confuse this Apache Tomcat-specific web.xml file with the standard
one that goes in the WEB-INF directory of each Web application.
4.3 Introduction to UML
The unified modeling language allows the software engineer to express an analysis model using
the modeling notation that is governed by a set of syntactic semantic and pragmatic rules.
A UML system is represented using five different views that describe the system from
distinctly different perspective. Each view is defined by a set of diagram ,which is as follows.
User model view

. this view represents the system from the users perspective.

The analysis representation describes a usage scenario from the end-users perspective.
Structural model view

In this model the data and functionality are arrived from inside the system.

This view models the static structures.
Behavioral model view

It represents the dynamic of behavioral as part of the system, depicting the interactions of
collection between various structural elements described in the user
model and structural model view.
Implementation model view

In this the structural and behavioral as part of the system are represented as they are to be
built.
Environmental model view

In this the structural and behavioral aspects of the environment in which the system is to
be implemented are to be represented.

UML is specifically constructed through two different domains they are

UML Analysis the modeling, which focuses on the user model and structural model
views of the system?

UML design modeling, which focuses on the behavioral modeling, implementation
modeling and environmental model views.

Use Case Diagrams represents the functionality of the system from a user’s point of view.
UseCases are used during requirements elicitation and analysis to represent the
Functionality of the system.

UseCase focus on the system from external point of view.

Actors are external entities that interact with the system. Examples of actors include users
like administrator, bank customer…..etc., or another system like central database
Rational Rose
Rational Rose is an object-oriented Unified Modeling Language (UML) software design tool
intended for visual modeling and component construction of enterprise-level software
applications. In much the same way a theatrical director blocks out a play, a software designer
uses Rational Rose to visually create (model) the framework for an application by blocking out
classes with actors (stick figures), use case elements (ovals), objects (rectangles) and
messages/relationships (arrows) in a sequence diagram using drag-and-drop symbols. Rational
Rose documents the diagram as it is being constructed and then generates code in the designer's
choice of C++, Visual Basic, Java, Oracle8, CORBA or Data Definition Language.
Two popular features of Rational Rose are its ability to provide iterative development and roundtrip engineering. Rational Rose allows designers to take advantage of iterative development
(sometimes called evolutionary development) because the new application can be created in
stages with the output of one iteration becoming the input to the next. (This is in contrast to
waterfall development where the whole project is completed from start to finish before a user
gets to try it out.) Then, as the developer begins to understand how the components interact and
makes modifications in the design, Rational Rose can perform what is called "round-trip
engineering" by going back and updating the rest of the model to ensure the code remains
consistent.
Rational Rose is extensible, with downloadable add-ins and third-party partner applications. It
supports COM/DCOM (ActiveX), JavaBeans, and Corba component standards.
UML DIAGRAMS
USE-CASE SPECIFICATION FILE FOR USER-BANK USE CASE
Precondition:
The person should be an authorized person.
Main flow:
Enter the user-id.
Enter the password.
User logins into the bank to open an account inorder to attain the creditcard
Submit (E1).
Post condition:
If the user-id and password are correct then the person is allowed to access the system
USE-CASE SPECIFICATION FILE FOR USER-BANK USE CASE
Precondition:
Main flow:
The person must set the security questions and must answer it while the transaction is under
process and he can update the questions when required.If the user wants to know the history of
his trancastion done the bank will provide the history.
Submit (E1).
Alternate flow:
E1: Re-enter the filename.
Post condition:
A crc file is generated.
CHAPTER-5
SYSTEM
IMPLEMENTATION
5.1 TESTING:
TESTING OBJECTIVES :

Testing is a process of executing a program with the intent of finding an error.

A good test has a high probability of finding an as yet undiscovered error.

A successful test is one that uncovers an as yet undiscovered error
The objective is to design tests that systematically uncover different classes of errors and do
so with a minimum amount of time and effort. Testing cannot show the absence of defects, it
can only show that software defects are present.
UNIT TESTING:
Interface
Number of input parameters should be equal to number of arguments.
Parameter and argument attributes must match.
Parameters passed should be in correct order.
Global variable definitions consistent across module.
If module does I/O,

File attributes should be correct.

Open/Close statements must be correct.

Format specifications should match I/O statements.

Buffer Size should match record size.

Files should be opened before use.

End of file condition should be handled.

I/O errors should be handled.

Any textual errors in output information must be checked.
Local Data Structures (common source of errors!)

Improper or inconsistent typing.

Erroneous initialization or default values.

Incorrect variable names.

Inconsistent date types.

Overflow, underflow, address exceptions.
Boundary conditions and Independent paths
Error Handling

Error description unintelligible.

Error noted does not correspond to error encountered.

Error condition handled by system run-time before error handler gets control.

Exception condition processing incorrect.
INTEGRATION TESTING:
TOP DOWN INTEGRATION :
Modules integrated by moving down the program design hierarchy. Can use depth first or
breadth first top down integration
Verifies major control and decision points early in design process. Top-level structure tested
most. Depth first implementation allows a complete function to be implemented, tested and
demonstrated. Can do depth first implementation of critical functions early. Top down
integration forced (to some extent) by some development tools in programs with graphical
user interfaces.
BOTTOM UP INTEGRATION :
Begin construction and testing with atomic modules (lowest level modules).Bottom up
integration testing as its name implies begins construction and testing with atomic modules.
Because modules are integrated from the bottom up, processing required for modules
subordinate to a given level is always available and the need for stubs is eliminated
3. VALIADATION TESTING :
Validation testing is aims to demonstrate that the software functions in a manner that can be
reasonably expected by the customer. This tests conformance the software to the Software
Requirements Specification.
Validation Test Criteria :
A set of black box test is to demonstrate conformance with requirements. To check that all
functional requirements satisfied, all performance requirements achieved, documentation is
correct and ' human-engineered', and other requirements are met (e.g. compatibility, error
recovery, and maintainability).
When validation tests fail it may be too late to correct the error prior to scheduled delivery.
Need to negotiate a method of resolving deficiencies with the customer.
Configuration Review :
An audit to ensure that all elements of the software configuration are properly developed
catalogued and has all the necessary detail to support maintenance.
4. ALPHA AND BETA TESTING :
It is difficult to anticipate how users will really use software. If there is one customer, a series
of acceptance tests are conducted (by the customer) to enable the customer to validate all
requirements. If software is being developed for use by multiple customers, cannot use
acceptance testing. An alternative is to use alpha and beta testing to uncover errors.
A customer conducts alpha testing at the developer's site. The customer uses the software
with the developer 'looking over the shoulder' and recording errors and usage problems.
Alpha testing conducted in a controlled environment
Beta testing is conducted at one or more customer sites by end users. It is ' live ' testing in an
environment not controlled by developer. The customer records and reports difficulties and
errors at regular intervals.
5. SYSTEM TESTING :
Software is only one component of a system. Software will be incorporated with other
system components and system integration and validation test performance.
6. RECOVERY TESTING :
Many systems need to be fault tolerant-processing faults must not cause overall system
failure. Other systems require after a failure within a specified time. Recovery testing is the
forced failure of the software in a variety of ways to verify that recovery is properly
performed.
7. SECURITY TESTING :
System with sensitive information or which have the potential to harm individuals can be
target for improper or illegal use. This can include:

attempted penetration of the system by outside individuals for fun or personal
gain.

disgruntled or dishonest employees.
During security testing the tester plays the role of the individual trying to penetrate the
system. Large range of methods:

Attempt to acquire passwords through external clerical means.

Use custom software to attack the system.

Overwhelm the system with requests.

Cause system errors and attempt to penetrate the system during recovery.

Browse through insecure data.
Given time and resources, the security of most systems can be breached.
8. PERFORMANCE TESTING :
For real-time and embedded systems, functional requirements may be satisfied but
performance problems make the system unacceptable. Performance testing checks the
run-time performance in the context of the integrated system Can be coupled with stress
testing, May require special software instrumentation.
Testing under various software development :
Requirements Stage
The requirements documents are tested by disciplined inspection and review. The
preparation of test plan, which should include:
1. Specification
2. Description of test precious
3. Test milestones
4. Test Schedule
5. Test data reduction
6. Evaluation criteria
Design Stage
Design products are tested by analysis, simulation, walkthrough and inspection. Test data
for functions are generated. Test cases based on structure of system are generated.
Construction Stage
This stage includes the actual execution of code with test data. Code walkthrough and
inspection are conducted. Static analysis, Dynamic analysis, Construction of test drivers,
hair nesses and stubs are done. Control and management of test process is critical. All test
sets, test results and test reports should be catalogued and stored.
Operation and Maintenance Stage
Modifications done to the software requires retesting this is termed regression testing.
Changes at a given level will necessitate retesting at all levels below it.
Approaches
Two basics approach:
1. Black box or "Functional" analysis
2. White box or "Structural" analysis
BLACK BOX TESTING:
Boundary value analysis (Stress Testing)
In this method the input data is partitioned and data inside and at the boundary of each
partition is tested.
Design based functional testing
Functional hierarchy is constructed. For each function at each level extrenal, non-extreamal
and special value test data are identified. Test data is identified such that it will generate
extremal, non-extremal and special output values.
Cause-effect graphing
In this method the characteristic input stimuli (Causes), characteristic output classes (effects)
are identified. The dependencies are identified using specification. These details are
presented as directed graph. Test cases are chosen to test dependencies.
WHITE BOX TESTING
Coverage-based testing :
The Program is represented as control-flow graph. The paths are identified. Data are chosen
to maximize paths executed under test conditions. For paths that are not always finite and
those infeasible, Coverage metrics can be applied.
Complexity-based testing :
The Cyclomatic Complexity is measured. The paths actually executed by
program
running on test data are identified and the actual complexity is set. A test set is devised which
will drive actual complexity closer to Cyclomatic complexity.
Test Data Analysis :
During Test Data Analysis “The Goodness of the test data set" is taken into major
consideration.
Statistical analysis and error seeding :
Known errors are seeded into the code so that their placement is statistically similar to that of
actual errors .
Mutation Analysis :
It is assumed that a set of test data that can uncover all simple faults in a program is capable
of detecting more complex faults. In mutation analysis a large number of simple faults, called
mutation, are introduced in a program one at a time .The resulting changed versions of the
test program are called mutates. Test data is then be constructed to cause these mutants to
fail. The effectiveness of the test data set is measured by the percentage to mutants killed.
Test Results :
The listed tests were conducted in the software at the various developments stages. Unit testing
was conducted. The errors were debugged and regression testing was performed. The integration
testing will be performed once the system is integrated with other related systems like Inventory,
Budget etc. Once the design stage was over the Black Box and White Box Testing was
performed on the entire application. The results were analyzed and the appropriate alterations
were made. The test results proved to be positive and henceforth the application is feasible and
test approved.
5.2 Test cases
Test case for Admin Login use case
Test
case
No.
1.
2.
3.
Input
Admin enters
correct
username and
password.
Admin enters
incorrect
username or
password.
Admin closes
the login form.
Expected Behavior
Observed
behavior
Status
admin is logged in and
access is granted.
-do-
Pass
Access is denied and
the user is asked to reenter details.
-do-
Pass
Exit the system
-do-
Pass
Test case for USER- use case:
Test
case
No.
Input
Expected Behavior
Observed
behavior
Status
1.
2.
3.
4.
User enters
valid details
User enters
invalid details
Submit button
is clicked
Accepts the details
-do-
Pass
Prompts the user to reenter the details
Prompts the user to
enter the file name.
-do-
Pass
-do-
Pass
.User closes
the frame
Exits from the
Administration service
-do-
pass
Observed
behavior
Status
Accepts the file.
-do-
Pass
Prompts the user to reenter the file name.
-do-
Pass
Prompts the user to
enter the file name.
-do-
Pass
Test case for USER-ADMIN use case:
Test
case
No.
1.
2.
3.
Input
User enters a
valid .crc file
name.
User enters
invalid file
name.
Compress
button is
clicked before
selecting the
file.
Expected Behavior
5.2 GUI SCREENS
CHAPTER-6
CONCLUSION
Now a days in this 21st century the growth is rampant right from small scale industries to the
rocket engineering .all the fields in this varied range need to use the sophisticated technology and
equipment to keep on pace with the changing times .
Airport administration and maintenance is no exception for it .growth of
the passenger flow, immigration are high now a days due to various reasons right from
globalization to politics, employment and economic crisis. the rate is set to have the exponential
growth and having no signs of decreasing .this adds to the already complex task of maintaining
whole airport activities. therefore effective ,adaptable capable reliable system should be in place
to handle all these activities .
Our project describes the basic activities that often takes place in the airport
which includes parking bay management, scheduling of flights their arrival and departure, staff
management, ground staff to pilot communication .attempt was made to enhance the areas to
avoid worst catastrophes by detecting the problem early taking the necessary actions. ground
monitoring system is a great help for the job .apart from it instantaneous report helps in
analyzing the tasks to take necessary proactive steps.
A lot is to be still done to cope up with the challenges ahead .many world class
airports also face challenges in the day by day increase in the air traffic. Our project is minor step
CHAPTER-7
BIBILOGRAPHY