Airline Reservation Sysytem

INTERFACE SOFTWARE BPUT UNIVERSITY
BIJUPATNAIK UNIVERSITY OF TECHNOLOGY

A Project Report on
AIRLINE RESERVATION SYSTEM
Carried out at
INTERFACE SOFTWARE
BHUBANESWAR
Submitted By:
Khitish Kumar Das
Registration No:-0805266064
The project is submitted for The Partial Fulfillment
of The Requirement for the degree of
MASTER IN COMPUTER APPLICATION (MCA)

Trident Academy
of
Creative Technology
Under the guidance of

PARTHASARATHI DAS
PROJECT GUIDER OF INTERFACE SOFTWARE.
AIRLINE RESERVATION SYSTEM 1

ACKNOWLEDGEMENT
No project reaches its destination with individual effort, similarly in my case
I have been able to complete my project because of the support I have received
from different avenues.
This project would not have seen the light of day without the guidance of
my external guide
I extend my heartfelt thanks to him for offering his valued guidance in completing
the project and also thankful for his valuable suggestion and efficient supervision in
spite of having arduous schedule. The project would have ended in a prenatal stage
if not for this perseverance and firm belief in my potential. This project is certainly
a success because of his all around help and concern; any word of thanks would be
insufficient for the assistance imparted to me.
I am also immensely thankful to our internal guide Mr. Kartik Rana faculty
of MCA Department of “ TRIDENT ACADEMY OF CREATIVE TECHNOLOGY ”.
I would also like to extend our thanks to Mr.P.K Dixit for his help and also
whole Interface family whose support has made our project a memorable success.
I would like to express my gratitude to Archana Panda and Niranjan Nayak,
for their valuable technical assistance, and Mr. Ashish Das , Mr Raghunath Rana
for their help.
Truly every day has been a learning experience for me due to the presence of all the
people who have helped me to frame a better life.

ABSTRACT
The first and foremost objective of the project is to give a better service to the
customer at the time of reserving the ticket of airline and eradicate the problems
faced by the customer to some extent .
The Airline Reservation System (ARS) was one of the earliest changes to improve
efficiency. ARS eventually evolved into the Computer Reservation System (CRS)
A Computer Reservation System is used for the reservation of a particular airline
and interfaces with a Global Distribution System (GDS) which supports travel
agencies and other distribution channels in making reservations for the most major
airlines in a single system .Airline Reservation System contain airline schedule, fare
traffics, passenger reservations and ticket records. An airline’s direct distribution
works within their own reservation system, as well as pushing out information to
the GDS. A second type of direct distribution channel is consumers who use the
internet or mobile application to make their own reservations.
The projects has successfully implemented with proper authentication

and services.
There are 2 main development modules in the project. They are
1. Admin Module
2. User/Customer Module
1. Admin Module:
Admin plays the key role throughout the whole project.Admin having own
username and password keeps track of the flight details and also about the customer
He can approve and can also reject the booking application of the customer.
2. User/Customer Modules:
User also having his/her own username and password for log on.
After log on he/she can view all the flights and their details and can book tickets as
per the requirement. User can also view and edit his own profile.

TABLE OF CONTENTS
Index
1. INTRODUCTION
2. REQUIRED SPECIFICATIONS
2.1 System Study
2.2 System specification
2.3 System Requirement study
2.4 Software specification
a. Java Server Pages
b. Java Script
c. Struts Framework and Servlet.
d. HTML
e. introduction to SQL Server.
3. SYSTEM DESIGN
3.1 Date base Design
3.2 Table Structures.
3.3 Data Flow Diagram.
3.4 ER Diagram.
4. IMPLEMENTATION
5. TESTING
6. CODING
7. CONCLUSION
8. APPENDIX
9. BIBLIOGRAPHY

LIST OF TABLES
 BOOKING_DETAILS
 CUSTOMERDETAILS
 FEEDBACK_DETAILS
 FLIGHTDETAILS
 LOGIN
 NOTICE
 PAYMENTDETAILS
 REGISTRATION

LIST OF FIGURES
 Data Flow Diagram
 Entity Relationship Diagram

CHAPTER-1
INTRODUCTION

Introduction
Online Air Ticket Booking system is to provide an option to customers to book
the tickets online and to check the confirmation online. This system will help the
company to sell the flight tickets online. Unless like in the previous stage people as
to walk into travel agency or this company ticket counter to buy the tickets and also
to check the flight timings. This problem is over come introducing this system.
Existing System
Presently the company has ticket counters in the airport. Where people as to come
to book the tickets or to check the flight timings. Also there are many travel agents
take the advance booking. In turn these agents will check out with the main ticket
counter officials for the ticket confirmation. This is very lengthy and tedious
process.
Proposed System
The proposed system will available online. So anybody who is interested in the
flight timings and ticket booking they check online only.
Objectives of the project
1. Online air ticketing saves time by reducing the time involved in the
physical transportation of the customer to the reservation counter; online air
ticketing process saves time in absolute terms.
2. It enables the customer to purchase tickets from the remote areas, thereby
increasing the customer-centricity of the services provided.
3. With a segment of customers opting for the online facilities, the pressure at
the reservation counter is substantially reduced.
4. Reduction in the pressure at the reservation counter creates scope to curtail

the number of employees at the reservation counters, contributing in cost-cut to
the company.
5. With faster, easier and hassle-free services to the customer, the company is
poised for a better competitive advantage in face of the oligopolistic structure.

6. Online portal can be used to ascertain any particular facilities that the
customer might be looking forward to during the journey.
7. The portal can also be used to inform the prospective customers about the
future economy option and other function benefits that the company could have
planned; thereby, enabling the customer to plan in advance.
8. With the induction of the cash on delivery system, the customer can easily
deliver his air-tickets while being at home.

CHAPTER-2
REQUIRED SPECIFICATIONS
2.1. System study

System study is a process that is to be done before any project begins.

This will held to understand how the existing system is functioning and what are the
drawbacks in it once the drawbacks have been identified it will be easy to design
the new system avoiding these drawbacks also system study should explain what is
the need for computerization.
2.2 OVERVIEW OF THE SOFTWARE:
2.2.1. Overview of java technology
History of java:
Java language was developed by James Gosling and his team at sun micro
systems and released formally in 1995. Its former name is oak. Java Development
Kit 1.0 was released in 1996. To popularize java and is freely available on Internet.
Overview of java:
Java is loosely based on C++ syntax, and is meant to be Object-Oriented
Structure of java is midway between an interpreted and a compiled language. Java
programs are compiled by the java compiler into Byte Codes which are secure and
portable across different platforms. These byte codes are essentially instructions
encapsulated in single type, to what is known as a java virtual machine (JVM)
which resides in standard browser.
Jvm verifies these byte codes when downloaded by the browser for integrity.
Jvm available for almost all OS. JVM converts these byte codes into machine
specific instructions at runtime.
Features of java:
• Java is object-oriented language and supports encapsulation,
inheritance, polymorphism and dynamic binding, but does not support
multiple inheritance. Every thing in java is an object except some
primitive data types.
• Java is portable architecture neutral that is java programs once
compiled can be executed on any machine that is enabled.
• JAVA is distributed in its approach and used for internet programming.
• Java is robust, secured, high performing and dynamic in nature.
• Java supports multithreading. There for different parts of the program
can be executed at the same time
Java and internet:

Java is strongly associated with internet and known as internet programming
language. Internet users can use java to create applet programs and run them locally
using java enabled browser search as hot java. Applets can be downloaded from
remote machine via internet and run it on local machine.
Java and World Wide Web:

World Wide Web is an open ended information retrieval system designed to
be used in the distributed environment. This system contains web pages that provide
both information and controls. We can navigate to a new web page in any direction.
This is made possible worth HTML java was meant to be used in distributed
environment such as internet. So java could be easily incorporated into the web
system and is capable of supporting animation graphics, games and other special
effect. The web has become more dynamic and interactive with support of java. We
can run a java program on remote machine over internet with the support of web.

Java Environment:
Java environment includes a large no. of tools which are part of the system
known as java development kit (JDK) and hundreds of classes, methods, and
interfaces grouped into packages forms part of java standard library (JSL).
Java Architecture:
Java architecture provides a portable, robust, high performing environment
for development. Java provides portability by compiling the byte codes for the java
virtual machine which are then interpreted on each platform by the runtime
environment. Java also provides stringent compile and runtime checking and
automatic memory management in order to ensure solid code.
Java Virtual Machine:

When we compile the code, java compiler creates machine code (byte code)
for a hypothetical machine called java virtual machine (jvm). The jvm will execute
the byte code and overcomes the issue of portability. The code is written and
compile for one machine and interpreted all other machines. This machine is called
java virtual machine.
About html:
HTML (hyper text markup language) is a language used to create hyper text
documents that have hyper links embedded in them. It consists of tags embedded in
the text of a document with HTML. We can build web pages or web document s. it
is basically a formatting language and not a programming language. The browser
reading the document interprets mark up tags to help format the document for
subsequent display to a reader. HTML is a language for describing structured
documents. HTML is a platform independent. WWW (World Wide Web) pages are
written using HTML. HTML tags control in part the representation of the WWW
page when view with web browser. The browser interprets HTML tags in the web

document and displays it. Different browsers show data differently. Examples of
browsers used to be web pages include:
• Netscape
• Internet Explorer
2.2.2. INTRODUCTION TO J2EE
Today, more and more developers want to write distributed transactional

applications for the enterprise and leverage the speed, security, and reliability of
server-side technology. If you are already working in this area, you know that in
today's fast-moving and demanding world of ecommerce and information
technology, enterprise applications have to be designed, built, and produced for less
money, faster, and with fewer resources than ever before.
To reduce costs and fast-track enterprise application design and development,

TM
the Java 2 Platform, Enterprise Edition (J2EETM) technology provides a
component-based approach to the design, development, assembly, and
deployment of enterprise applications. The J2EE platform gives you a multitiered
distributed application model, the ability to reuse components, a unified security
model, and flexible transaction control. Not only can you deliver innovative
customer solutions to market faster than ever, but your platform-independent
J2EE component-based solutions are not tied to the products and APIs of any one
vendor.
This tutorial takes an examples-based approach to describing the features and

functionalities available in J2EE SDK version 1.4. Whether you are a new or an
experienced enterprise developer, you should find the examples and
accompanying text a valuable and accessible knowledge base for creating your
own enterprise solutions.

If you are new to J2EE applications development, this chapter is a good place
to start. Here you will learn the J2EE architecture, become acquainted with
important terms and concepts, and find out how to approach J2EE applications
programming, assembly, and deployment.
2.2.2.1 SERVLETS OVERVIEW
INTRODUCTION
Servlets extend the request-response-oriented servers, such as Java-
enabled Web servers. For example, a Servlet can retrieve data from an HTML
form and applying the business logic used to update Product database.
Client System
Servlet Product
Database
HTTP
Server
Applets used in browsers. Similarly Servlets for server.

The Servlet API assumes nothing about the server’s environment or
protocol. Therefore, Servlet can be embedded in many different servers.
Uses of Other Servlets:

A Servlet can handle multiple requests concurrently, it allows Servlets
to support systems and concurrently requests.
• Servlets can be used to balance load among several
servers that mirror the same content, and to partition a
single logical service over several servers, thus Servlets
can forward requests.
Web Servers:
A Web server receives the request it then springs into action.
Depending on the type of request, the webserver might look for a web page or it
might execute program on the server, usually, as discussed earlier, CGI script or
an advanced server-side program.
The Servlet API:
The two packages contains the code to build the Servlets: javax.servlet
and javax.servlet.http
The javax.servlet package:
The javax.servlet package contains a number of interfaces and classes

that establish the framework in which Servlets operate. The ServletRequest and
ServletResponse are also very important.
• The ServletRequest interface is used to read data from a client

request.

• The ServletResponse interface is used to write data to a client
response.
The Servlet Interface:

All Servlets must implement the Servlet interface. Generic Servlet
must implements the Servlet and Servletconfig interface. HttpServlet extends
GenericServlet. It is commonly used to Servlets that receives and process HTTP
requests.
GenericServlets
ServletConfig
Servlet
HttpServlet

The ServletRequest Interface:

The server implements the ServletRequest interface. It enables to obtain about a
client request:
• The parameter of the names passed by the client, and the names of
the remote host that made the request.
• Servlets use to get data from clients that use application protocols
such as the HTTP POST and PUT methods in an InputStream such
as ServletInputStream.
• The HttpServletRequest interface contains methods for accessing
HTTP-specific header information.
The ServletResponse Interface:

The ServletResponse interface is implemented by the server. It enables
to obtain about a client response:
• It allows the Servlet to set the content length.
• Servlet can send the reply data which writer through n output
stream such as ServletOutputStream.
• The HttpResponse interface contains allow the Servlet to
manipulate HTTP-specific header information.
Hypertext Transfer Protocol (HTTP):

The Hypertext Transfer Protocol (HTTP) is used an application-level
protocol for distributed, collaborative, hypermedia information systems. A
feature of HTTP is the typing and negotiation of data representation, allowing
systems to be built independently of the data being transferred. The HTTP
protocol is a request/response protocol.

The javax.servlet.http Package:
The javax.servlet.http package contains several interfaces and classes
that are commonly used by Servlet developers.
Http Request and Responses:

The Http Requests and Responses contains in two arguments:
• An HttpServletRequest is used to enables Servlets to read
data from an HTTP request.
• An HttpServletResponse is used to enables Servlets to
write data to an HTTP response.
HttpServletRequest Object:
An HttpServletRequest Object provides to access the data from the
client:
• The getParameter method returns the value of a named
parameter and similarly the getParameterValues method
returns an array of values for the named parameter.
• The getReader method returns the BufferedReader to use
to read the data.
• The getInputStream method returns the
ServletInputStream to use to read the data.
HttpServletResponse Objects:
An HttpServletResponse object provides the HTTP method. To access
the data from the user:
• The getWriter method returns a Writer.
• The getOutputStream method returns the ServletOutputStream.

HTTP Header Data:

The HTTP header data means to access Writer or OutputStream. For
example, the GET and POST for HTTP requests to which the service method
includes:
• The handling for GET requests returns to doGet, Conditional
GET and HEAD requests.
• The handling for POST requests returns to doPost.
• The handling for PUT requests returns to doPut.
• The handling for DELETE requests returns to doDelete.
Servlets Features:
Servlets are efficient when compared to any other server-side
programs. They allow persistence of data to be maintained. More important is the
fact they are portable, robust security features.
Servlets Better than CGI:

Servlets offer advantages over CGI in the areas of performance,
portability and security. Each of these advantages will be discussed in turn:
• Performance is perhaps the most visible difference between Servlets
and CGI. Since most Servlets run in the same process space as the
server and are loaded only once, they are able to respond much more
quickly and efficiently to client requests. In contrast, CGI must create a
new process to service each new request. The overhead involved with
creating a new process incurs a significant performance penalty.
Unlike Servlets, CGI cannot share a single database connection across
multiple requests.

• Portability is another strong advantage for Servlets. Unlike many CGI
applications, Servlets can be run on different servers and platforms
without modifications. This characteristic can be extremely important
when building enterprise-wide distributed applications.
• Servlets are much more secure than CGI. Though CGI scripts can be
written in Java, they are often written in more error-prone language
such as C, since C programs can inadvertently or maliciously access
invalid memory locations, CGI programs are less secure. Of course,
these restrictions can be lifted according to the security policies set by
the Java Security Manager.
Life Cycle of Servlet:

Each Servlet has the same life cycle:
• Sever loads and initializes the servlets calls the init () method.
• The sever handles zero or more client requests calls the service
() method.
• The server removes the servlets calls the destroy () method.
(Some servers do this step only when they shutdown Destroy ())

Server Servlet code
Client
Handle
Servlet code Client
Request
Server Client
Servlet code
Server
Initialization Parameters of Servlets:

Initialize the Servlet before client requests are handled and before the
Servlet is destroyed. The Servlet runs the init method. The Servlet calls the init
method when the server loads the Servlet, and similarly will not call the init
method again unless the server is reloading the Servlet. After initialization, the
Servlet able to handle client requests. Initialization can be accessed in two ways:
• The init method declared by the Servlet interface receives
ServletConfig object as its argument. This object provides
methods that enable you to read the initialization parameters.
• The getServletConfig method declared by the Servlet interface
returns a ServletConfig object.
Destroying Servlets:

Destroys the Servlet runs the servlet’s destroy method. The method is
run once; similarly the server will not run the destroy method, when the server
calls the destroy method, another thread might be running a service request.
Servlets run until the server destroys them.
Communication of Servlets:
To communicate Servlets sometimes need to access network resources.
HTML pages, objects shared among Servlets at the same server and other
Servlets:
• The Request Dispatcher Object with other Server Resources
(JSDK 2.1) such as other Servlets with HTML pages and so on.
• The resource is an object in the JAVA programming language
such as Sharing Resources among Servlets (JSDK2.1).
• The other servlet’s Servlet object and calling its public such as
Calling Servlet from Servlets (JSDK2.0).
Utilities For Running Servlets:

The JSDK2.0 has a utility called Servletrunner. If you can test it with
the utility included in the JSDK, while JSDK2.1 comes with a small utility
server.
Properties of Servlets:
The Servlet requires initialization parameters, if you set this data before
starting the JSDK process that runs your Servlet.

STRUTS
Why struts?
We are using struts in this project. in the present scenario of web-technology, struts
plays a vital role. strut is a better structure. In standard mvc there is no clue
regarding the structure and designing. java pages being used, labels that has been
used so we found the previous mvc was not at it’s best to eradicate those
problems. We are using an api and a framework
In the name of struts designed by apache.it takes the help of standard servelet api
,jsp,java.
This frame work also follows mvc architecture means it has a model component. it
mix with some standard xml file. and struts defined java file.
It is a framework communication of apis, specification, where we found following

major specification.
1-- jsp specification
2 --servelet specification
3--java specification
4 --xml specification
5--struts specification
Struts basically drivn by the follwing major architecture

1-- mvc
2-- Front controller model
3 --data access object model
4 --data transfer

MVC ARCHITECTURE OVERVIEW
Controller(Servlet)
Request
Processing Data
Validation
Model
Business Logic
Data
Manipulation
Browser View(JSP) Database
. In the MVC architecture, a central servlet, known as the Controller, receives all
requests for the application. The Controller then processes the request and works
with the Model to prepare any data needed by the View (which is usually a JSP)
and forwards the data to a JSP. The JSP then uses the data prepared by the
controller to generate a response to the browser. In this architecture, the business
and presentation logic are separated from each other. Having the separation of
business and presentation code accommodates multiple interfaces to the application,
be they web, wireless, or GUI (Swing). Additionally, this separation provides
excellent reuse of code.
A CLOSER LOOK AT THE MODEL-VIEW-CONTROLLER ARCHITECTURE
Understanding of the MODEL-View-Controller architecture is crucial to

understanding Struts, this section takes a closer look at each of its parts. As a point
of interest, MVC is based on an older graphical user interface (GUI) design pattern
that has been around for some time, with its origins in the Smalltalk world. Many

of the some forces behind MVC for GUI development apply nicely to Web
development.
Model Components
In the MVC architecture, model components provide an interface to the data

and /or services used by an application. This way, controller components don’t
unnecessarily embed code for manipulating an application’s data. Instead, they
communicate with the model components that perform the data access and
manipulation. Thus, the model component provides the business logic. Model
components come in many different forms and can be as simple as a basic Java
bean or as intricate as Enterprise Java Beans (EJBs) or Web services.
View Components
View components are used in the MVC architecture to generate the response to the
browser. Thus, a view component provides what the user sees. Often times the
view components are simple JSPs or HTML pages. However, you can just as
easily use WML design advantages of MVC. You can use any view technology
that you’d like without impacting the Model layer of your application.
Controller Components
At the core of the MVC architecture are the controller components. The
controller is typically a servlet that receives requests for the application and
manages the flow of data between the Model layer and the View layer. Thus, it

controls the way that the Model and View layers interact. The Controller often uses
helper classes for delegating control over specific requests or processes.
Basic Components of Struts
The Struts framework is a rich collection of Java libraries and can be broken
down into the following major pieces:
Base framework
JSP tag libraries
Tiles plugin
Validator plugin
Base Framework
The base frame work provides the core MVC functionality and is comprised
of the building blocks for your application. At the foundation of the base
framework is the controller servlet ActionServlet. The rest of the base framework
is comprised of base classes. Most prominent among the base class are the Action
and ActionForm classes. These two classes are used extensively in all Struts
applications. Action classes are used by Action servlet to process specific requests.
Action Form classes are used to capture data from HTML forms and to be a conduit
of data back to the View layer for page generation.
JSP Tag Libraries

Struts comes packaged with several JSP tag libraries for assisting with
programming the View logic in JSPs. JSP tag libraries enable JSP authors to use
HTML-like tags to represent functionality that is defined by a java class.

Following is a listing of the libraries and their purpose;
HTML Used to generate HTML forms that interact with the Struts APIs.
Bean Used to work with Java bean objects in JSPs, such as accessing bean values.
Logic used to cleanly implement simple conditional logic in JSPs.
Nested Used to allow arbitrary levels of nesting of the HTML, Bean, and logic tags
that otherwise do not work.
Tiles Plug-in
Struts come packaged with the Tiles sub framework. Tiles is a rich JSP
templating framework that facilitates the reuse of presentation (JTML) code. With
Tiles, JSP pages can be broken up into individual tiles or pieces and then glued
together to create one cohesive page. Similar to the design principles that the core
Struts framework is built on, Tiles provides excellent reuse of View code
Validator Plug-in
Struts come packaged as of version 1.1, with the Validator sub framework for
performing data validation. Validate provides a rich framework for performing data
validation on both the server side and client side. Each validation is configured in
an outside XML file so that validations can easily be added to and removed from an
application declaratively versus being hard-coded into the application. Similar to
Tiles, prior to Struts 1.1, validator was a third party ass-on, but has since been
included in the project and is more tightly integrated.

STRUTS AND THE VIEW LAYER
Struts provide a rich set of functionality and features for developing the View
layer of MVC applications. There are several forms that the View layer of a Struts
application can take. It can be HTML/JSP (the most common case) or it can be
XML/XSLT, Velocity, Swing, or whatever your application requires. This is the
power of Struts and MVC. Because HTML/JSP is the typical view technology used
for Java-based Web applications Struts provides the most functionality and features
for developing your application this way. The remainder of this chapter focuses on
Struts support for creating the view layer using HTML/JSP.
Struts HTML/JSP view layer support can be broken down into the following
major components:
JSP pages
Form Beans
JSP tag libraries
Resource bundles
JSP PAGES
JSPs are the centerpiece of the Struts view layer. They contain the static
HTML and JSP library tags that generate dynamic HTML. Together the static and
dynamically generated HTML gets sent to the user’s browser for rendering. That is,
the JSPs contain the code for the user interface with which a user interacts. JSPs are
the centerpiece of the Struts View layer. They contain the static HTML and JSP
library tags that generate dynamic HTML. Together the static and dynamically

generated HTML gets sent to the user’s browser for rendering. That is, the JSPs
contain the code for the user interface with which a user interacts.
JSPs in Struts applications are like JSPs in any other java-based Web
application. However, to adhere to the mvc paradigm, the JSPs should not contain
any code for performing business logic or code for directly accessing data sources.
Struts provide a set of tag libraries that supports displaying data and creating HTML
forms that capture data. Additionally, the tags support displaying content stored in
resource bundles. The JSP tag libraries glue those two together and the resource
bundles provide a means of content management.
FORM BEANS
Form Beans provide the conduit for transferring data between the view and
controller layers of Struts applications. When HTML forms are submitted to a
Struts application, Struts takes the incoming form data and uses it to populate the
form’s corresponding form Bean. The Struts Controller layer then uses the Form
Beans to access data that must be sent to the Model layer. On the flip side, the
Controller layer populates form Beans with Model layer data so that it can be
displayed with the View layer. Essentially, Form Beans are simple data containers.
They either contain data from an HTML form that is headed to the Model via the
controller or contain data from the Model headed to the View via the controller.
MODEL LAYER BREAKDOWN
The typical model layer of a correctly designed MVC application can be

broken down into three conceptual sublayers. Each sublayer can be thought of as a
component or responsibility of the Model. Figure3-1 illustrates this breakdown.

Each sublayer does not necessarily represent a separate set of classes, but
rather the Model’s set of responsibilities. You may choose to house a specific
function’s code for all layers in one layer class, or you may break down each
sublayer into fine-grained objects. The level of object granularity is up to y9u and
what’s best and or necessary really depends on the size and complexity of your
application. The following are the three sublayers:
External interface Composed of code that provides and interface that external
code uses to interact with the Model.
Business logic encompasses the bulk of the Model code and provides the
business functionality for an application.
Data access Composed of code for communicating with an application’s data
sources such as a database.
STRUTS AND THE MODEL
The struts framework does not provide any specific features or constraints for
developing the Model layer of your application. At first glance this may seem odd,
or even a shortcoming, given that Struts is designed for building MVC applications.
However, it’s a actually a key design feature of struts and is a great benefit. By not
dictating how the Model layer should be bui9lt, struts gives your application the
flexibility to use any approach or technology for building the Model layer code.
Whether it be Enterprise java Beans, Java Data Objects (JDO), or the Data Access
Objects (DAO) pattern, struts will accommodate.
Because the model defines the business logic, the model is where struts ends
and your application code begins. Your Model code will be accessed from
subclasses of Struts Action object that are part of the Controller layer of the Struts

framework. Action subclasses interact with the model via Action’s interfaces and
use its Data Transfer Objects to pass and retrieve data.
You should not place any business logic or data access code in Action objects.
Doing so would bypass the separation of the Model and the Controller. Similarly,
your Model code should not have any ref4erences to Struts code or objects.
Violating this rule unnecessarily couples your core application code to Struts.
STRUTS AND THE CONTROLLER LAYER:

Struts provide a robust Controller layer implementation that has been designed from
the ground up to be extensible. At its core is the Controller servlet, Action Servlet,
which is responsible for initializing a Struts application’s configuration from the
struts configuration file and for receiving all incoming requests to the application.
Upon receiving arequest, action Servlet delegates its processing to the Request
Processor class. The Request Processor class processes all aspects of the request,
including selecting the Form Bean associated with the request, populating the Form
Bean with data, validating the Form Bean, and then selecting the correct Action
class to execute for the request. The Action class is where the Struts framework
ends and your application code begins. Action classes provide the glue between the
View and Model layers.

UNDERSTANDING THE FLOW OF EXECUTION
1.HTTP request
Controller View
3.Call Action with Form

6. Forward to JSP file
Struts Controller Action JSP File

Action Servlet Class
7.Produce HTTP
Response
2.Create Form Bean 5.Create Result Beans 4.Call DAO Method
Model
Data Access Object

DB
Form bean Result bean
(DAO)

It is necessary to describe the way that execution takes place. Struts uses the
Model-View-Controller design pattern,. The MVC architecture defines a specific
flow of execution. An understanding of this flow of execution is crucial to and
overall unders6snding of struts. For Mine HR, execution proceeds in the following
way:
The flow of execution for any Struts application as shown here.
1. The browser makes a request to the Struts application that is processed
by Action Servlet (controller).
2. Action Servlet (Controller) populates the Action form (View) object
with HTML form data and invokes it’s validate () method.
3. Action Servlet (controller) executes the Action object (Controller)
4. Action (Controller) interfaces with model components and prepares
data for view.
5. Action (Controller) forwards control, to the JSP (VIEW).
6. JSP (View) uses model data to generate a response to the browser.

Java database connectivity (jdbc)
Jdbc and Odbc in java:
Most popular and widely accepted database connectivity called Open
Database Connectivity (ODBC) is used to access the relational databases. It
offers the ability to connect to almost all the databases on almost all platforms.
Java applications can also use this ODBC to communicate with a database. Then
we need JDBC why? There are several reasons:
• ODBC API was completely written in C language and it makes an
extensive use of pointers. Calls from Java to native C code have a
number of drawbacks in the security, implementation, robustness and
automatic portability of applications.
• ODBC is hard to learn. It mixes simple and advanced features together,
and it has complex options even for simple queries.
• ODBC drivers must be installed on client’s machine.
Architecture of JDBC:
JDBC Architecture contains three layers:
JDBC Application
JDBC Drivers
JDBC Drivers

 Application Layer: Java program wants to get a connection to a
database. It needs the information from the database to display on the
screen or to modify the existing data or to insert the data into the table.
 Driver Manager: The layer is the backbone of the JDBC architecture.
When it receives a connection-request form.
 The JDBC Application Layer: It tries to find the appropriate driver by
iterating through all the available drivers, which are currently
registered with Device Manager. After finding out the right driver, it
connects the application to appropriate database.
 JDBC Driver layers: This layer accepts the SQL calls from the
application and converts them into native calls to the database and
vice-versa. A JDBC Driver is responsible for ensuring that an
application has consistent and uniform m access to any database.
When a request received by the application, the JDBC driver passes the
request to the ODBC driver, the ODBC driver communicates with the database,
sends the request, and gets the results. The results will be passed to the JDBC driver
and in turn to the application. So, the JDBC driver has no knowledge about the
actual database, it knows how to pass the application request o the ODBC and get
the results from the ODBC.
The JDBC and ODBC interact with each other, how? The reason is both the
JDBC API and ODBC are built on an interface called “Call Level Interface” (CLI).
Because of this reason, the JDBC driver translates the request to an ODBC call. The
ODBC then converts the request again and presents it to the database. The results of
the request are then fed back through the same channel in reverse.

Structured Query Language (SQL):

SQL (Pronounced Sequel) is the programming language that defines and
manipulates the database. SQL databases are relational databases; this means
simply the data is store in a set of simple relations. A database can have one or
more table. You can define and manipulate data in a table with SQL commands.
You use the data definition language (DDL) commands to creating and altering
databases and tables.
You can update, delete or retrieve data in a table with data

manipulation commands (DML). DML commands include commands to alter and
fetch data.
The most common SQL commands include commands is the SELECT

command, which allows you to retrieve data from the database.
In addition to SQL commands, the oracle server has a procedural

language called PL/SQL. PL/SQL enables the programmer to program SQL
statement. It allows you to control the flow of a SQL program, to use variables, and
to write error-handling procedures

3. SYSTEM DESIGN AND DEVELOPMENT
3.1. System design:
The design of a system produces the details that state how a system
meet the requirements identified during system analysis. System specialists often
refer to this stage as logical design, in contrast to the process of developing program
software, which is referred to as physical design.
Data Flow Diagrams have been used in the design of the system. Data
Flow Diagram is a graphical tool used to describe and analyze the movement of
data. The transformation of data from input to output, through processes may be
described logically using these Data Flow Diagrams.
The DFD shown to the user must represent only the major functions
being performed by the system. This is called Top Level DFD. If this process is
complex enough, it can be broken further into different levels. This process can be
continued till the process is simple. This is called the leveling of DFD’s.
3.2. Database design:

The main objective of designing a database is
• Data Integration
• Data Integrity
• Data Independence
Data Integration:
In a database information from several files is co-ordinate, accessed and
operated upon a as through it is single file.

Data Integrity:
Data Integrity means storing all the data in a singly place and allow each
application to access it. This approach results in more consistent, on update being
sufficient to achieve a new record status for all the applications, which use it.
Data Independence:
Data Independence is the insulation of application programs from changing
aspects of physical data organization. This objective seeks to allow changes in the
content and organization of physical data with out reprogramming of applications
and to allow modifications to application programs with out reorganizing the
physical data.
3.2.1. Normalization:
Data structuring is refined through a process called normalization, is a formal
process of developing data structures in a manner that eliminates redundancy and
promotes integrity. It is a step-by –step decomposition of complex records into
simple records to reduce redundancy, inconsistency and removes anomalies.
There are several normal forms to be followed in the normalization
process .The most important and widely used are:
• First Normal Form
• Second Normal Form
• Third Normal Form
3.2.1.1 First Normal Form (1 NF):
A table is said to be in the first normal form, if the intersection of any column
and row contains only value.
Identify a suitable identifier from the pool of UN normalized data. Remove
any item that repeat with in a single value of this key to another relation bringing
with them .The identifier key to form part of a new composite key in the relation.

3.2.1.2 Second Normal Form (2 NF):
For a table to be in the second normal form it should be in the first normal
form and the values in every column are functionally depend upon the primary key.
3.2.1.3 Third Normal Form (3 NF):
For a table to be in the third normal form it should be in the second normal
form and the values in every non-key column are not transitively depend upon on
the primary key
3.2 Table Structures
Table name : Login

Purpose : stores users name, password and type
Primary key : Slno
Column Name Data type Size

Slno Number 22
Username Varchar 4000
Password Varchar 4000
Type Varchar 4000

Table name : Booking_Details

Purpose : stores booking detail.
Primary key : Bid

Bid Number 22
Date_of_booking Varchar2 4000
Date_of_journey Varchar2 4000
Class Varchar2 4000
No_of_seat Number 22
Cid Number 22
Fid Number 22
Full Name Varchar2 4000
Address Varchar2 4000
Mob_no Number 22
Dd/Cheque/Scrool no Varchar2 4000
Flight_from Varchar2 4000
Flight_to Varchar2 4000
Flight_name Varchar2 4000
Mode_of_payment Varchar2 4000
Table name : Notice

Purpose : stores notices
Primary key : Notice_no

Notice_no Number 22
Subject Varchar2 4000
Content Varchar2 4000
Date_of_notice Varchar2 4000
Receive_username Varchar2 4000

Table name : Feedback_details
Purpose : stores feedbacks
Primary key: Feedback_no

Feedback_no Number 22
Comments Varchar2 4000
Suggestion Varchar2 4000
Date_of_feedback Varchar2 4000
Name Varcahr2 4000
Table name : Paymentsdetails

Purpose : stores payments details
Primary key :pid
Pid Number 22
Bid number 22
Date_of_payments date 7
Paymentmode varchar 4000
Accountno number 22

Table name : Customer_details
Purpose : stores customer details
Primary key : Customerid

Customer_id number 22
Name Varchar2 4000
Address Datetime2 4000
Email Varchar2 4000
Gender Varchar2 4000
Phono Varchar2 4000
Cid number 22
Table name : Flightdetails

Purpose : stores flight details
Primary key : Fid
column Name Data type Size

Fid number 22
Fname Varchar2 4000
Flt_from Varchar2 4000
Flt_to Varchar2 4000
Deparature_time number 22
Arrival_time number 22
Available number 22
Price number 22
Class Varchar2 4000

Table name : Registration
Purpose : stores new user details
Primary key :Rid

Rid number 22
Fname Varchar2 4000
Lname Varchar2 4000
Gender Varchar2 4000
Email Varchar2 4000
Address Varchar2 4000
Mob_no number 22
Slno number 22
3.3 Data Flow Diagram

Definition:
A data flow diagram is a graphical technique that depicts information flow and the
transforms that applied as data move from input to output. The Data flow diagram
used to represent a system or software at any level of abstraction. In fact DFDs may
be portioned into levels.
A level of DFD, also called a context model, represents the entire software elements
as a single bubble with input and output by arrow. A level of DFD is portioned into
several bubbles with inter connecting arrows. Each of the process represented at
level one is sub function of the over all depicted in the context model.
The DFD Notations:
External Entity Hardware person and other program
Process Information of the system to be modeled.
Data Item(s): Arrowhead indicates the

direction of flow
Store
Stored Information that is used by the s/w
Level 0:

DATA FLOW DIAGRAM FOR OVERALL SYSTEM
LOGIN
AIRLINE
ADMIN RESRVATION
USER
SYSTEM
DATABAS
E

Level-0
INPUT
(0.0)
PROCESS OUTPUT
DATASTORE

LEVEL - 1
1ST LEVEL DFD (FOR LOGIN)
User Name
Password (1.0)
Login
Type LOGIN Successfully
LOGIN
1ST LEVEL DFD (FOR REGISTRATION)
Customer Details (1.1) Login

REGISTRATION
Successfully
LOGIN
REGISTRATION

2nd LEVEL DFD (FOR VALID ADMIN)
Flight Management (2.0.1)
View Customer(2.0.2)
VALID ADMIN (2.0)
View Booking(2.0.3)
PROCESS View Feedback(2.0.4)
Give announcement(2.0.5)
2nd LEVEL DFD (FOR FLIGHT MANAGEMENT)
ADD FLIGHT (2.0.1.0)

FLIGHT MANAGEMENT
EDIT FLIGHT(2.0.1.1)
(2.0.1)
DELETE FLIFHT(2.0.1.2)
PROCESS

2nd LEVEL DFD (FOR ADD FLIGHT)
FLIGHT NAME
FLIGHT NO
FROM
TO (2.0.1.0)
ARRIVAL TIME
DEPARATURE TIME
SUCESSFULLY
CLASS ADD FLIGHT ADDED
SEAT AVAILABLE
PRICE
FLIGHTDETAILS
2nd LEVEL DFD (FOR EDIT FLIGHT)
SELECT FLIGHT (2.0.1.1) VIEWED UPDATE

SEARC FLIGHT
UPDATED
H SUCCESSFULY
FLIGHTDETAILS

2nd LEVEL DFD (FOR VIEW CUSTOMER)
(2.0.2)
SELECT CUSTOMER VIEWED
VIEW VIEWED
CUSTOMER SUCESSFULLY
CUSTOMERDETAILS
2nd LEVEL DFD (FOR VIEW BOOKING)
SELECT CUSTOMER VIEWED

(2.0.3)
PROCESS VIEWED
VIEW SUCCESSFULLY
BOOKING
BOKING_DETAILS

2nd LEVEL DFD (FOR VIEW FEEDBACK)
SELECT NAME VIEWED

(2.0.4)
PROCESS FEEDBACK
VIEW VIEWED
BOOKING SUCCESSFULLY
NOTICE
2nd LEVEL DFD (FOR ANNOUNCEMENT)
SELECT DATE VIEWED

(2.0.5)
PROCESS ANNOUNCEMENT
VIEW VIEWED
BOOKING SUCCESSFULLY
NOTICE

3rd LEVEL DFD (FOR VIEW BOOKING)
MY PROFILE (3.0.1)
CHANGE PASSWORD(3.0.2)
(3.0) VIEW FLIGHT(3.0.3)

VALID USER
MY BOOKING(3.0.4)
PROCESS CANCELLATION(3.0.5)
GIVE FEEDBACK(3.0.6)
VIEW ANNOUNCEMENT(3.0.7)
3rd LEVEL DFD (FOR MY PROFILE)
MY PROFILE (3.0.1) EDIT PROFILE(3.0.1.0)
PROCESS DELETE PROFILE(301.1)

3RD LEVEL DFD (FOR EDIT PROFILE)
SELECT NAME EDITED

(3.0.1.0)
UPDATED
PROCESS SUCCESSFULLY
CUSTOMERDETAILS
3RD LEVEL DFD (FOR DELETE PROFILE)
SELECT NAME DELETED

(3.0.1.1)
DELETED
CUSTOMERDETAILS

4TH LEVEL DFD (FOR NOTICE MANAGEMENT)
ADD NOTICE(4.0.1)
ADMIN (4.0) EDIT NOTICE(4.0.2)
PROCESS
DELETE NOTICE(4.0.3)
4TH LEVEL DFD (FOR EDIT NOTICE)
SELECT NOTICE (4.0.2) MODIFIED NOTICE

MODIFIED
NOTICE

3.4 ER-DIAGRAM
NA AD
ME DR
ES
US
RID S
ER
ME
NA
NO O
E
SL ST
M
CU
LOGIN HAS
A
CUSTOMERDETAILS
S A
EM
T
P
W S
AIL
Y
P
E
O
CID
RD
GE PH
ND ON
ER O EN
HAS
A
DATE_OF_JOURN
DATE_OF_BOOKIN
Y
CLASS NO_O
F_SEA
BID S T
MODE_OF_PA
CID Y
BOOKING_DETAILS
FLIGHTNAME
FID
O
TT
GH
FULL_NAM FLI
E
ADDRESS
O
MOB_NO DD TFR
GH
FLI
M
HAS
A

PID ACCOUNTNO BID

SUBJECT
NOTICENO
USERNAM
PAYMENTDETAILS CONTEN
T NOTICE E
DATE_OF_PAYMEN DATE_OF_NOTICE
PAYMENTMODE
T
FLT_FRO
FNAME
M
FID
FLIGHTDETAILS FLT_TO
CLASS
ARRIVALTIME
AVAILLABL
PRICE E
FEEDBACK_NO COMMENTS
SUGGESTION FEEDBACK_DETAILS
NAME
DATE_OF_FEEDBACK

4. SYSTEM TESTING AND IMPLEMENTATION
4.1. System testing:

Theoretically, a new designed system should have all the pieces in
working order, but in reality, each piece works independently. Now is the time
to put all pieces into one system and test it to determine whether it meets the
user’s requirements. The purpose of the system is to consider all the likely
variations to which it will be subjected and then push the system to its limits. It
is tedious but necessary step in system development. One needs to be familiar
with the following basic terms.
• UNIT TESTING: Unit Testing is testing changes made in an existing
or a new program.
• SEQUENTIAL OR SERIES TESTING: Sequential or Series Testing is
checking the logic of one or more programs in the candidate system, where
the output of one program will affect the processing done by another
program.
• SYSTEM TESTING: System Testing is executing a program to check
logic changes made in it and with the intention of finding errors making the
program fail.
• ACCEPTANCE TESTING: Acceptance Testing is running the system
with live data by the actual user of the system.
Testing is vital to the success of the system. System testing makes a
logical assumption that if all the parts of the system are correct, the goal will be
successfully achieved. In adequate testing or no-testing leads to errors that may
not appear until months later. Another reason for system testing is its utility as a
user-oriented vehicle before implementation. The best program and the user
have communication barriers due to different backgrounds. The system

tester(designer, programmer, or user) who has developed some computer
mastery can bridge this barrier.
4.1.1 Unit Testing:
This focuses on the smallest unit of software design. The module
using the details design description as a guide; important control paths are tested
to uncover errors within the boundary of the module.
Unit test consideration:
The module interface id tested to ensure that information properly
flows into and out of the program unit under test. The local data structures are
examined to ensure that the data stored temporarily maintains it integrity during
all steps in an algorithm execution. Boundary conditions are tested to ensure that
the module operates properly at boundaries established to limit or restrict
processing. The test of data flow across a module interface is required before
any other test. If data do not enter and exit properly, all other tests are moot.
Unit Procedure:
 Unit test is normally considered adjunct to the coding style.

 After source level code has been developed, reviewed and verified for
correct syntax, unit test case design begins. Each test case should be
coupled with a set of expected results.
 Normally, a driver is a “main program” that accepts test case data,
passes such data to the module to be tested and prints the relevant
results. Stubs serve to replace modules that are subroutines called by
the module to be tested. A Stub or ‘dummy stub program’ uses the
subroutine module’s interface to do minimal data manipulation and
returns.

Unit testing is simplified when a module with high cohesion is designed. When a
module addresses only one function, the number of test cases is reduced and
errors can be more easily predicted and uncovered.
4.1.2 Integration Testing:

Integration is a systematic technique for constructing the program
structure, while at the same time conducting tests to uncover errors associated with
interfacing. The objective is to make unit-tested modules and build a program
structure that has been dictated by design. Incremental integration is the program
that is the program that is constructed and tested in small segments where errors are
easier to isolate and correct.
Top down Integration:

Top-down integration is an incremental approach to the construction of
program structure. Modules are integrated by moving downward through the
control hierarchy, beginning with the main control module. Module subroutine to
the main control module is incorporated into the structure either in a depth-first
manner is engaged for this system. Breadth-first incorporates all modules directly
subroutine at each level, moving across the structure horizontally.
The integration process is performed in a series of five steps:

 The main control module is used as a test driver and stubs are
substituted for all modules directly subroutine to the main control
module.
 Depending on the integration approach selected (depth or breadth first)
subroutine stub are replaced one at a time with actual modules.
 Tests are conducted as each module is integrated.

 On the completion of each set of test, another stub is replaced with the
real module.
 Registration testing is conducted to ensure that new errors have not
been introduced.
4.1.3 Validation testing:

At the end of integration testing, the system is completely assembled
as a package with interfacing errors corrected after which a final series of
software tests namely validation testing begins. Validation succeeds when the
software functions in a manner that can be reasonably expected by the user.
Criteria:
Software validation is achieved through black box tests that
demonstrate conformity with requirements.
4.1.4 System Testing:
System testing is actually a series of different tests whose primary
purpose is to fully exercise the computer-based system. Although each test has a
different purpose, all work should verify that all system elements have been
properly integrated and perform allocated functions. Being the most important
test, the performance test is covered briefly below:
Performance Testing:
For real-time systems, software that provides required function but does
not conform to performance requirement is unacceptable. Performance testing is
designed to test the run-time performance of software within the context of an
integrated system. Performance testing occurs throughout all steps in the testing
process. Even at the unit level, the performance of an individual module may be
accessed as tests are conducted. However, it is not until all system elements are
fully integrated that the true performance of a system can be ascertained.

4.1.5 Debugging:
Debugging is not testing not occurs as a consequence of testing, that is
when a test case uncovers an error, debugging is the process that results in the
removal of the error.
Normally three categories for debugging approaches are proposed:
 Brute force
 Back-tracking
 Cause-elimination
4.1.5.1 Brute force:

This is the most common and least efficient method for isolating the
cost of a software error. Brute-force debugging method is usually applied when
all else fails. Using a “let the computer finding the error” philosophy, memory-
dumps are taken, runtime traces are invoked and the program is loaded with
WRITE (in this case message box) statements. In the information that is
produced, a clue is found leading to the cause of the error.
4.1.5.2 Back-tracking:
This is fairly common debugging approach that can be used
successfully in small programs. Beginning at the site where a symptom has been
uncovered, the source code is traced backwards (manually) until the site of the
cost is found.

Cause-Elimination:
This approach is manifested by induction/deduction and introduces the
concept of ‘binary partition’. A ‘cause hypothesis’ is devised and the error
related data are used to prove or disprove the hypothesis. Alternatively, a list of
all possible causes is developed, and tests are conducted to eliminate each. If
initial tests indicate that a particular cause hypothesis shows promise, that data
are refined in an attempt to isolate the path.
Each of the debugging approaches can be supplemented with
debugging tools. A wide variety of debugging compilers, dynamic debugging
aids (tracers), automatic test case generators, memory dumps and cross-reference
maps can be applied. However, tools are not a substitute for careful evaluation,
based on a complete software design document and clear source code.
4.2. System implementation

After proper testing and validation, the question arises whether the
system can be implemented or not. Implementation includes all those activities that
take place to convert from the old system to the new. The new system may be
totally new; replacing an existing module or automated system, or it may be major
modification to an existing system. In either case proper implementation is essential
to provide a reliable to provide a reliable system to meet organization requirements.
All planning has now, be completed and the transformation to a fully
operational system can commence. The first job will be writing, debugging
documenting of all computer programs and their integration into a total system. The
master and transaction files are decided, and this general processing of the system is
established. Programming is complete when the programs conformed to the detailed
specification.

When the system is ready for implementation, emphasis switches to
communicate with the finance department staff. Open discussion with the staff is
important form the beginning of the project. Staff can be expected to the concerned
about the effect of the automation on their jobs and the fear of redundancy or loss of
status must be allayed immediately. During the implementation phase it is
important that all staff concerned be apprised of the objectives of overall operation
of the system. They will need shinning on how computerization will change their
duties and need to understand how their role relates to the system as a whole. An
organization-training program is advisable; this can include demonstrations,
newsletters, seminars etc.
The department should allocate a member of staff, who understands
the system and the equipment, and should be made responsible for the smooth
operation of the system. An administrator should coordinate the users to the system.
Users should be informed about new aspects of the system that will,
affect them. The features of the system explained with the adequate documentation.
New services such as security, on-line application from the back-ups must be
advertise on the staff when the time is ripe.
Existing documents such as employee loan details should be entered into the new
system. Since these files are very large, conversion of these may continue long after
the system based on current files has been implemented. Hence we need to assign
responsibility for each activity.
The system may come into full operation via number of possible
routes. Complete change over at one point time is conceptually the most tidy.
But this approach requires careful planning and coordination, particularly during
the changeover. A phased approach, possible implementing the system of the
section relating to one operation or procedure first and processing to more novel
or complex subsystems in the fullness of time. These likely to be less traumatic.

A phased approach gives the staff time to adjust to the new system. But depends
on being able to split the system, without reliance on it. Thus approach is
sensible when the consequences of failure are disastrous, but will require extra
staff time. The fourth angle, is pilot operation permits any problems to be
tackled on a smaller scale operation. Pilot operation generally means the
implementation of the complete system, but at one location or branch only.

Screen shot:
Login.jsp
Description : This page comes first when you run this projects. This page is by
defult call index.jsp page.

AdminHome.jsp
Description :This page comes after inputing correct username, password and type
then clicking the Login button on Login page.
Fields :
Login -: Login id of admin

Password -: password of admin

Registration.jsp
Description: This page comes after clicking NewUser hyperlink at the Login page.
This page is for the registration of new user by filling required
fields available and all the data giving by the users through this page will store in
database.

UserHome.jsp
Description: This page comes after inputting correct username, password and type
then clicking the Login button on Login page.
Fields:
Login -: Login id of user.

Password -: password of user.

ViewFlight.jsp
Description: This page comes after clicking the Attributes of user . It gives all the
information of the flight.

GiveFeedback.jsp
Description: This page is for storing the feedback given by the customer.
Fields:
Name- Customer Name.
Comments-Comments given by the Customer.
Suggestion- Suggestion given by the Customer.

ViewCustomer.jsp
Description: This page comes after clicking the Attributes of Admin i.e View
Customer. It gives the details of Customers.
Fields:
Customer Name: Name of Customer.
Address: Address of Customer.
Gender: Gender of Customer.
Mob No: Mobile no of Customer.

Annoucement.jsp
Description: This page comes after clicking the Attributes of Admin i.e. Give
Announcement. It gives the details about the Announcement.

ViewBooking.jsp
Description: This page comes after clicking the Attributes of Admin i.e View
Booking. It gives details of the booking of ticket.

ChangePassword.jsp
Description: This page comes after clicking the attribute of user i.e. Change
Password. This page changes the old password of a User.

DEVELOPMENT PROCESS
2.1. PROJECT LIFE CYCLE
The Software Development Life Cycle (SDLC) is the process by which

software is created. Some companies don't have anything more than an ad hoc
approach to software development, but these environments still have an SDLC-it's
just a bad one. Likewise, each company that has a formal SDLC probably has its
own, unique flavor of the SDLC. Sometimes the SDLC is a very complicated,
detailed approach that requires a whole team of project managers just to keep going.
The lifecycle of a project may include the following steps:
.
By applying this simple set of definite steps and deliverables at the outset and
relating this to a transparent time and cost structure, we provide clients with an
effective framework against which to measure expectation, quality, progress and
cost for their project.

2.2. DEVELOPMENT PROCESS
Waterfall Model
Planning the development process involves several important considerations.

The first consideration is to define a product life-cycle model.A software LIFE-
CYCLE model encompasses all activities required to define, test, and develop.
Requiremen
t analysis-
Design- v&v
Implementation-
v&v
Testing- v&v
Maintenance-
v&v

FEASEBILITY STUDY
The main aim of feasibility study is to determine whether developing

the product is financially and technically feasible .The feasibility study involves.
 An abstract definition of the problem.

 Formation of different solution strategies.
 Examination of alternative solution strategies and their benefits,
indicating resources required, developed, cost and time respect of each of
the alternative solution. A cost effective analysis is performed to determine
which solution is the best at this stage , it may also determine whether any
of this solution is not feasible due to the high cost , resource constraint or
extraordinary technically reason .
The module is totally feasible in all respect i.e. technically it reduces the time
consuming and in economically it reduces the cost.
The feasibility aspect of the project was considered at the time of the
negotiation with the officials and while discussing the same with the team.
FEASIBILITY ANALYSIS:
The advantage of computer based system is more likely to be

plagued by a scarcity of resources and difficulty delivery dates. A feasibility study
is not warranted for a system in which economic justification is obvious, technical
risk is low, few legal problem are expected and no reasonable alternative risks.
Even if there are different types of feasibility study reports but the following were
given importance for this project:-

 Security Feasibility
 Operational Feasibility
 Economical Feasibility
 Technical Feasibility
SEQURITY FEASIBILITY:
The security of the database from being tampered from an unauthorized

personnel different password fields were provided to different users. The
password are validated and given in the front-end keeping its flexibility and user
friendliness in view. As the concept goes usually the backend is not a frequently
visited area that’s why we kept the access of passwords in jsp. As our project
keeps, evaluates and relatives very important and confidential data about the
diseases and it’s eradication program , it is very important that user should
maintain their own individuality and identity so as one cannot overlap or interfere
or even tamper the restricted fields.
OPERATIONAL FEASIBILITY:
People are inherently resistance to change and computers have been

known to facilitate change. An estimate should be made of how strong a reaction
the user staff is likely to have towards the development of a computerized
system. It is common knowledge that computer installations have something to
do with turnover, transfer retraining and change in job status.
The end users are eager enough to use the s/w. This would reieve them from
physical labor and also financially to maintain various registers and paying a lot
of staffs in the working office and depot.

The top level officials or the outsides can vital information quickly and
correctly form our interpretation.
ECONOMICALLY FEASIBILITY:
Economically Feasibility is most frequently used for evaluating the

effectiveness of equipment information system. More commonly known as cost
benefit analysis, the procedure is to determine the benefits and saving that are
expected from equipment information system and compare them with costs. If
benefits outweigh costs, then the decision is made to design and implement the
system, otherwise design and implement the system, otherwise further justification
or alternation in the proposed system will have to be made if it is to have a chance
of being approved.
Keeping in view the no. of clients who would be using this software that
is the different places and locations, this project was developed keeping in view the
lowest hardware capacity computer available during that time. As can be seen in
our synopsis that we use p2 7 p3 computers the lowest available with the client
having the following configuration.
 486 DX
 60 MHz
 1 GB HDD
 12/16 MB RAM

The software was developed in JSP & Oracle8.0 because we opted for a front-end
that will be very user friendly, web friendly and easier for the end user. This also
helped the end user to a very large extent because usually the end user is just a data
entry operator who knows the distinction between letter and number. Keeping this
IQ level of the user into view this type of front-end was used for smooth operation.
TECHNICAL FEASIBILITY:
Technical Feasibility involves financial considerations to accommodate

technical enhancement. If the budget is a serious constraint then the project is
judged ‘not feasible’.
Here the cost incurred by searching an appropriate s/w which may handle
by some few people and hidden to others, but it reduces the searching time, so it
technically fit.
The module reduce the work load of different end user , and gives a clear
picture about the s/w required so the user use this module , hence this system is
operationally feasible .
As this page is technically, economically sequritically and operationally
feasible, so this system is judged feasible.
Hardware Feasibility
For develop this project or implement this project we need different

types of hardware configuration for server and client. If we will use different type
of hardware’s then it may not work properly.

FOR SERVER
Machine: Pentium IV Server
Memory: 256 MB DDRAM
Hard Drive: 40 GB HDD or Higher
CPU Speed: 2.0Ghz
Monitor: S.V.G.A
Keyboard: Standard
Printer: Laser
UPS: 5KVA
For client
Machine: Pentium IV Client
Memory: 128 MB DDRAM
Hard Drive: 10 GB HDD or Higher
CPU Speed: 1.0Ghz
Monitor: S.V.G.A
Keyboard: Standard
Printer: Laser
UPS: 2KVA

Software Feasibility
Using different types of software, which have listed below so these

software’s also need for implement this project, developed this project. If we will
use different types of software then this project will not work.
Operating System: WINDOWS 98, 2000, Xp,2007
Front-end Tool: SERVLET, JSP, STRUTS
Back-end Tool: SQL SERVER
Server: Tomcat 6.0, WBLOGIC
Economical Feasibility
As soon as the specific requirements and solutions have been identified then
the cost of and benefits of each alternative would be evaluated.

Cost Of Estimation Of the Project
The cost of the major hardware, software and accessories required for this
project are 20 lakhs.
Requirement Analysis and Specification
Before starting to design a software product, it is extremely important to understand

the precise requirements of the customer and to document them properly. The
requirements analysis and specifications phase starts once the feasibility study
phase is complete and the project is found to be financially sound and technically
feasible, the goal of the requirements analysis and specifications phase is to clearly
understand the customer requirements and to systematically organize these
requirements in a specification document, this phase consists of the following two
activities:
 Requirements gathering analysis
 Requirements specification
Requirements gathering analysis

We can elaborate the two main activities involved in the requirements
gathering and analysis phase:

Requirements gathering.
This activity typically involves interviewing the end-users and customers and
studying the existing documents to collect all possible information regarding the
system. If the project involves automating some existing procedures then the task of
the system analyst becomes a little easier as he can obtain the input and the output
data formats and the details of the nation and creativity on the part of the system
analyst is required.
Analysis of gathered requirements.
The main purpose to this activity is to clearly understand the exact
requirements of the customer. The following basic questions pertaining to the
project should be clearly understood by the analyst in order to obtain a good grasp
of the problem:
 What is the problem?
 Why is it important to solve the problem?
 What are the possible solutions to the problem?
 What exactly are the data inputs to the system and what exactly are the
data outputs required of the system?
 What are the likely complexities that might arise while solving the
problem?
 If there are external software or hardware with which the developed

software has to interface, then what exactly would the data interchange
formats with the external system.

Software Requirements Specification (SRS).
After the analyst has collected all the required information regarding the
software to be developed, and has removed all incompleteness, inconsistencies, and
anomalies from the specification, he starts to systematically organize the
requirements n the form of an SRS document. The SRS document usually contains
all the user requirements in an informal form.
Contents of the SRS Document

An SRS document should clearly document the following aspects of a
system:
 Functional requirements
 Nonfunctional requirements
 Goals of implementation
The functional requirements part should discuss the functionalities required from
the system. It is useful to consider a system as performing a set of functions {f1}.
This functional view of a system is shown schematically in figure.
y
System
Input Output
Each function fi of the system can be considered as a transformation of a set

of input data(ii)corresponding set of output data(oi).
The nonfunctional requirements deal with the characteristics of the system that
cannot be expressed as functions. Example of nonfunctional requirements includes

aspects also include reliability issues, accuracy of results, human-computer

interface issues, and constraints on the system implementation.
The ‘goals of implementation’ part of the SRS document gives some general
suggestions regarding development. These suggestion guide trade-off among design
decisions.
DESIGN
Software design deals with transforming the customer requirements, as described in
the SRS document, into a form that is implement able using a programming
language, for a design to be easily implement able using a programming language,
the following items must be designed during the design phase:
 Different modules required implementing the design solution.
 Control relationship among the identified modules. The relationship is

also known as the call relationship or invocation relationship among
modules.
 Data structures of the individual modules

.
 Algorithms required implementing the individual modules.
System design
System design consists of the flow of control among different modules and the
approach i.e. function-oriented approach of object-oriented approach is used.
In our project we have used function-oriented approach. The commonly used data
flow control (DFD).

6.Coding
Web.xml
<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
version="2.4"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<servlet>
<servlet-name>action</servlet-name>
<servlet-
class>org.apache.struts.action.ActionServlet</servlet-
class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-
value>
</init-param>
<init-param>
<param-name>debug</param-name>
<param-value>3</param-value>
</init-param>
<init-param>
<param-name>detail</param-name>
<param-value>3</param-value>
</init-param>
<load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>Home.jsp</welcome-file>
</welcome-file-list>
</web-app>

Struts-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software
Foundation//DTD Struts Configuration 1.2//EN"
"http://struts.apache.org/dtds/struts-config_1_2.dtd">
<struts-config>
<data-sources />
<form-beans >
<form-bean name="loginForm" type="pp.form.LoginForm"
/>
</form-beans>
<global-exceptions />
<global-forwards />
<action-mappings >
<action
attribute="loginForm"
name="loginForm"
parameter="submit"
path="/login"
scope="request"
type="pp.action.LoginAction">
<forward name="submit" path="/Registration.jsp"/>
<forward name="notapp" path="/Login.jsp"/>
<forward name="admin" path="/AdminHome.jsp"/>
<forward name="customer" path="/UserHome.jsp"/>
<forward name="view" path="/FlightManagment.jsp"/>
<forward name="flight"
path="/FlightManagment.jsp"/>
<forward name="add" path="/AddFlight.jsp"/>
<forward name="fedit" path="/EditFlight.jsp"/>
<forward name="vcust" path="/ViewCustomer.jsp"/>
<forward name="vcust1" path="/ViewBooking.jsp"/>
<forward name="feed" path="/ViewFeedback.jsp"/>
<forward name="notice" path="/Announcement.jsp"/>
<forward name="vprof" path="/MyProfile.jsp"/>
<forward name="eprof" path="/EditProfile.jsp"/>
<forward name="dprof" path="/DeleteProfile.jsp"/>

<forward name="cpwd" path="/ChangePassword.jsp"/>
<forward name="fview" path="/View Flight.jsp"/>
<forward name="mbook" path="/MyBooking.jsp"/>
<forward name="cancel" path="/Cancellation.jsp"/>
<forward name="feed1" path="/GiveFeedback.jsp"/>
<forward name="vannoun"
path="/ViewAnnouncement.jsp"/>
<forward name="not" path="/NoticeMgmt.jsp"/>
<forward name="ntice" path="/EditNotice.jsp"/>
<forward name="dnotice" path="/DeleteNotice.jsp"/>
<forward name="subError"
path="/Registration.jsp" />
<forward name="logon" path="/Login.jsp" />
<forward name="logout" path="/UserHome.jsp" />
</action>
</action-mappings>
<message-resources parameter="pp.ApplicationResources"
/>
</struts-config>
Home.jsp
<%@ page language="java" pageEncoding="ISO-8859-1"%>
<%@ taglib uri="http://struts.apache.org/tags-bean"

prefix="bean" %>
<%@ taglib uri="http://struts.apache.org/tags-html"
prefix="html" %>
<%@ taglib uri="http://struts.apache.org/tags-logic"
prefix="logic" %>
<%@ taglib uri="http://struts.apache.org/tags-tiles"
prefix="tiles" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0

Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-
transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html;
charset=utf-8" />
<title>Professional by FreeCSSTemplates.org</title>
<link rel="stylesheet" type="text/css" href="style.css"
media="screen" />
</head>
<body>
<div id="wrapper">
<div id="header">
<div id="logo">
<h1>Air Ticket Reservation</h1>
<p>Fly In
Cooooooooollllllllllllll......................</p>
</div>

<div id="menu">
<ul>
<li class="active"><a
href="Home.jsp">Home</a></li>
<li><a href="AboutUs.jsp">About Us</a></li>
<li><a href="ContactUs.jsp">Contact
Us</a></li>
</ul>
</div>

</div>

<div id="page">
<div id="header-pic"></div>
<div id="content">
<div class="post">
<h1 class="title"><h2>Welcome To Home
Page......</h2> </h1>
<p class="byline">
<div class="entry">
</div>
<div class="meta">
<p class="links">
Welcome aboard RK Airlines, where you are
made to feel like an honoured guest and not just a
passenger. At RK, a flight is not a journey between two
airports but an experience of a lifetime.RK is built for
people with things to do, places to be, people to see -
who don't want to waste time, money or energy in the
process. By minimizing the cost/time/tension of air
travel, RK opens up a country full of opportunities.
With RK, you've got a billion reasons to fly</div>

</div>
<div class="post">
<p class="byline">
<div class="entry">
</div>
<div class="meta">
</div>
</div>
</div>

<div id="sidebar">
<div id="sidebar-bgtop"></div>
<div id="sidebar-content">
<div id="sidebar-bgbtm">
<ul>
<li>
<h2>Sign Here<br /></h2>
<ul>
<li><a
href="Login.jsp">Login<br /></a></li>
<li><a
href="Registration.jsp">New User<br /></a></li>
</ul>
</li>
<li>
<ul>
</li>
</ul>
</div>
</div>
</div>

<div style="clear:both; margin:0;"></div>
</div>

</div>
<div id="footer">
</div>

</body>
</html>

Login.jsp

prefix="bean" %>
prefix="html" %>
prefix="logic" %>
prefix="tiles" %>

Transitional//EN"
transitional.dtd">

<head>
charset=utf-8" />
media="screen" />
<script>
function validateForm(frm)
{
var uname=frm.uname.value;
var pwd=frm.pwd.value;
if(uname.length==0)
{
alert("Enter ur UserName");
frm.uname.focus();
return false;
}
if(pwd.length==0)
{
alert("Enter ur Password");
frm.pwd.focus();
return false;
}
return true;
}
</script>
</head>
<body>
<div id="wrapper">
<div id="header">
<div id="logo">
<p>Fly In
</div>

<div id="menu">
<ul>
Us</a></li>
</ul>
</div>

</div>
<div id="page">
<div id="content">
<div class="post">
<h1 class="title"><h2>Welcome Login
Page......</h2> </h1>
<p class="byline">
<div class="entry">
</div>
<div class="meta">
<p class="links">
Welcome Login Page......
<html:form action="login" onsubmit="return

validateForm(this);">
<table>
<tr><td>User Name</td><td><html:text
property="uname"/></td></tr>
<tr><td>Password</td><td><html:password
property="pwd"/></td></tr>
<tr><td>Type</td><td colspan="2"
align="center"><html:radio property="type"
value="admin">Admin</html:radio>
<html:radio property="type"
value="customer">Customer</html:radio></td></tr>
<tr><td><html:submit property="submit"
value="Login"/><html:submit property="submit"
value="Reset"/></td></tr>
</table>
</html:form>
<font color="red"><bean:write name="loginForm"
property="msg"></bean:write></font>
<br /></div></div>
<div class="post">
<p class="byline">
<div class="entry">
</div>
<div class="meta">
</div>
</div>
</div>
<div id="sidebar">
<div id="sidebar-bgtop">
</div>
<div id="sidebar-content"><div id="sidebar-
bgbtm"><ul><li><h2>Sign Here<br /></h2><ul>
<li><a
href="Login.jsp">Login<br /></a></li>
<li><a
href="Registration.jsp">New User<br /></a></li>
</ul>
</li>
<li>
<ul>
</li>
</ul>
</div>
</div>
</div>
</div>

</div>
<div id="footer">
</div>
<></body>
</html>

UserHome.jsp

prefix="bean" %>
prefix="html" %>
prefix="logic" %>
prefix="tiles" %>

Transitional//EN"
transitional.dtd">

<head>
charset=utf-8" />
media="screen" />
</head>
<body>

<div id="wrapper">
<div id="header">
<div id="logo">
<p>Fly In
</div>

<div id="menu">
<ul>
Us</a></li>
<li><a href="login.do?
submit=LogOut">Logout</a></li>
</ul>
</div>

</div>
<div id="page">
<div id="content">
<div class="post">
<h1 class="title"><h2>Welcome To User Home
Page......</h2> </h1>
<p class="byline">
<div class="entry">
</div>
<div class="meta">
<p class="links">
<br /></div></div>
<div class="post">
<p class="byline">
<div class="entry">
</div>
<div class="meta">
</div>
</div>
</div>
<div id="sidebar">
<div id="sidebar-bgtop">
</div>
<div id="sidebar-content"><div id="sidebar-
bgbtm"><ul><li><h2><br /></h2><ul>
submit=viewProfile">My Profile<br /></a></li>
<li><a
href="ChangePassword.jsp">Change Password</a></li>
submit=viewFlight">View Flight</a></li>
submit=myBooking">My Booking</a></li>
submit=cancelFlight">Cancellation<br /></a></li>
submit=viewAnnouncement">View Announcement<br
/></a></li>
</ul>
</li>
<li>
<ul>
</li>
</ul>
</div>
</div>
</div>
</div>

</div>
<div id="footer">
</div>
<></body>
</html>
MyProfile.jsp
<jsp:directive.page import="java.util.*"/>

prefix="bean" %>
prefix="html" %>
prefix="logic" %>
prefix="tiles" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01

Transitional//EN">
<html:html lang="true">
<head>
<html:base />
<title>MyProfile.jsp</title>
<meta http-equiv="pragma" content="no-cache">

<meta http-equiv="cache-control" content="no-
cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords"
content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my
page">

</head>
<body>

<head>
charset=utf-8" />
media="screen" />
</head>
<body>
<div id="wrapper">
<div id="header">
<div id="logo">
<p>Fly In
</div>

<div id="menu">
<ul>
href="#">Home</a></li>
<li><a href="#">About Us</a></li>
<li><a href="#">Contact Us</a></li>
</ul>
</div>

</div>
<div id="page">
<div id="content">
<div class="post">
<h1 class="title"><h2>Welcome To My Profile
page......</h2> </h1>
<p class="byline">
<div class="entry">
<html:form action="login.do?
submit=viewProfile1">
<%
ArrayList<String>
name=( ArrayList<String>)request.getAttribute("CUST");
%>
<table>
<tr><td>Customer
Name</td><td><html:select property="cname" size="1">
<%
for(int i=0;i <
name.size();i++)
{
%>
<html:option
value="<%=name.get(i)%>"><%=name.get(i)%></html:option>
<%
}
%>
</html:select></td></tr>
<tr><td>Address</td><td><html:textarea
property="address"/></td></tr>
<tr><td>Gender</td><td><html:text
property="gender"></html:text><br /></td></tr>
<tr><td>Mob.
No</td><td><html:text property="mob"/></td></tr>
<tr><td>Email</td><td><html:text
property="email"/></td></tr>
<br\><tr><td colspan="2"
align="center"><html:submit property="view"
value="View"></html:submit></td></tr> </table>
</html:form>
</div>
<div class="meta">
<p class="links">
</div>
</div>
<div class="post">
<p class="byline">
<div class="entry">
</div>
<div class="meta">
</div>
</div>
</div>
<div id="sidebar">
<div id="sidebar-bgtop"></div>
<div id="sidebar-content">
<div id="sidebar-bgbtm">
<ul>
<li>
<h2> </h2>
<ul>

submit=editProfile">Edit Profile</a></li>
submit=deleteProfile">Delete Profile</a></li>
</ul>
</li>
<li>
<ul>
</ul>
</li>
</ul>
</div>
</div>
</div>
</div>

</div>
<div id="footer">
<p>© 2008. All Rights Reserved. Design by <a
href="http://www.freecsstemplates.org/">Free CSS
Templates</a>.</p>
</div>
</body>
</html>
</html:html>
LoginAction.java
package pp.action;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;
import pp.DBLogic;
import pp.form.LoginForm;
public class LoginAction extends DispatchAction {
public ActionForward Submit(ActionMapping
mapping, ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws SQLException
{
LoginForm loginForm = (LoginForm) form;
DBLogic dblogic=new DBLogic();
String fname=loginForm.getFname();
String uname=loginForm.getUname();
String pwd=loginForm.getPwd();
String gender=loginForm.getGender();
if(gender==null)
{
loginForm.setMsg("Plz Select Gender");

return mapping.findForward("subError");
}
String email=loginForm.getEmail();
String address=loginForm.getAddress();
Long mob=loginForm.getMob();
System.out.println(fname+uname+pwd+gender+email+address+
mob);
int i=0;
i=dblogic.Submit(fname,uname,pwd,gender,email,address,mo
b);
loginForm.reset(mapping, request);
return mapping.findForward("submit");
}
public ActionForward Login(ActionMapping
mapping,ActionForm form,HttpServletRequest
request,HttpServletResponse response)throws SQLException
{
LoginForm loginForm=(LoginForm)form;
String uname=loginForm.getUname();
String pwd=loginForm.getPwd();
String type=loginForm.getType();
String msg="You Are Not Approved";
System.out.println(msg);
System.out.println(uname+" "+pwd+" "+type);
ResultSet rs=dblogic.Login(uname,pwd,type);
while(rs.next())
{ if(type.equals("admin"))
{
return mapping.findForward("admin");
}
if(type.equals("customer"))
{
ResultSet rs1=dblogic.retCId(uname);
Long id=null;
while(rs1.next())
{
id=rs1.getLong("CUSTOMERID");
System.out.println(id);
}
HttpSession
session=request.getSession();
session.setAttribute("CID", id);
return mapping.findForward("customer");
}}
loginForm.setMsg(msg);
loginForm.reset(mapping, request);
return mapping.findForward("notapp");
}
Public ActionForward viewProfile(ActionMapping
{
LoginForm loginForm=(LoginForm) form;
HttpSession session=request.getSession(true);
Long id=(Long)session.getAttribute("CID");
ResultSet rs=dblogic.viewProfile(id);
ArrayList<String>
cname= new ArrayList<String>();
while(rs.next())
{
cname.add(rs.getString("NAME"));
System.out.println(cname);
}
request.setAttribute("CUST",cname);
return mapping.findForward("vprof");
}
public ActionForward viewProfile1(ActionMapping
{
LoginForm loginForm=(LoginForm) form;
HttpSession session=request.getSession(true);
Long id=(Long)session.getAttribute("CID");
ResultSet rs=dblogic.view9(id);
while(rs.next())
{
loginForm.setGender(rs.getString("GENDER"));
loginForm.setAddress(rs.getString("ADDRESS"));
loginForm.setMob(rs.getLong("PHONO"));
loginForm.setEmail(rs.getString("EMAIL"));
}
return viewProfile(mapping,form,request,response);
}
LoginForm.java
package pp.form;
import javax.servlet.http.HttpServletRequest;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
public class LoginForm extends ActionForm
{ private String ruser;
private String nsub;
private String ncon;
private String suggestion;
private String comments;
private String ffname;
private String type;
private String email;
private String address;
private Long mob;
private String flight;
private String fno;
private String from;
private String to;
private Long atime;
private Long dtime;
private String clas;
private Long available;
private Long price;
private String cname;
private String doj;
private String dob;
private String funame;
private Long nos;
private String mop;
private String dcs;
private String name;
private String feedback;
private String data;
private String announ;
private String opwd;
private String npwd;
private String vnnoun;
private String subject;
private String content;
private String ruse;
private String rpwd;
private String don;
private String snm;
private String epwd;
private String sugg;
private String euse;
private String gender;
private String cpwd;
private String lname;
private String fname;
private String pwd;
private String uname;
private String msg;
private String cnd;
private String Suggestion;
public String getUname() {
return uname;}
public void setUname(String uname) {
this.uname = uname; }
public ActionErrors validate(ActionMapping mapping,
HttpServletRequest request) {
return null;}
public void reset(ActionMapping mapping,
HttpServletRequest request)
{ this.address=null;
this.ruser=null;
this.nsub=null;
this.ncon=null;
this.suggestion=null;
this.comments=null;
this.ffname=null;
this.type=null;
this.email=null;
this.address=null;
this.mob=null;
this.flight=null;
this.fno=null;
this.from=null;
this.to=null;
this.atime=null;
this.dtime=null;
this.clas=null;
this.available=null;
this.price=null;
this.cname=null;
this.doj=null;
this.dob=null;
this.funame=null;
this.nos=null;
this.mop=null;
this.dcs=null;
this.name=null;
this.feedback=null;
this.data=null;
this.announ=null;
this.opwd=null;
this.npwd=null;
this.vnnoun=null;
this.subject=null;
this.content=null;
this.ruse=null;
this.rpwd=null;
this.don=null;
this.snm=null;
this.epwd=null;
this.sugg=null;
this.euse=null;
this.gender=null;
this.cpwd=null;
this.lname=null;
this.fname=null;
this.pwd=null;
this.uname=null;
this.msg=null;
this.cnd=null; }
public String getPwd() {
return pwd; }
public void setPwd(String pwd) {
this.pwd = pwd;
}
public String getEmail() {
return email;}
public void setEmail(String email) {
this.email = email; }
public String getAddress() {return address;}
public void setAddress(String address) {

this.address = address;}
public Long getMob() {
return mob;
}
public void setMob(Long mob) {
this.mob = mob; }
public String getFlight() {
return flight;}
public void setFlight(String flight) {
this.flight = flight; }
public String getFno() {
return fno;
}
public void setFno(String fno) {
this.fno = fno; }
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;}
public String getTo() {return to;}
public void setTo(String to) {this.to = to;}
public Long getAtime() {return atime;}
public Long getDtime() {return dtime;}
public String getClas() {return clas;}
public void setClas(String clas) {this.clas = clas;}
public Long getAvailable() {return available;}
public void setAvailable(Long available) {
this.available = available;}
public Long getPrice() {return price;}
public void setPrice(Long price) {this.price = price;}
public String getCname() {return cname;}
public void setCname(String cname) {this.cname = cname;}
public String getDoj() {return doj;}
public void setDoj(String doj) {this.doj = doj;}
public String getDob() {return dob;}
public void setDob(String dob) {this.dob = dob;}
public String getFuname() {return funame;}
public void setFuname(String funame){
this.funame = funame;}
public Long getNos() {return nos;}

public void setNos(Long nos) {this.nos = nos;}
public String getMop() {return mop;}
public void setMop(String mop) {this.mop = mop;}
public String getDcs() {return dcs;}
public void setDcs(String dcs) {this.dcs = dcs;}
public String getName() {return name;}
public void setName(String name) {this.name = name;
}
public String getFeedback() {return feedback;}
public void setFeedback(String feedback) {
this.feedback = feedback; }
public String getData() {return data;}
public void setData(String data) {this.data =
data;}
public String getAnnoun() {return announ;}
public void setAnnoun(String announ) {this.announ =
announ;}
public String getOpwd() { return opwd;}
public void setOpwd(String opwd) {this.opwd = opwd;}
public String getNpwd() {return npwd;}
public void setNpwd(String npwd) {this.npwd = npwd;}
public String getVnnoun() {return vnnoun;}
public void setVnnoun(String vnnoun) {this.vnnoun =
vnnoun;}
public String getSubject() {return subject;}
public void setSubject(String subject) {
this.subject = subject;}
public String getContent() {return content;}
public void setContent(String content) {this.content =
content;}
public String getRuse() {return ruse;}
public void setRuse(String ruse) {this.ruse = ruse;}
public String getRpwd() {return rpwd;}
public void setRpwd(String rpwd) {this.rpwd = rpwd;}
public String getDon() {return don;}
public void setDon(String don) {this.don = don;}
public String getSnm() {return snm;}
public void setSnm(String snm) {this.snm = snm;}
public String getEpwd() {return epwd;}
public void setEpwd(String epwd) {this.epwd = epwd;}
public String getSugg() {return sugg;}
public void setSugg(String sugg) {this.sugg = sugg;}
public String getEuse() {return euse;}
public void setEuse(String euse) {this.euse = euse;}
public String getGender() {return gender;}
public void setGender(String gender) {this.gender =
gender;}
public String getCpwd() {return cpwd;}
public void setCpwd(String cpwd) {this.cpwd = cpwd;}
public String getLname() {return lname;}
public void setLname(String lname) {this.lname = lname;}
public String getFname() {return fname;}
public void setFname(String fname) {this.fname = fname;}
public String getType(){return type;}
public void setType(String type) {this.type = type;}
public String getMsg() {return msg;}
public void setMsg(String msg) {this.msg = msg;}
public void setAtime(Long atime) {this.atime = atime;}
public void setDtime(Long dtime) {this.dtime = dtime;}
public String getFfname() {return ffname;}
public void setFfname(String ffname) {this.ffname =
ffname;}
public String getComments() {return comments;}
public void setComments(String comments) {this.comments
= comments;}
public String getSuggestion() {return suggestion;}
public void setSuggestion(String suggestion) {
this.suggestion = suggestion;}
public String getRuser() {return ruser;}
public void setRuser(String ruser) {this.ruser = ruser;}
public String getNsub() {return nsub;}
public void setNsub(String nsub) {this.nsub = nsub;}
public String getNcon() {return ncon;}
public void setNcon(String ncon) {this.ncon = ncon;}
public String getCnd() {return cnd;}
public void setCnd(String cnd) {this.cnd = cnd;}
}
DBLogic.java
package pp;
import java.util.*;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import pp.form.LoginForm;
public class DBLogic {
public int Submit(String fname,String uname,String
pwd,String gender,String email,String address,Long
mob)throws SQLException{
int i=0;
Statement st=DBConnect.getStatement();
st.executeUpdate("insert into LOGIN
values(LID_SEQ.nextval,'"+uname+"','"+pwd+"','customer')
");
i=st.executeUpdate("insert into CUSTOMERDETAILS
values(RID_SEQ.nextval,'"+fname+"','"+address+"','"+emai
l+"','"+gender+"',"+mob+",lid_seq.currval)");
return i;
}
public ResultSet Login(String uname,String pwd,String
type) throws SQLException{
ResultSet
rs=DBConnect.getStatement().executeQuery("select * from
Login where username='"+uname+"' and password='"+pwd+"'
and type='"+type+"'");
return rs;
}
public ResultSet viewProfile(Long id)throws SQLException
{
ResultSet
CUSTOMERDETAILS where CUSTOMERID="+id+"");
return rs;
}
public ResultSet view9(Long id)throws SQLException
{
ResultSet
CUSTOMERDETAILS where CUSTOMERID="+id+"");
Return
rs;
}
DBConnect.java
package pp;
import java.sql.DriverManager;
import java.sql.*;
public class DBConnect {
public static Statement getStatement()
{
Connection con=null;
Statement st=null;
ResultSet rs=null;
try{
Class.forName("oracle.jdbc.driver.OracleDriver");
con=DriverManager.getConnection("jdbc:oracle:thin:@local
host:1521:XE","bubu","bubu");
st=con.createStatement();
}
catch(Exception err){

System.out.println(err.getMessage());
}
return st;
}
}

7.CONCLUSION
The project “AIRLINE RESERVATION SYSTEM” has been

developed as per the requirements specification of the Interface Software .It has
been developed in Servlet,jsp and struts in frontend and SQL server in backend.
The complete system is thoroughly tested with the availability data and
throughput reports are verified with reports which are prepared manually.
It has been observed that the report generation is easier and now
compared with the manual operation. These are found to be more accurate
because of availability of information from various levels. Design procedure and
output reports are presented in this project report. This design is so flexible that
any new modules can be incorporated easily.
8. APPENDICES
7.1. SYSTEM REQUIREMENTS
8.1.1. Software specification

Operating System : windows’2k
Front end : java, servlet, jsp, html
Back end : SQL Server 2000
Server : Weblogic Bea server 9.0
8.1.2. Hardware specification

CPU type : Pentium IV
Memory : 256 MB RAM
Hard disk : 20 GB hdd
Key board : 110 keys
8.1.3. Drive summary
CDROM Monitor : 15’’color monitor

9. BIBILIOGRAPHY
 The Complete reference java2... By Herbert Schildt …….

Tata McGraw Hill Publication.
 Pure JSP By James Goodwill Dream Tech Publication.
 A Beginner’s guide JSP By Madhushree Ganguli Wiley

Publishing .
 Teach Yourself Web-Technologies (I & II) By Ivan Bay Ross
BPB Publication.
 Oracle 9i Complete reference Oracle Oracle Corporation TMH
 Analysis and Design of Information System …. By James A. Senn
 The Complete reference Struts…..James Holmes…………..TMH

Airline Reservation Sysytem

Caricato da

Informazioni sul documento

Descrizione originale:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Airline Reservation Sysytem

Caricato da

Copyright:

Formati disponibili

INTERFACE SOFTWARE BPUT UNIVERSITY

BIJUPATNAIK UNIVERSITY OF TECHNOLOGY

MASTER IN COMPUTER APPLICATION (MCA)

Under the guidance of

AIRLINE RESERVATION SYSTEM 1

AIRLINE RESERVATION SYSTEM 2

The projects has successfully implemented with proper authentication

AIRLINE RESERVATION SYSTEM 3

AIRLINE RESERVATION SYSTEM 4

AIRLINE RESERVATION SYSTEM 5

 Data Flow Diagram

 Entity Relationship Diagram

AIRLINE RESERVATION SYSTEM 6

AIRLINE RESERVATION SYSTEM 7

Objectives of the project

4. Reduction in the pressure at the reservation counter creates scope to curtail

AIRLINE RESERVATION SYSTEM 8

AIRLINE RESERVATION SYSTEM 9

2.1. System study

System study is a process that is to be done before any project begins.

2.2.1. Overview of java technology

Java and internet:

Java and World Wide Web:

AIRLINE RESERVATION SYSTEM 12

Java Virtual Machine:

AIRLINE RESERVATION SYSTEM 13

2.2.2. INTRODUCTION TO J2EE

Today, more and more developers want to write distributed transactional

To reduce costs and fast-track enterprise application design and development,

This tutorial takes an examples-based approach to describing the features and

AIRLINE RESERVATION SYSTEM 14

2.2.2.1 SERVLETS OVERVIEW

Applets used in browsers. Similarly Servlets for server.

Uses of Other Servlets:

The Servlet API:

The javax.servlet package:

The javax.servlet package contains a number of interfaces and classes

• The ServletRequest interface is used to read data from a client

AIRLINE RESERVATION SYSTEM 16

The Servlet Interface:

AIRLINE RESERVATION SYSTEM 17

The ServletRequest Interface:

The ServletResponse Interface:

Hypertext Transfer Protocol (HTTP):

AIRLINE RESERVATION SYSTEM 18

Http Request and Responses:

AIRLINE RESERVATION SYSTEM 19

HTTP Header Data:

Servlets Better than CGI:

AIRLINE RESERVATION SYSTEM 20

Life Cycle of Servlet:

AIRLINE RESERVATION SYSTEM 21

Server Servlet code

Initialization Parameters of Servlets:

AIRLINE RESERVATION SYSTEM 22

Utilities For Running Servlets:

AIRLINE RESERVATION SYSTEM 23

It is a framework communication of apis, specification, where we found following

Struts basically drivn by the follwing major architecture

AIRLINE RESERVATION SYSTEM 24

MVC ARCHITECTURE OVERVIEW

Browser View(JSP) Database