Air Ticket Reservation System Project Report

LUCKNOW PUBLIC COLLEGE OF
PROFESSIONAL STUDIES
A MAJOR PROJECT REPORT ON

AIR TICKET RESERVATION SYSTEM
Submitted By:
PRAKHAR SHARMA
Roll no. :- 180820625057
The project is submitted for The Partial Fulfillment
of The Requirement for the degree of
BACHELOR OF COMPUTER APPLICATION (BCA)
Under the guidance of

MR. Rohit Kapoor
SESSION:-2018-21
.
CERTIFICATE
LUCKNOW PUBLIC COLLEGE OF PROFESSIONAL STUDIES
Certified that the project entitled “AIR TICKET RESERVATION

SYSTEM” submitted by PRAKHAR SHARMA (180820625057) in the
fulfillment of the requirements for the award of the degree of the
Bachelor of Computer Application, is a record of student’s own work
carried under our supervision and guidance.
The project report embodies results of the original work and studies
carried out by students and the contents do not form the basis for the
award of any other degree to the candidate or to anybody else.
Signature of the Student Signature of the Guide

_____________________ _____________________
Date: Signature of Dean Academic
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 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.
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

TM
development, 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
Server Request
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 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
DB
Form bean Result bean Data Access Object
(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
DATABASE
Level-0
INPUT (0.0)
PROCESS OUTPUT
DATASTORE
LEVEL - 1
1ST LEVEL DFD (FOR LOGIN)
User Name
(1.0)
Password Login
LOGIN Successfully
Type
LOGIN
1ST LEVEL DFD (FOR REGISTRATION)
(1.1)
Customer Details Login
REGISTRATION Successfully
LOGIN
REGISTRATION
2nd LEVEL DFD (FOR VALID ADMIN)
Flight Management (2.0.1)
(2.0) View Customer(2.0.2)

VALID ADMIN
PROCESS View Booking(2.0.3)

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
(2.0.1.0)
FROM
TO
ARRIVAL TIME
DEPARATURE TIME
ADD FLIGHT SUCESSFULLY
ADDED
CLASS
SEAT AVAILABLE
PRICE
FLIGHTDETAILS
2nd LEVEL DFD (FOR EDIT FLIGHT)
SELECT FLIGHT (2.0.1.1) VIEWED UPDATE

FLIGHT UPDATED
SEARCH SUCCESSFULY
FLIGHTDETAILS
2nd LEVEL DFD (FOR VIEW CUSTOMER)
(2.0.2) VIEWED
SELECT CUSTOMER VIEW VIEWED
SUCESSFULLY
CUSTOMER
CUSTOMERDETAILS
2nd LEVEL DFD (FOR VIEW BOOKING)
SELECT CUSTOMER (2.0.3) VIEWED

PROCESS VIEWED
VIEW SUCCESSFULLY
BOOKING
BOKING_DETAILS
2nd LEVEL DFD (FOR VIEW FEEDBACK)
SELECT NAME (2.0.4) VIEWED

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

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)
(3.0.1)
MY PROFILE EDIT PROFILE(3.0.1.0)
PROCESS
DELETE PROFILE(301.1)
3RD LEVEL DFD (FOR EDIT PROFILE)
SELECT NAME (3.0.1.0) EDITED

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

DELETED
CUSTOMERDETAILS
4TH LEVEL DFD (FOR NOTICE MANAGEMENT)
ADD NOTICE(4.0.1)
(4.0)
ADMIN EDIT NOTICE(4.0.2)
PROCESS
DELETE NOTICE(4.0.3)
4TH LEVEL DFD (FOR EDIT NOTICE)
(4.0.2)
NOTICE
SELECT NOTICE MODIFIED
MODIFIED
NOTICE
3.4 ER-DIAGRAM
NAME ADDRESS
USERNAME
CUSTOMERID
SLNO
LOGIN HAS A
CUSTOMERDETAILS
PASSWORD TYPE
EMAIL
CID
GENDER PHONENO
HAS A
DATE_OF_BOOKIN DATE_OF_JOURNY
CLASS NO_OF_SEATS
BID
CID MODE_OF_PAY
BOOKING_DETAILS
FLIGHTNAME
FID
FLIGHTTO
FULL_NAME
ADDRESS
FLIGHTFROM
MOB_NO DD
HAS A
PID ACCOUNTNO BID
SUBJECT
NOTICENO
PAYMENTDETAILS USERNAME
CONTENT NOTICE
DATE_OF_PAYMENT DATE_OF_NOTICE
PAYMENTMODE
FNAME FLT_FROM
FID
FLIGHTDETAILS FLT_TO
CLASS
ARRIVALTIME
AVAILLABLE
PRICE
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.
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>
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>
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>
<li><a
href="login.do?submit=viewProfile">My Profile<br
/></a></li>
<li><a
href="ChangePassword.jsp">Change Password</a></li>
<li><a
href="login.do?submit=viewFlight">View Flight</a></li>
<li><a
href="login.do?submit=myBooking">My Booking</a></li>
<li><a
href="login.do?submit=cancelFlight">Cancellation<br
/></a></li>
<li><a
href="login.do?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>
<li><a
href="login.do?submit=editProfile">Edit
Profile</a></li>
<li><a
href="login.do?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+add
ress+mob);
int i=0;
i=dblogic.Submit(fname,uname,pwd,gender,email,address,m
ob);
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
SQLException
{
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
SQLException
{
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+"','"+ema
il+"','"+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:@
localhost: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

Air Ticket Reservation System Project Report

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Air Ticket Reservation System Project Report

Uploaded by

Copyright:

Available Formats

LUCKNOW PUBLIC COLLEGE OF

A MAJOR PROJECT REPORT ON

Under the guidance of

LUCKNOW PUBLIC COLLEGE OF PROFESSIONAL STUDIES

Certified that the project entitled “AIR TICKET RESERVATION

Signature of the Student Signature of the Guide

No project reaches its destination with individual effort, similarly in my

received from different avenues.

would be insufficient for the assistance imparted to me.

all the people who have helped me to frame a better life.

The projects has successfully implemented with proper authentication

Objectives of the project

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

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:

Java Virtual Machine:

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

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

If you are new to J2EE applications development, this chapter is a good

2.2.2.1 SERVLETS OVERVIEW

Applets used in browsers. Similarly Servlets for server.

Uses of Other Servlets:

The Servlet API:

The two packages contains the code to build the Servlets:

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

The Servlet Interface:

The ServletRequest Interface:

The ServletResponse Interface:

Hypertext Transfer Protocol (HTTP):

The javax.servlet.http Package:

Http Request and Responses:

HTTP Header Data:

Servlets Better than CGI:

(Some servers do this step only when they shutdown Destroy

Server Servlet code

Initialization Parameters of Servlets:

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

Struts basically drivn by the follwing major architecture

MVC ARCHITECTURE OVERVIEW

A CLOSER LOOK AT THE MODEL-VIEW-CONTROLLER ARCHITECTURE

Understanding of the MODEL-View-Controller architecture is crucial to

In the MVC architecture, model components provide an interface to the data

Basic Components of Struts

JSP Tag Libraries

Following is a listing of the libraries and their purpose;

Logic used to cleanly implement simple conditional logic in JSPs.

STRUTS AND THE VIEW LAYER

MODEL LAYER BREAKDOWN

The typical model layer of a correctly designed MVC application can be

External interface Composed of code that provides and interface that

STRUTS AND THE MODEL

3.Call Action with Form

Struts Controller Action

You can update, delete or retrieve data in a table with data

The most common SQL commands include commands is the

In addition to SQL commands, the oracle server has a procedural

3.1. System design: