Se Project

A PROJECT REPORT
ON
RTO MANAGEMENT SYSTEM

Submitted in Partial Fulfillment of Requirement
For the award of the degree
In
Bachelor of Computer Applications
Of
BANGALORE UNIVERSITY
Submitted By
PRAVALIKA J
REG.NO.15VFSB7040
Under the Guidance of

Mrs. APPORVA
Sr. Asst. Professor
Marathalli Campus, Marathalli outer ring road, Bangalore-560103.
Website: www.newhorizonindia.edu
DEPARTMENT OF COMPUTER SCIENCE

CERTIFICATE
This is to certify that Pravalika J- Register No. 15VFSB7040, have satisfactorily
completed the Sixth Semester BCA Project titled “RTO MANAGEMENT
SYSTEM “. This Report is submitted in partial fulfillment of the requirements for
the award of the Degree in Bachelors of Computer Applications, awarded by
Bangalore University, during the Academic Year 2017-2018.
Guide Head of the Department
APPORVA A NAGARAJU KILARI
Signature of the External Examiners:
• ___________________
• ___________________
ACKNOWLEDGEMENT
With immense pleasure, we take this opportunity to express our

gratitude to the beloved Principal Dr.R.Bodhisatvan for providing
valuable guidance and support during the course.
We would like to thanks Mr. Nagaraju Kilari, Head of the Department

– BCA for his unending support and encouragement during the
development of this project.
We would like to acknowledge the interest and the support extended by
our project guide Mrs. Apporva Sr.Asst.Professor, Department of BCA,
to make this project implementation successful.
Finally, we wish to thank every individual who helped us directly or

indirectly in making the project a grand success.
INDEX
CHAPTERS PAGE NO
CHAPTER:1 INTRODUCTION TO THE PROJECT
1.1. INTRODUCTION 6
1.2 ABSTRACT 6
1.3 MODULE DESCRIPTION 7 7-9

CHAPTER:2 SYSTEM ANALYSIS
2.1. EXISTING SYSTEM 9
2.2. PROPOSED SYSTEM 10
2.3. REQUIREMENT SPECIFICATION 11
2.4. HARDWARE REQUIREMENTS

2.5 SOFTWARE REQUIREMENTS 12
2.3.3. INTRODUCTION TO HTML 13
2.3.4. INTRODUCTION TO CSS 14
2.3.5. INTRODUCTION TO PHP 15
2.3.5. INTRODUCTION TO
JAVASCRIPT 16
2.3.5. INTRODUCTION TO MYSQL 17-19

CHAPTER:3 SYSTEM DESIGN
3.1. TABLE STRUCTURE 20-22
3.2. E-R DIAGRAM 23

3.3 FORM DESIGN 24-28
CHAPTER:4 CODING AND DEVELOPMENT
4.1. SOURCE CODE 29-103
CHAPTER:5 TESTING AND IMPLEMENTATION
5.1. INTRODUCTION TO TESTING 104
5.2. TYPES OF TESTING USED 111-128
CHAPTER:6 CONCLUSION 129
6.1. FUTURE ENHANSMENT 130
BIBLIOGRAPHY 135
01.INTRODUCTION
RTO Management System

Vehicle information management system
Objective
This is RTO office management system created for RTO to maintain all records like vehicle
registration such as 2 wheelers, 3 wheelers registration, LMV, HMV, Learning licenses and
permanent licenses etc. These are the main activities of RTO office. This application manages all
the data of the registered user and his vehicles.In RTO Management System administrator has
the power to verify the data entered by the user, processing of data and provide appropriate
solutions.
Users of the system
1-Users
2- RTO Officer
3-Admin
High Level Requirements
1-Any person who have been authorized by the administrator. An authorized user should have a
user name and password to access detailed information from the site excluding or accessing
general information in shared, public pages.
2-User is the person who gets the full benefits of this application. By introducing the new system
we have been organized some striking felicities. Registration of vehicle through online.Complete
RTO facilities are available .This system will maintain and manage day to day operation very
smoothly with minimum errors.This software provides facility for searching a particular vehicles
detail.
4-Vehicle registration module: Two wheeler, Three Wheeler, Light motor Vehicle (LMV) and
Heavy motor vehicle (HMV) and others. To register a vehicle through this software user has to
provide all the details of vehicles including vehicle number, makers name, body type, Vehicle
owner, address, chassis number, registration date, etc
5-Licence module: Learner license, driving license, Changing address of license. It has options
to apply the license and renew the license.
6-Tax module: This module is used to entry the records of tax.manager and user should be able
to view tax record.
7-Renewal module: This module helps to renew vehicle registration records.
8-Transfer module: This is a vehicle transfer module which is used to change the ownership of
the vehicle. Manager should be able to update vehicle owner details.
9-Application should be able to maintain admin panel where admin can view, search and Update
any information.
Non Functional Requirements
1. Internet Explorer 9.0 above browser compatibility
2. Proper user-id/password based user authentication to allow access to the system.
Technical Requirements
1.Create a detailed UML diagram (Component, Sequence, and Class) for the OSMS and its
subcomponents using RSA7.5.
2. Deploy the solution using Web-Sphere Application Server tool-kit which serves dual purpose
i.e. as an IDE as well as an application server.
3. DB2 Database.
1.1 SYSTEM ANALYSIS

THE STUDY OF THE SYSTEM
• To conduct studies and analyses of an operational and technological nature, and
• To promote the exchange and development of methods and tools for operational analysis
as applied to defense problems.
Logical design
The logical design of a system pertains to an abstract representation of the data flows,
inputs and outputs of the system. This is often conducted via modeling, using an over-abstract
(and sometimes graphical) model of the actual system. In the context of systems design are
included. Logical design includes ER Diagrams i.e. Entity Relationship Diagrams
Physical design
The physical design relates to the actual input and output processes of the system. This is
laid down in terms of how data is input into a system, how it is verified / authenticated, how it is
processed, and how it is displayed as output. In Physical design, following requirements about
the system are decided.
• Input requirement,
• Output requirements,
• Storage requirements,
• Processing Requirements,
• System control and backup or recovery.
Put another way, the physical portion of systems design can generally be broken down into three
sub-tasks:
• User Interface Design
• Data Design
• Process Design
User Interface Design is concerned with how users add information to the system and
with how the system presents information back to them. Data Design is concerned with how the
data is represented and stored within the system. Finally, Process Design is concerned with how
data moves through the system, and with how and where it is validated, secured and/or
transformed as it flows into, through and out of the system. At the end of the systems design
phase, documentation describing the three sub-tasks is produced and made available for use in
the next phase.
Physical design, in this context, does not refer to the tangible physical design of an
information system. To use an analogy, a personal computer's physical design involves input via
a keyboard, processing within the CPU, and output via a monitor, printer, etc. It would not
concern the actual layout of the tangible hardware, which for a PC would be a monitor, CPU,
motherboard, hard drive, modems, video/graphics cards, USB slots, etc. It involves a detailed
design of a user and a product database structure processor and a control processor. The H/S
personal specification is developed for the proposed system.
1.2 INPUT & OUTPUT REPRESENTATION

Input Design
The input design is the link between the information system and the user. It comprises the
developing specification and procedures for data preparation and those steps are necessary to put
transaction data in to a usable form for processing can be achieved by inspecting the computer to
read data from a written or printed document or it can occur by having people keying the data
directly into the system. The design of input focuses on controlling the amount of input required,
controlling the errors, avoiding delay, avoiding extra steps and keeping the process simple. The
input is designed in such a way so that it provides security and ease of use with retaining the
privacy. Input Design considered the following things:
• What data should be given as input?
• How the data should be arranged or coded?
• The dialog to guide the operating personnel in providing input.
• Methods for preparing input validations and steps to follow when error occur.
Objectives
Input Design is the process of converting a user-oriented description of the input into a
computer-based system. This design is important to avoid errors in the data input process and
show the correct direction to the management for getting correct information from the
computerized system.
It is achieved by creating user-friendly screens for the data entry to handle large volume
of data. The goal of designing input is to make data entry easier and to be free from errors. The
data entry screen is designed in such a way that all the data manipulates can be performed. It also
provides record viewing facilities.
When the data is entered it will check for its validity. Data can be entered with the help of
screens. Appropriate messages are provided as when needed so that the user will not be in maize
of instant. Thus the objective of input design is to create an input layout that is easy to follow
Output Design
A quality output is one, which meets the requirements of the end user and presents the
information clearly. In any system results of processing are communicated to the users and to
other system through outputs. In output design it is determined how the information is to be
displaced for immediate need and also the hard copy output. It is the most important and direct
source information to the user. Efficient and intelligent output design improves the system‟s
relationship to help user decision-making.
• Designing computer output should proceed in an organized, well thought out manner; the
right output must be developed while ensuring that each output element is designed so
that people will find the system can use easily and effectively. When analysis design
computer output, they should Identify the specific output that is needed to meet the
requirements.
• Select methods for presenting information.
• Create document, report, or other formats that contain information produced by the
system.
The output form of an information system should accomplish one or more of the following
objectives.
• Convey information about past activities, current status or projections of the future.
• Signal important events, opportunities, problems, or warnings.
• Trigger an action.
• Confirm an action.
1.3 PROCESS MODEL USED WITH JUSTIFICATION

SDLC is nothing but Software Development Life Cycle. It is a standard which is used by
software industry to develop good software.
SDLC (Spiral Model):

Stages of SDLC:
Requirement Gathering and Analysis
• Designing
• Coding
• Testing
• Deployment
1.4 Requirements Definition Stage and Analysis:
The requirements gathering process takes as its input the goals identified in the high-level
requirements section of the project plan. Each goal will be refined into a set of one or more
requirements. These requirements define the major functions of the intended application, define
operational data areas and reference data areas, and define the initial data entities. Major
functions include critical processes to be managed, as well as mission critical inputs, outputs and
reports. A user class hierarchy is developed and associated with these major functions, data
areas, and data entities. Each of these definitions is termed a Requirement. Requirements are
identified by unique requirement identifiers and, at minimum, contain a requirement title and
textual description.
These requirements are fully described in the primary deliverables for this stage: the
Requirements Document and the Requirements Traceability Matrix (RTM). the requirements
document contains complete descriptions of each requirement, including diagrams and
references to external documents as necessary. Note that detailed listings of database tables and
fields are not included in the requirements document. The title of each requirement is also placed
into the first version of the RTM, along with the title of each goal from the project plan. The
purpose of the RTM is to show that the product components developed during each stage of the
software development lifecycle are formally connected to the components developed in prior
stages.
In the requirements stage, the RTM consists of a list of high-level requirements, or goals,
by title, with a listing of associated requirements for each goal, listed by requirement title. In this
hierarchical listing, the RTM shows that each requirement developed during this stage is
formally linked to a specific product goal. In this format, each requirement can be traced to a
specific product goal, hence the term requirements traceability. The outputs of the requirements
definition stage include the requirements
document, the RTM, and an updated project plan.
Design Stage:
The design stage takes as its initial input the requirements identified in the approved
requirements document. For each requirement, a set of one or more design elements will be
produced as a result of interviews, workshops, and/or prototype efforts. Design elements
describe the desired software features in detail, and generally include functional hierarchy
diagrams, screen layout diagrams, tables of business rules, business process diagrams, pseudo
code, and a complete entity-relationship diagram with a full data dictionary. These design
elements are intended to describe the software in sufficient detail that skilled programmers may
develop the software with minimal additional input.
When the design document is finalized and accepted, the RTM is updated to show that
each design element is formally associated with a specific requirement. The outputs of the design
stage are the design document, an updated RTM, and an updated project plan.
Development Stage:
The development stage takes as its primary input the design elements described in the
approved design document. For each design element, a set of one or more software artifacts will
be produced. Software artifacts include but are not limited to menus, dialogs, data management
forms, data reporting formats, and specialized procedures and functions. Appropriate test cases
will be developed for each set of functionally related software artifacts, and an online help
system will be developed to guide users in their interactions with the software.
The RTM will be updated to show that each developed artifact is linked to a specific design
element, and that each developed artifact has one or more corresponding test case items. At this
point, the RTM is in its final configuration. The outputs of the development stage include a fully
functional set of software that satisfies the requirements and design elements previously
documented, an online help system that describes the operation of the software, an
implementation map that identifies the primary code entry points for all major system functions,
a test plan that describes the test cases to be used to validate the correctness and completeness of
the software, an updated RTM, and an updated project plan.
Integration & Test Stage:

During the integration and test stage, the software artifacts, online help, and test data are
migrated from the development environment to a separate test environment. At this point, all test
cases are run to verify the correctness and completeness of the software. Successful execution of
the test suite confirms a robust and complete migration capability.
During this stage, reference data is finalized for production use and production users are
identified and linked to their appropriate roles. The final reference data (or links to reference data
source files) and production user list are compiled into
the Production Initiation Plan.
The outputs of the integration and test stage include an integrated set of software, an
online help system, an implementation map, a production initiation plan that describes reference
data and production users, an acceptance plan which contains the final suite of test cases, and an
updated project plan.
Installation & Acceptance Stage
During the installation and acceptance stage, the software artifacts, online help, and
initial production data are loaded onto the production server. At this point, all test cases are run
to verify the correctness and completeness of the software. Successful execution of the test suite
is a prerequisite to acceptance of the software by the customer.
After customer personnel have verified that the initial production data load is correct and
the test suite has been executed with satisfactory results, the customer formally accepts the
delivery of the software.
The primary outputs of the installation and acceptance stage include a production
application, a completed acceptance test suite, and a memorandum of customer acceptance of the
software. Finally, the PDR enters the last of the actual labor data into the project schedule and
locks the project as a permanent project record. At this point the PDR "locks" the project by
archiving all software items, the implementation map, the source code, and the documentation
for future reference.
1.5 SYSTEM ARCHITECTURE
Architecture Flow:
Below architecture diagram represents mainly flow of request from the users to database
through servers. In this scenario overall system is designed in three tiers separately using three
layers called presentation layer, business layer, data link layer. This project was developed using
3-tier architecture.
3-Tier Architecture:
The three-tier software architecture (a three layer architecture) emerged in the 1990s to
overcome the limitations of the two-tier architecture. The third tier (middle tier server) is
between the user interface (client) and the data management (server) components. This middle
tier provides process management where business logic and rules are executed and can
accommodate hundreds of users (as compared to only 100 users with the two tier architecture) by
providing functions such as queuing, application execution, and database staging.
The three tier architecture is used when an effective distributed client/server design is
needed that provides (when compared to the two tier) increased performance, flexibility,
maintainability, reusability, and scalability, while hiding the complexity of distributed processing
from the user. These characteristics have made three layer architectures a popular choice for
Internet applications and net-centric information systems
Advantages of Three-Tier:
• Separates functionality from presentation.
• Clear separation - better understanding.
• Changes limited to well define components.
• Can be running on WWW.
• Effective network performance.

02. FEASIBILITY STUDY
2.1 FEASIBILITY STUDY:
Feasibility study is conducted once the problem is clearly understood. The feasibility
study which is a high level capsule version of the entire system analysis and design process. The
objective is to determine whether the proposed system is feasible or not and it helps us to the
minimum expense of how to solve the problem and to determine, if the Problem is worth solving.
The following are the three important tests that have been carried out for feasibility study.
Technical feasibility:
In the technical feasibility study, one has to test whether the proposed system can be
developed using existing technology or not. It is planned to implement the proposed system in
JSP. The project entitled is technically feasible because of the following reasons.
• All necessary technology exists to develop the system.
• The existing system is so flexible that it can be developed further.
Economic feasibility:
As a part of this, the costs and benefits associated with the proposed systems are to be
compared. The project is economically feasible only if tangible and intangible benefits outweigh
the cost. We can say the proposed system is feasible based on the following grounds.
• The cost of developing the full system is reasonable.

• The cost of hardware and software for the application is less.
Operational feasibility:
The project is operationally feasible because there is sufficient support from the project
management and the users of the proposed system .Proposed system definitely does not harm
and will not produce the bad results and no problem will arise after implementation of the
system.
User-friendly
Customer will use the forms for their various transaction i.e. for adding new routes,
viewing the routes details. Also the Customer wants the reports to view the various transactions
based on the constraints. Theses forms and reports are generated as user-friendly to the Client.
Reliability
The package wills pick-up current transactions on line. Regarding the old transactions,
User will enter them in to the system.
Security
The web server and database server should be protected from hacking, virus etc.
Availability
This software will be available always.
2.2 SYSTEM CONFIGURATION:

Hardware requirements:
Processer : Any Update Processer
Ram : Min 1 GB
Hard Disk : Min 100 GB
Software requirements:
Operating System : Windows family
Technology : Java (1.7/1.8)
Web Technologies : Html, Html-5, JavaScript, CSS.
Web Server : Tomcat 7/8
Server side Lang : J2EE
Database : DB-2
UML : Star UML
DFD : DFD Drawer
Implemented by
Development team : Cloud Technologies
Website : http://www.cloudstechnologies.in
Contact : 8121953811, 040-65511811
2.3 Software over View:

JAVA
History
Java is a programming language created by James Gosling from Sun Microsystems in 1991. The
first publicly available version of Java (Java 1.0) was released in 1995. Over time new enhanced
versions of Java have been released. The current version of Java is Java 1.7 which is also known
as Java 7.
From the Java programming language the Java platform evolved. The Java platform
allows that the program code is written in other languages than the Java programming language
and still runs on the Java virtual machine.
Java Virtual machine

The Java virtual machine (JVM) is a software implementation of a computer that
executes programs like a real machine. The Java virtual machine is written specifically for a
specific operating system, e.g. for Linux a special implementation is required as well as for
Windows.
Java programs are compiled by the Java compiler into so-called byte code. The Java virtual
machine interprets this byte code and executes the Java program.
Java Runtime Environment vs. Java Development Kit

Java comes in two flavors, the Java Runtime Environment (JRE) and the Java
Development Kit (JDK). The Java runtime environment (JRE) consists of the JVM and the Java
class libraries and contains the necessary functionality to start Java programs. The JDK contains
in addition the development tools necessary to create Java programs. The JDK consists therefore
of a Java compiler, the Java virtual machine, and the Java class libraries.
The Java Development Kit (JDK) is provided by Sun Microsystems as a basic

development environment for Java. The JDK provides similar facilities to the cc compiler for C
programs, plus a JVM simulator and some additional facilities such as a debugger. To use the
JDK, programs are constructed as ascii text files (by using an editor, for example). The program
files are compiled, which translates the Java code to JVM bytecode in .class files.
Each public class must be in a file having the class name (case sensitive on Unix)
followed by a .java suffix. There may be any number of classes defined in a .java file, but the
compiler produces a separate .class file for each class. A file is compiled with the javac
command, which is similar to the cc (or gcc) command. A class is executed (or more precisely,
the method main in a class is executed) by the command java with the class name (not the .class
file) as the parameter. Thus, for example, to compile the program in file Hi.java, we would use
the command
javac Hi.java
and then to execute the program we would use the command
java Hi
Both compile-time and execution-time (exceptions) error messages include the file name and line
where the error occurred. No .class file is produced if there is a compile-time error.
Characteristics of Java
The target of Java is to write a program once and then run this program on multiple operating
systems.
Java has the following properties:
• Platform independent: Java programs use the Java virtual machine as abstraction and do
not access the operating system directly. This makes Java programs highly portable. A
Java program which is standard complaint and follows certain rules can run unmodified
on all supported platforms, e.g. Windows or Linux.
• Object-orientated programming language: Except the primitive data types, all elements in
Java are objects.
• Strongly-typed programming language: Java is strongly-typed, e.g. the types of the used
variables must be pre-defined and conversion to other objects is relatively strict, e.g. must
be done in most cases by the programmer.
• Interpreted and compiled language: Java source code is transferred into the byte code
format which does not depend on the target platform. These byte code instructions will be
interpreted by the Java Virtual machine (JVM). The JVM contains a so called Hotspot-
Compiler which translates performance critical byte code instructions into native code
instructions.
• Automatic memory management: Java manages the memory allocation and de-allocation
for creating new objects. The program does not have direct access to the memory. The
so-called garbage collector deletes automatically objects to which no active pointer
exists.
The Java syntax is similar to C++. Java is case sensitive, e.g. the variables my Value and my
value will be treated as different variables.
Development Process with Java

The programmer writes Java source code in a text editor which supports plain text. Normally the
programmer uses an Integrated Development Environment (IDE) for programming. An IDE
supports the programmer in the task of writing code, e.g. it provides auto-formatting of the
source code, highlighting of the important keywords, etc.
At some point the programmer (or the IDE) calls the Java compiler (javac). The Java compiler
creates the byte code instructions. . These instructions are stored in .class files and can be
executed by the Java Virtual Machine.
J2SE
J2SE is a collection of Java Programming Language API (Application programming
interface) that is very useful to many Java platform programs. It is derived from one of the most
dynamic programming language known as "JAVA"
J2SE is a collection of Java Programming Language API (Application programming

interface) that is very useful to many Java platform programs. It is derived from one of the most
dynamic programming language known as "JAVA" and one of its three basic editions of Java
known as Java standard edition being used for writing Applets and other web based applications.
J2SE platform has been developed under the Java umbrella and primarily used for writing
applets and other Java-based applications. It is mostly used for individual computers. Applet is a
type of fast-working subroutine of Java that is platform-independent but work within other
frameworks. It is a mini application that perform a variety of functions, large and small, ordinary
and dynamic, within the framework of larger applications.
J2SE provide the facility to users to see Flash movies or hear audio files by clicking on a
Web page link. As the user clicks, page goes into the browser environment and begin the process
of launching application-within-an-application to play the requested video or sound application.
So many online games are being developed on J2SE. JavaBeans can also be developed by using
J2SE.
J2EE
Java 2 Platform Enterprise Edition. J2EE is a platform-independent, Java-centric environment
from Sun for developing, building and deploying Web-based enterprise applications online. The
J2EE platform consists of a set of services, APIs, and protocols that provide the functionality for
developing multitier, Web-based applications.
Key features and services of J2EE:
• At the client tier, J2EE supports pure HTML, as well as Java applets or applications. It
relies on Java Server Pages and servlet code to create HTML or other formatted data for
the client.
• Enterprise JavaBeans (EJBs) provide another layer where the platform's logic is stored.
An EJB server provides functions such as threading, concurrency, security and memory
management. These services are transparent to the author.
• Java Database Connectivity (JDBC), which is the Java equivalent to ODBC, is the
standard interface for Java databases.
• The Java servlet API enhances consistency for developers without requiring a graphical
user interface.
2.4 JDBC
JDBC stands for Java Database Connectivity, which is a standard Java API for database-
independent connectivity between the Java programming language and a wide range of
databases.
The JDBC library includes APIs for each of the tasks commonly associated with database
usage:
• Making a connection to a database
• Creating SQL or MySQL statements
• Executing that SQL or MySQL queries in the database

• Viewing & Modifying the resulting records
Fundamentally, JDBC is a specification that provides a complete set of interfaces that

allows for portable access to an underlying database. Java can be used to write different types of
executables, such as:
• Java Applications
• Java Applets
• Java Servlets
• Java ServerPages (JSPs)
• Enterprise JavaBeans (EJBs)
All of these different executables are able to use a JDBC driver to access a database and
take advantage of the stored data.
JDBC provides the same capabilities as ODBC, allowing Java programs to contain
database-independent code.
JDBC Architecture:
The JDBC API supports both two-tier and three-tier processing models for database
access but in general JDBC Architecture consists of two layers:
• JDBC API: This provides the application-to-JDBC Manager connection.
• JDBC Driver API: This supports the JDBC Manager-to-Driver Connection.
The JDBC API uses a driver manager and database-specific drivers to provide transparent
connectivity to heterogeneous databases.The JDBC driver manager ensures that the correct
driver is used to access each data source. The driver manager is capable of supporting multiple
concurrent drivers connected to multiple heterogeneous databases.
Following is the architectural diagram, which shows the location of the driver manager
with respect to the JDBC drivers and the Java application.
Common JDBC Components:
The JDBC API provides the following interfaces and classes:
• DriverManager: This class manages a list of database drivers. Matches connection

requests from the java application with the proper database driver using communication
subprotocol. The first driver that recognizes a certain subprotocol under JDBC will be
used to establish a database Connection.
• Driver: This interface handles the communications with the database server. You will
interact directly with Driver objects very rarely. Instead, you use DriverManager objects,
which manages objects of this type. It also abstracts the details associated with working
with Driver objects
• Connection : This interface with all methods for contacting a database. The connection
object represents communication context, i.e., all communication with database is
through connection object only.
• Statement : You use objects created from this interface to submit the SQL statements to
the database. Some derived interfaces accept parameters in addition to executing stored
procedures.
• ResultSet: These objects hold data retrieved from a database after you execute an SQL
query using Statement objects. It acts as an iterator to allow you to move through its data.
• SQLException: This class handles any errors that occur in a database application.
What is JDBC Driver?
JDBC drivers implement the defined interfaces in the JDBC API for interacting with your
database server.For example, using JDBC drivers enable you to open database connections and
to interact with it by sending SQL or database commands then receiving results with Java.
The Java.sql package that ships with JDK contains various classes with their behaviours
defined and their actual implementaions are done in third-party drivers. A third party vendor
implements the java.sql.Driver interface in their database driver.
JDBC Drivers Types:
JDBC driver implementations vary because of the wide variety of operating systems and
hardware platforms in which Java operates. Sun has divided the implementation types into four
categories, Types 1, 2, 3, and 4, which is explained below:
Type 1: JDBC-ODBC Bridge Driver:
In a Type 1 driver, a JDBC bridge is used to access ODBC drivers installed on each client
machine. Using ODBC requires configuring on your system a Data Source Name (DSN) that
represents the target database.
When Java first came out, this was a useful driver because most databases only supported
ODBC access but now this type of driver is recommended only for experimental use or when no
other alternative is available.
The JDBC-ODBC bridge that comes with JDK 1.2 is a good example of this kind of driver.
Type 2: JDBC-Native API:
In a Type 2 driver, JDBC API calls are converted into native C/C++ API calls which are unique
to the database. These drivers typically provided by the database vendors and used in the same
manner as the JDBC-ODBC Bridge, the vendor-specific driver must be installed on each client
machine.
If we change the Database we have to change the native API as it is specific to a database and
they are mostly obsolete now but you may realize some speed increase with a Type 2 driver,
because it eliminates ODBC's overhead.
The Oracle Call Interface (OCI) driver is an example of a Type 2 driver.
Type 3: JDBC-Net pure Java:
In a Type 3 driver, a three-tier approach is used to accessing databases. The JDBC clients
use standard network sockets to communicate with an middleware application server. The socket
information is then translated by the middleware application server into the call format required
by the DBMS, and forwarded to the database server.
This kind of driver is extremely flexible, since it requires no code installed on the client and a
single driver can actually provide access to multiple databases.
You can think of the application server as a JDBC "proxy," meaning that it makes calls
for the client application. As a result, you need some knowledge of the application server's
configuration in order to effectively use this driver type.
Your application server might use a Type 1, 2, or 4 driver to communicate with the
database, understanding the nuances will prove helpful.
Type 4: 100% pure Java:
In a Type 4 driver, a pure Java-based driver that communicates directly with vendor's
database through socket connection. This is the highest performance driver available for the
database and is usually provided by the vendor itself. This kind of driver is extremely flexible,
you don't need to install special software on the client or server. Further, these drivers can be
downloaded dynamically.s
MySQL's Connector/J driver is a Type 4 driver. Because of the proprietary nature of their
network protocols, database vendors usually supply type 4 drivers.
JDBC Database Connections
After you've installed the appropriate driver, it's time to establish a database connection using
JDBC.
The programming involved to establish a JDBC connection is fairly simple. Here are these
simple four steps:
• Import JDBC Packages: Add import statements to your Java program to import
required classes in your Java code.
• Register JDBC Driver: This step causes the JVM to load the desired driver
implementation into memory so it can fulfill your JDBC requests.
• Database URL Formulation: This is to create a properly formatted address that points
to the database to which you wish to connect.
• Create Connection Object: Finally, code a call to the DriverManager object's

getConnection( ) method to establish actual database connection.
Import JDBC Packages:
The Import statements tell the Java compiler where to find the classes you reference in your
code and are placed at the very beginning of your source code.
To use the standard JDBC package, which allows you to select, insert, update, and delete data in
SQL tables, add the following imports to your source code:
import java.sql.* ; // for standard JDBC programs
import java.math.* ; // for BigDecimal and BigInteger support
Register JDBC Driver:

You must register the your driver in your program before you use it. Registering the driver is the
process by which the Oracle driver's class file is loaded into memory so it can be utilized as an
implementation of the JDBC interfaces.
You need to do this registration only once in your program. You can register a driver in one of
two ways.
Approach (I) - Class.forName():

The most common approach to register a driver is to use Java's Class.forName() method to
dynamically load the driver's class file into memory, which automatically registers it. This
method is preferable because it allows you to make the driver registration configurable and
portable.
The following example uses Class.forName( ) to register the Oracle driver:
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
catch(ClassNotFoundException ex) {
System.out.println("Error: unable to load driver class!");
System.exit(1);
}
You can use getInstance() method to work around noncompliant JVMs, but then you'll have to
code for two extra Exceptions as follows:
try {
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
System.exit(1);
catch(IllegalAccessException ex) {
System.out.println("Error: access problem while loading!");
System.exit(2);
catch(InstantiationException ex) {
System.out.println("Error: unable to instantiate driver!");
System.exit(3);
Approach (II) - DriverManager.registerDriver():

The second approach you can use to register a driver is to use the static
DriverManager.registerDriver() method.
You should use the registerDriver() method if you are using a non-JDK compliant JVM, such as
the one provided by Microsoft.
The following example uses register Driver() to register the Oracle driver:
try {
Driver myDriver = new oracle.jdbc.driver.OracleDriver();
DriverManager.registerDriver( myDriver );
}
System.exit(1);
Database URL Formulation:

After you've loaded the driver, you can establish a connection using the
DriverManager.getConnection() method. For easy reference, let me list the three overloaded
DriverManager.getConnection() methods:
• getConnection(String url)
• getConnection(String url, Properties prop)
• getConnection(String url, String user, String password)
Create Connection Object:

Using a database URL with a username and password:
I listed down three forms of DriverManager.getConnection() method to create a connection

object. The most commonly used form of getConnection() requires you to pass a database URL,
a username, and a password:
Assuming you are using Oracle's thin driver, you'll specify a host:port:databaseName value for
the database portion of the URL.
If you have a host at TCP/IP address 192.0.0.1 with a host name of amrood, and your Oracle
listener is configured to listen on port 1521, and your database name is EMP, then complete
database URL would then be:
jdbc:oracle:thin:@amrood:1521:EMP
Now you have to call getConnection() method with appropriate username and password to get a
Connection object as follows:
String URL = "jdbc:oracle:thin:@amrood:1521:EMP";
String USER = "username";

String PASS = "password"
Connection conn = DriverManager.getConnection(URL, USER, PASS);
Using only a database URL:

A second form of the DriverManager.getConnection( ) method requires only a database
URL:
DriverManager.getConnection(String url);
However, in this case, the database URL includes the username and password and has the
following general form:
jdbc:oracle:driver:username/password@database
So the above connection can be created as follows:
String URL = "jdbc:oracle:thin:username/password@amrood:1521:EMP";
Connection conn = DriverManager.getConnection(URL);
Using a database URL and a Properties object:
A third form of the DriverManager.getConnection( ) method requires a database URL and a

Properties object:
DriverManager.getConnection(String url, Properties info);
A Properties object holds a set of keyword-value pairs. It's used to pass driver properties to the
driver during a call to the getConnection() method.
To make the same connection made by the previous examples, use the following code:
import java.util.*;
String URL = "jdbc:oracle:thin:@amrood:1521:EMP";
Properties info = new Properties( );
info.put( "user", "username" );
info.put( "password","password");
Connection conn = DriverManager.getConnection(URL, info);

Closing JDBC connections:
At the end of your JDBC program, it is required explicitly close all the connections to the
database to end each database session. However, if you forget, Java's garbage collector will close
the connection when it cleans up stale objects.
Relying on garbage collection, especially in database programming, is very poor programming

practice. You should make a habit of always closing the connection with the close() method
associated with connection object.
To ensure that a connection is closed, you could provide a finally block in your code. A finally
block always executes, regardless if an exception occurs or not.
To close above opened connection you should call close() method as follows:
conn.close();
Explicitly closing a connection conserves DBMS resources, which will make your database
administrator happy.
03. JAVA
3.1 JAVA SRIPT

Java Script is Netscape‟s cross–platform, object-based scripting language for client server
application. JavaScript is mainly used as a client side scripting language. This means that
JavaScript code is written into an HTML page. When a user requests an HTML page with
JavaScript in it, the script is sent to the browser and it's up to the browser to do something with
it. JavaScript can be used in other contexts than a Web browser. Netscape created server-side
JavaScript as a CGI-language that can do roughly the same as Perl or ASP.
Fortunately most browsers can handle JavaScript nowadays, but of course some browsers
do not support some bits of script.
Types of Java Script:

a. Navigator Java Script also called client-side Java Script.
b. Live Wire Java Script also called server-side Java Script.
Using Java Script, dynamic HTML pages can be created that process user input and
maintain persistent data using special objects, files and relational databases. Browser interprets
JavaScript statements embedded in an HTML page. Netscape Navigator 2.0 and Internet
Explorer 3.0 versions and later recognize Java Script. Through JavaScript Live Connect
functionally, application can access Java and CORBA distributed-object applications. Navigator
3.0 and later versions supports Live Connect.
Features of JavaScript (JS):

• Browser interprets JavaScript.
• JavaScript is object based and uses built-in, extensible objects and have no classes or
inheritance
• JavaScript is loosely typed language
• In JavaScript object reference are checked at runtime
• JavaScript is designed to supplement the capabilities of HTML with script that are
capable of responding to web pages events. JSP has access to some extent of aspects
of the web browser window.
• JavaScript control browser and content but cannot draw graphics or perform
networking.
Client side JavaScript features:

Client–side JavaScript has expressly been developed for use in a web browser in
conjunction with HTML pages. This has certain consequences for security.
• JavaScript cannot read files from or write them to the file system on the computer.
This would be a clear security hazard
• JavaScript cannot execute any other programs. This would also be unacceptable.
• JavaScript cannot establish any connection to whatever computer, except to download
a new HTML page or to send mail. This, too, would create unacceptable hazards.
The Client-Side JavaScript also has the following features:

• Controls Document‟s appearance and content
• Control the browser
• Interact with the HTML forms
• Interact with the user
• Read and write client state with cookies
Server- Side JavaScript Features:
• Embedded in HTML page
• Executed at the server
• Pre-complied for faster response
• Access to Server-side objects
• Encapsulation of the request
3.2 Apache Tomcat Server

Apache Tomcat is a web container developed at the Apache Software Foundation (ASF).
Tomcat implements the servlet and the Java Server Pages (JSP) specifications from Sun
Microsystems, providing an environment for Java code to run in cooperation with a web server.
It adds tools for configuration and management but can also be configured by editing
configuration files that are normally XML-formatted. Tomcat includes its own HTTP server
internally.
Environment:
Tomcat is a web server that supports servlets and JSPs. The accompanying Tomcat Jasper
compiler compiles JSPs into servlets. The Tomcat servlet engine is often used in combination
with an Apache HTTP Server or other web servers. Tomcat can also function as an independent
web server. Earlier in its development, the perception existed that standalone Tomcat was only
suitable for development environments and other environments with minimal requirements for
speed and transaction handling. However, that perception no longer exists; Tomcat is
increasingly used as a standalone web server in high-traffic, high-availability environments.
Tomcat is cross-platform, running on any operating system that has a Java Runtime
Environment. The following properties can be specified, either as system properties, or by using
a deployer. Properties file located in the root folder of the deployer package:
 Build: The build folder used will be, by default, ${build}/webapp${path}. After the
end of the execution of the compile target, the web application WAR will be located
at ${build}/webapp${path}.war.
 Webapp: Folder containing the expanded web application which will be compiled and
validated. By default, the folder is myapp.
 Path: Deployed context path of the web application, by default /myapp.
 URL: Absolute URL to the manager web application of a running Tomcat server,
which will be used to deploy and undeploy the web application. By default, the
deployer will attempt to access a Tomcat instance running on local host, at
http://localhost:8080/manager.
 Username: Username to be used to connect to the Tomcat manager.
 Password: Password to be used to connect to the Tomcat manager
A web application which is programmatically developed by the developer is stored in the

webapps folder and WEB-INF folder also saved in that location which consists of folder named
classes which supports to run application automatically.
The deployer package includes a ready to use Ant script, with the following targets:
 compile (default): Compile and validate the web application. This can be used
standalone, and does not need a running Tomcat server. The compiled application
will only run on the associated Tomcat 5.0.x server release, and is not guaranteed to
work on another Tomcat release, as the code generated by Jasper depends on its
runtime component. It should also be noted that this target will also compile
automatically any Java source file located in the /WEB-INF/classes folder of the web
application.
 deploy: Deploy a web application (compiled or not) to a Tomcat server
 undeploy: Undeploy a web application
 Start: Start web application
 reload: Reload web application
 Stop: Stop web application
3.3 JAVA SERVER PAGES

Introduction:
Jsp technology enables you to mix regular static html with dynamically generated content
from servlets. Separating the static html from the dynamic content provides a number of benefits
over servlets alone.
Why use JSP:
Jsp is easy to learn and allows developers to quickly produce wed sites and application in
an open and standard way. Jsp is based on java, an object-oriented language. Jsp offers a robust
platform for web development.
Main reasons to Jsp:
• Multi platform
• Component reuse by using java beans and Ejb
• Advantages if java
We can take one Jsp file and move it to another platform, web server or Jsp servlet engine.
JSP compared to ASP:
Jsp and Asp are fairly similar in the functionality that they provide. Jsp may have
slightly higher learning curve. Both allow embedded code in an html page, session variables
Platform i.e., NT, JSP can operate on any platform that conforms to the J2EE specification. Jsp
allow component reuse by using JavaBeans and Ejbs. Asp provides the use of Com/activeX
controls.
JSP compared to servlets:
A servlet is java class that provides special server side service. It is hard to write HTML
code in servlets. In servlets you need to have lots of println statement to generate HTML.
Description:
JSP looks like html, but they get compiled into java servlets the first time they are
invoked. The resulting servlet is a combination of the html from the jsp file and embedded
dynamic content specified by the new tags. That is not to say that jsp must contain html. Some of
them contain only java code; this is particularly useful when the jsp is responsible for a particular
task like maintaining application flow.
Everything in Jsp can be broken into 2 categories:
• Elements that are processed on the server.
• Template data or everything other than elements that the engine processing the Jsp
ignores.
A Jsp page is executed by a Jsp engine or container, which is installed on a web server, or
on an application server. When the client asks for a jsp resource the engine wraps up that request
and response object to incorporate the communication with the client. The container then wraps
up the underlying layer for a jsp that of a servlet implementation. The abstractions of the request
and response are the same as javax.servlet.ServletRequest and javax.servlet.ServletReesponse
respectively.
JSP Architecture:
Jsp are built on top of sun‟s servlet technology. Jsp is essentially an html page with
special jsp tags embedded. These jsp tags can contain java code. The jsp file extension is .jsp
rather than .htm or .html. The jsp engine parses the .jsp and creates a java servlet source file. It
then compiles the source file into a class file; this is done the first time and this why the jsp is
probably slower the first time it is accessed. Any time after this, the special compiled servlet is
executed and is therefore returns faster.
Steps required to JSP request:
• The user goes to a web site made using jsp. The user goes to a jsp page. The web
browser makes the request via the internet.
• The jsp request gets sent to the web server
• The web server recognizes that the file required is special (.jsp), therefore passes the
jsp file to the jsp servlet engine.
• If the jsp file has been called the first time, the jsp file is parsed, otherwise go to step
7
• The next step is to generate a special servlet form the jsp file. The entire html
required is converted to println statements.
• The servlet source code is compiled into a class
• The servlet is instantiated, calling the init and service methods
• Html from the servlet output is sent via the internet
• Html results are displayed on the user‟s web browser.
Servlets are server-side java programs that can be deployed on a web server.
The servlet interface provides the basic frame work for coding servlets.
Java Server Pages, SQL, HTML Forms and Databases
This section examines how to communicate with a database from Java. We have already
seen how to interface an HTML Form and a JSP. Now e has to see how that JSP can talk to a
database. The objectives of this section are to understand how to:
• Administratively register databases.
• Connect a JSP to an Access database.
• Insert records in a database using JSP.
• Inserting data from HTML Form in a database using JSP.
• Delete Records from Database based on Criteria from HTML Form.
• Retrieve data from a database using JSP – result sets.
• Apply SQL operations like sort, create table, remove table, delete, and Access-based
arithmetic functions.
JSP Declarations:
Used to define page level variables and methods are placed with in the <%!and %> tags
and always end with a semicolon.
Example:
<%!
Int I=0;
Int j=0;
Int z=0 ;%>
JSP Scriptlets:
Consists of valid code snippets enclosed with in the <% and %> JSP tags.
Example:
To accept the user name and display the name 10 times:
<%@ page import=”java.util.*” %>
<%@ page import=”java” %>
<HTML><BODY>
<%out.println (“<HTML>”);
out.println (“<BODY>”);
out.println (“<BODY>”);
out.println (“<HTML>”);%>
</BODY></HTML>
JSP Expressions:
Used to directly insert values into the output
Example :< %=msg %>
JSP Implicit Objects:

Are predefined variables that can be included in JSP expressions and Scriplets can be
Created.
• Implicitly by using directives.
• Explicitly by using standard actions.
• Directly by declaring objects with in scriptlets.
Include variables such as
PAGE: To represent the current instance of the jsp page.
REQUEST: To represent an object of HTTP Servlet request used to retrieve the request
data.
RESPONSE: To represent an object of HTTP servlet response used to write the
HTML response output.
JSP Actions:
<jsp: getProperty>: To retrieve the property of the specified bean and direct it as
output.
Attributes used are: Name and Property.
<jsp: setProperty>: To set the property of specified bean.
Attributes used are: Name, Property, Value and Param.
<jsp: forward>: To forward a request to a different page.
Attribute used is Page.
<jsp: param>: Used as a sub attribute with jsp: include and jsp: forward to passadditional
request parameters.
Attributes used are Name and Value.
<jsp: include> : To insert a file into a particular jsp page.
Attributes used are Page and Flush.
3.4 SERVLETS
Introduction:
The Java web server is Java Soft own web Server. The Java web server is just a part of a
larger framework, intended to provide you not just with a web server, but also with tools. To
build customized network servers for any Internet or Intranet client/server system. Servlets are to
a web server, how applets are to the browser.
About SERVLETS:
Servlets provide a Java-based solution used to address the problems currently associated
with doing server-side programming, including inextensible scripting solutions, platform-specific
APIs, and incomplete interfaces. Servlets are objects that conform to a specific interface that can
be plugged into a Java-based server.
Servlets are to the server-side what applets are to the client-side - object byte codes that
can be dynamically loaded off the net. They differ from applets in that they are faceless objects
(without graphics or a GUI component). They serve as platform independent, dynamically
loadable, plug able helper byte code objects on the server side that can be used to dynamically
extend server-side functionality. For example, an HTTP Servlet can be used to generate dynamic
HTML content. When you use Servlets to do dynamic content you get the following advantages:
• They are faster and cleaner than CGI scripts

• They use a standard API (the Servlet API)
• They provide all the advantages of Java (run on a variety of servers without needing
to be rewritten).
Attractiveness of SERVLETS:
There are many features of Servlets that make them easy and attractive to use. These
include:
• Easily configured using the GUI-based Admin tool

• Can be loaded and invoked from a local disk or remotely across the network.
• Can be linked together, or chained, so that one Servlet can call another Servlet or
several Servlets in sequence.
• Can be called dynamically from within HTML pages, using server-side include tags.
• Are secure - even when downloading across the network, the Servlet security model
and Servlet sandbox protect your system from unfriendly behavior.
Advantages of the SERVLET API:

One of the great advantages of the Servlet API is protocol independence. It assumes
nothing about:
• The protocol being used to transmit on the net
• How it is loaded
• The server environment it will be running in
These qualities are important, because it allows the Servlet API to be embedded in many
different kinds of servers. There are other advantages to the Servlet API as well. These include:
• It's extensible - you can inherit all your functionality from the base classes made
available to you.
• It's simple, small, and easy to use.
Features of SERVLETS:
Servlets are persistent. Servlet are loaded only by the web server and can maintain services
between requests.
• Servlets are fast. Since Servlets only need to be loaded once, they offer much better
performance over their CGI counterparts.
• Servlets are platform independent.
• Servlets are extensible. Java is a robust, object-oriented programming language,
which easily can be extended to suit your needs
• Servlets are secure.
Loading SERVLETS:
Servlets can be loaded from three places:

From a directory that is on the CLASSPATH. The CLASSPATH of the Java Web
Server includes service root/classes/which is where the system classes reside. From the
<SERVICE_ROOT/Servlets/directory> this is *not* in the server‟s class path. A class loader is
used to create Servlets from this directory. New Servlets can be added - existing Servlets can be
recompiled and the server will notice these changes from a remote location. For this a code base
like http://nine.eng/classes/foo/ is required in addition to the Servlet class name. Refer to the
admin GUI docs on Servlet section to see how to set this up.
Loading Remote SERVLETS:
Remote Servlets can be loaded by:

• Configuring the Admin Tool to setup automatic loading of remote Servlets
• Setting up server side include tags in .html files
Defining a filter chain configuration
Invoking Servlets:
A Servlet invoker is a Servlet that invokes the "service" method on a named Servlet. If
the Servlet is not loaded in the server, then the invoker first loads the Servlet (either from local
disk or from the network) and the then invokes the "service" method. Also like applets, local
Servlets in the server can be identified by just the class name. In other words, if a Servlet name is
not absolute, it is treated as local.
A client can invoke Servlets in the following ways:
• The client can ask for a document that is served by the Servlet.
• The client (browser) can invoke the Servlet directly using a URL, once it has been
mapped using the Servlet aliases section of the admin GUI.
• The Servlet can be invoked through server side include tags.
• The Servlet can be invoked by placing it in the Servlets / directory.
• The Servlet can be invoked by using it in a filter chain.
two ways.
portable.
The following example uses Class.forName( ) to register the DB2Driver driver:
try {
Class.forName("com.ibm.db2.jcc.DB2Driver");
}
System.exit(1);
try {
Class.forName("com.ibm.db2.jcc.DB2Driver").newInstance();
System.exit(1);
System.exit(2);
System.exit(3);
try {
Driver myDriver = new com.ibm.db2.jcc.DB2Driver();
System.exit(1);
Here each form requires a database URL. A database URL is an address that points to your
database.
Formulating a database URL is where most of the problems associated with establishing a
connection occur.
Following table lists down popular JDBC driver names and database URL.
All the highlighted part in URL format is static and you need to change only remaining part as
per your database setup.

jdbc:db2://localhost:50000/outage
String URL = " jdbc:db2://localhost:50000/outage ";
String USER = " db2admin ";
String PASS = " admin "

URL:
" jdbc:db2:driver:username/password@database
String URL = " jdbc:db2://localhost:50000/outage","db2admin","admin" ";

Properties object:
import java.util.*;
String URL = jdbc:db2://localhost:50000/outage","db2admin","admin";


conn.close();
two ways.
portable.
The following example uses Class.forName( ) to register the DB2Driver driver:
try {
Class.forName("com.ibm.db2.jcc.DB2Driver");
}
System.exit(1);
try {
Class.forName("com.ibm.db2.jcc.DB2Driver").newInstance();
System.exit(1);
System.exit(2);
System.exit(3);

try {
Driver myDriver = new com.ibm.db2.jcc.DB2Driver();
System.exit(1);

jdbc:db2://localhost:50000/outage
String URL = " jdbc:db2://localhost:50000/outage ";
String USER = " db2admin ";
String PASS = " admin "
URL:
" jdbc:db2:driver:username/password@database
String URL = " jdbc:db2://localhost:50000/outage","db2admin","admin" ";

Properties object:
import java.util.*;
String URL = jdbc:db2://localhost:50000/outage","db2admin","admin";


conn.close();
04. SYSTEM ANALYSIS & DESIGN
4.1 SYSTEM DESIGN

The System Design Document describes the system requirements, operating environment,
system and subsystem architecture, files and database design, input formats, output layouts,
human-machine interfaces, detailed design, processing logic, and external interfaces.
UML DIAGRAMS DESCRIPTION:
Global Use Case Diagrams:
Identification of actors:
Actor: Actor represents the role a user plays with respect to the system. An actor interacts with,
but has no control over the use cases.
Graphical representation:
<<Actor name>>
An actor is someone or something that:
Interacts with or uses the system.
• Provides input to and receives information from the system.
• Is external to the system and has no control over the use cases
Actors are discovered by examining:
• Who directly uses the system?
• Who is responsible for maintaining the system?
• External hardware used by the system.
• Other systems that need to interact with the system.
Questions to identify actors:
• Who is using the system? Or, who is affected by the system? Or, which
groups need help from the system to perform a task?
• Who affects the system? Or, which user groups are needed by the system
to perform its functions? These functions can be both main functions and
secondary functions such as administration.
• Which external hardware or systems (if any) use the system to perform
tasks?
• What problems does this application solve (that is, for whom)?
• And, finally, how do users use the system (use case)? What are they doing
with the system?
The actors identified in this system are:
• System Administrator
• Customer
• Customer Care
Identification of usecases:
Usecase: A use case can be described as a specific way of using the system from a user‟s
(actor‟s) perspective.
4.2 Graphical representation:
A more detailed description might characterize a use case as:
• Pattern of behavior the system exhibits
• A sequence of related transactions performed by an actor and the system
• Delivering something of value to the actor
Use cases provide a means to:
• capture system requirements
• communicate with the end users and domain experts
• test the system
Use cases are best discovered by examining the actors and defining what the actor will be
able to do with the system.
Guide lines for identifying use cases:
• For each actor, find the tasks and functions that the actor should be able to perform or
that the system needs the actor to perform. The use case should represent a course of
events that leads to clear goal
• Name the use cases.
• Describe the use cases briefly by applying terms with which the user is familiar.
This makes the description less ambiguous
Questions to identify use cases:
• What are the tasks of each actor?
• Will any actor create, store, change, remove or read information in the system?
• What use case will store, change, remove or read this information?
• Will any actor need to inform the system about sudden external changes?
• Does any actor need to inform about certain occurrences in the system?
• What usecases will support and maintains the system?
Flow of Events
A flow of events is a sequence of transactions (or events) performed by the system. They
typically contain very detailed information, written in terms of what the system should do, not
how the system accomplishes the task. Flow of events are created as separate files or documents
in your favorite text editor and then attached or linked to a use case using the Files tab of a model
element.
A flow of events should include:
• When and how the use case starts and ends
• Use case/actor interactions
• Data needed by the use case
• Normal sequence of events for the use case

• Alternate or exceptional flows
Construction of Usecase diagrams:
Use-case diagrams graphically depict system behavior (use cases). These diagrams present a
high level view of how the system is used as viewed from an outsider‟s (actor‟s) perspective. A
use-case diagram may depict all or some of the use cases of a system.
A use-case diagram can contain:
• actors ("things" outside the system)
• use cases (system boundaries identifying what the system should do)
• Interactions or relationships between actors and use cases in the system including the
associations, dependencies, and generalizations.
Relationships in use cases:
• Communication:
The communication relationship of an actor in a usecase is shown by connecting the actor

symbol to the usecase symbol with a solid path. The actor is said to communicate with the
usecase.
• Uses:
A Uses relationship between the usecases is shown by generalization arrow from the usecase.
• Extends:
The extend relationship is used when we have one usecase that is similar to another usecase but
does a bit more. In essence it is like subclass.
4.3 SEQUENCE DIAGRAMS

A sequence diagram is a graphical view of a scenario that shows object interaction in a time-
based sequence what happens first, what happens next. Sequence diagrams establish the roles of
objects and help provide essential information to determine class responsibilities and interfaces.
There are two main differences between sequence and collaboration diagrams: sequence
diagrams show time-based object interaction while collaboration diagrams show how objects
associate with each other. A sequence diagram has two dimensions: typically, vertical placement
represents time and horizontal placement represents different objects.
Object:
An object has state, behavior, and identity. The structure and behavior of similar objects are
defined in their common class. Each object in a diagram indicates some instance of a class. An
object that is not named is referred to as a class instance.
The object icon is similar to a class icon except that the name is underlined:
An object's concurrency is defined by the concurrency of its class.
Message:
A message is the communication carried between two objects that trigger an event. A message
carries information from the source focus of control to the destination focus of control. The
synchronization of a message can be modified through the message specification.
Synchronization means a message where the sending object pauses to wait for results.
Link:
A link should exist between two objects, including class utilities, only if there is a relationship
between their corresponding classes. The existence of a relationship between two classes
symbolizes a path of communication between instances of the classes: one object may send
messages to another. The link is depicted as a straight line between objects or objects and class
instances in a collaboration diagram. If an object links to itself, use the loop version of the icon.
CLASS DIAGRAM:
Identification of analysis classes:
A class is a set of objects that share a common structure and common behavior (the same
attributes, operations, relationships and semantics). A class is an abstraction of real-world items.
There are 4 approaches for identifying classes:
• Noun phrase approach:
• Common class pattern approach.

• Use case Driven Sequence or Collaboration approach.
• Classes , Responsibilities and collaborators Approach
Noun Phrase Approach:
The guidelines for identifying the classes:
• Look for nouns and noun phrases in the usecases.
• Some classes are implicit or taken from general knowledge.
• All classes must make sense in the application domain; Avoid computer
implementation classes – defer them to the design stage.
• Carefully choose and define the class names After identifying the classes we
have to eliminate the following types of classes:
• ACommon class pattern approach:
The following are the patterns for finding the candidate classes:
• Concept class.
• Events class.
• Organization class
• Peoples class
• Places class
• Tangible things and devices class.
• Use case driven approach:
We have to draw the sequence diagram or collaboration diagram. If there is need for
some classes to represent some functionality then add new classes which perform those
functionalities.
• CRC approach:
The process consists of the following steps:
• Identify classes‟ responsibilities ( and identify the classes )
• Assign the responsibilities

• Identify the collaborators.
Identification of responsibilities of each class:
The questions that should be answered to identify the attributes and methods of a class
respectively are:
• What information about an object should we keep track of?
• What services must a class provide?
Identification of relationships among the classes:
Three types of relationships among the objects are:
Association: How objects are associated?
Super-sub structure: How are objects organized into super classes and sub classes?
Aggregation: What is the composition of the complex classes?
Association:
The questions that will help us to identify the associations are:
• Is the class capable of fulfilling the required task by itself?
• If not, what does it need?
• From what other classes can it acquire what it needs?
Guidelines for identifying the tentative associations:
• A dependency between two or more classes may be an association. Association often

corresponds to a verb or prepositional phrase.
• A reference from one class to another is an association. Some associations are implicit or
taken from general knowledge.
Some common association patterns are:
Location association like part of, next to, contained in…..
Communication association like talk to, order to ……
We have to eliminate the unnecessary association like implementation associations, ternary or n-

ary associations and derived associations.
Super-sub class relationships:
Super-sub class hierarchy is a relationship between classes where one class is the parent class of
another class (derived class).This is based on inheritance.
Guidelines for identifying the super-sub relationship, a generalization are
• Top-down:
Look for noun phrases composed of various adjectives in a class name. Avoid excessive
refinement. Specialize only when the sub classes have significant behavior.
• Bottom-up:
Look for classes with similar attributes or methods. Group them by moving the common
attributes and methods to an abstract class. You may have to alter the definitions a bit.
• Reusability:
Move the attributes and methods as high as possible in the hierarchy.
• Multiple inheritances:
Avoid excessive use of multiple inheritances. One way of getting benefits of multiple
inheritances is to inherit from the most appropriate class and add an object of another class as an
attribute.
Aggregation or a-part-of relationship:
It represents the situation where a class consists of several component classes. A class
that is composed of other classes doesn‟t behave like its parts. It behaves very difficultly. The
major properties of this relationship are transitivity and anti symmetry.
The questions whose answers will determine the distinction between the part and whole
relationships are:
• Does the part class belong to the problem domain?
• Is the part class within the system‟s responsibilities?
• Does the part class capture more than a single value?( If not then simply include it
as an attribute of the whole class)
• Does it provide a useful abstraction in dealing with the problem domain?

There are three types of aggregation relationships. They are:
Assembly:
It is constructed from its parts and an assembly-part situation physically exists.
Container:
A physical whole encompasses but is not constructed from physical parts.
Collection member:
A conceptual whole encompasses parts that may be physical or conceptual. The container and
collection are represented by hollow diamonds but composition is represented by solid diamond.
4.4 UML Diagrams:

Use case Diagram:
User Sequence Diagram:
RTO Officer Sequence Diagram:
Admin Sequence Diagram:
User Collaboration Diagram:
RTO Officer Collaboration Diagram:
Admin Collaboration Diagram:
State Chart Diagram:
RTO Officer State chart Diagram:
Admin State chart Diagram:
Activity Diagram:
Class Diagram:
Component Diagram:
Deployment
Data Base Tables
4.5 TESTING
Testing is the debugging program is one of the most critical aspects of the computer
programming triggers, without programming that works, the system would never produce an
output of which it was designed. Testing is best performed when user development is asked to
assist in identifying all errors and bugs. The sample data are used for testing. It is not quantity
but quality of the data used the matters of testing. Testing is aimed at ensuring that the system
was accurately an efficiently before live operation commands.
Testing objectives:
The main objective of testing is to uncover a host of errors, systematically and

with minimum effort and time. Stating formally, we can say, testing is a process of executing a
program with intent of finding an error.
A successful test is one that uncovers an as yet undiscovered error.
A good test case is one that has probability of finding an error, if it exists.
The test is inadequate to detect possibly present errors.
The software more or less confirms to the quality and reliable standards.
Levels of Testing:
In order to uncover present in different phases we have the concept of levels of testing.
The basic levels of Testing:
Client needs acceptance testing
Requirements system testing
Design integration testing
Code unit testing
Code testing:
This examines the logic of the program. For example, the logic for updating various
sample data and with the sample files and directories were tested and verified.
Specification Testing:
Executing this specification starting what the program should do and how it should
performed under various conditions. Test cases for various situation and combination of
conditions in all the modules are tested.
Unit testing:
In the unit testing we test each module individually and integrate with the overall system.
Unit testing focuses verification efforts on the smallest unit of software design in the module.
This is also known as module testing. The module of the system is tested separately. This testing
is carried out during programming stage itself. In the testing step each module is found to work
satisfactorily as regard to expected output from the module. There are some validation checks for
fields also. For example the validation check is done for varying the user input given by the user
which validity of the data entered. It is very easy to find error debut the system.
Each Module can be tested using the following two Strategies:
• Black Box Testing
• White Box Testing

BLACK BOX TESTING
What is Black Box Testing?

Black box testing is a software testing techniques in which functionality of the software
under test (SUT) is tested without looking at the internal code structure, implementation
details and knowledge of internal paths of the software. This type of testing is based entirely on
the software requirements and specifications.
In Black Box Testing we just focus on inputs and output of the software system without
bothering about internal knowledge of the software program.
The above Black Box can be any software system you want to test. For example : an
operating system like Windows, a website like Google ,a database like Oracle or even your own
custom application. Under Black Box Testing , you can test these applications by just focusing
on the inputs and outputs without knowing their internal code implementation.
Black box testing - Steps

Here are the generic steps followed to carry out any type of Black Box Testing.
• Initially requirements and specifications of the system are examined.

• Tester chooses valid inputs (positive test scenario) to check whether SUT processes them
correctly. Also some invalid inputs (negative test scenario) are chosen to verify that the
SUT is able to detect them.
• Tester determines expected outputs for all those inputs.
• Software tester constructs test cases with the selected inputs.
• The test cases are executed.
• Software tester compares the actual outputs with the expected outputs.
• Defects if any are fixed and re-tested.
Types of Black Box Testing

There are many types of Black Box Testing but following are the prominent ones -
• Functional testing – This black box testing type is related to functional requirements of a
system; it is done by software testers.
• Non-functional testing – This type of black box testing is not related to testing of a
specific functionality, but non-functional requirements such as performance, scalability,
usability.
• Regression testing – Regression testing is done after code fixes , upgrades or any other
system maintenance to check the new code has not affected the existing code.
WHITE BOX TESTING

White Box Testing is the testing of a software solution's internal coding and infrastructure.It
focuses primarily on strengthening security, the flow of inputs and outputs through the
application, and improving design and usability.White box testing is also known as clear, open,
structural, and glass box testing.
It is one of two parts of the "box testing" approach of software testing. Its counter-part,
blackbox testing, involves testing from an external or end-user type perspective. On the other
hand, Whitebox testing is based on the inner workings of an application and revolves around
internal testing. The term "whitebox" was used because of the see-through box concept. The
clear box or whitebox name symbolizes the ability to see through the software's outer shell (or
"box") into its inner workings. Likewise, the "black box" in "black box testing" symbolizes not
being able to see the inner workings of the software so that only the end-user experience can be
tested
What do you verify in White Box Testing ?
White box testing involves the testing of the software code for the following:
• Internal security holes
• Broken or poorly structured paths in the coding processes
• The flow of specific inputs through the code
• Expected output
• The functionality of conditional loops
• Testing of each statement, object and function on an individual basis
The testing can be done at system, integration and unit levels of software development. One of
the basic goals of whitebox testing is to verify a working flow for an application. It involves
testing a series of predefined inputs against expected or desired outputs so that when a specific
input does not result in the expected output, you have encountered a bug.
How do you perform White Box Testing?
To give you a simplified explanation of white box testing, we have divided it into two basic
steps. This is what testers do when testing an application using the white box testing technique:
STEP 1) UNDERSTAND THE SOURCE CODE
The first thing a tester will often do is learn and understand the source code of the application.
Since white box testing involves the testing of the inner workings of an application, the tester
must be very knowledgeable in the programming languages used in the applications they are
testing. Also, the testing person must be highly aware of secure coding practices. Security is
often one of the primary objectives of testing software. The tester should be able to find security
issues and prevent attacks from hackers and naive users who might inject malicious code into the
application either knowingly or unknowingly.
Step 2) CREATE TEST CASES AND EXECUTE
The second basic step to white box testing involves testing the application‟s source code
for proper flow and structure. One way is by writing more code to test the application‟s source
code. The tester will develop little tests for each process or series of processes in the application.
This method requires that the tester must have intimate knowledge of the code and is often done
by the developer. Other methods include manual testing, trial and error testing and the use of
testing tools as we will explain further on in this article.
System testing:
Once the individual module testing is completed, modules are assembled and integrated to
perform as a system. The top down testing, which began from upper level to lower level module,
was carried out to check whether the entire system is performing satisfactorily.
There are three main kinds of System testing:
• Alpha Testing
• Beta Testing
• Acceptance Testing
Alpha Testing:
This refers to the system testing that is carried out by the test team with the Organization.
Beta Testing:
This refers to the system testing that is performed by a selected group of friendly customers
Acceptance Testing:
This refers to the system testing that is performed by the customer to determine whether
or not to accept the delivery of the system.
Table.7.2: Acceptance Testing:

Test Description of Expected results Covered by script
Condition coverage
ID
1. Verification of a If a particular record This type of test in {verify}

particular record already exists it procedure in every Jsp file where
displays a message a record is inserted via an
interface
2. Updating of a All the details should This type of test is covered in all
particular record not be updated. the Asp files where updations are
made.
3. Validity of login Only the authorized This is covered in the login

persons must access procedure for the validity of a
system. user
Integration Testing:
Data can be lost across an interface, one module can have an adverse effort on the other
sub functions, when combined, may not produce the desired major functions. Integrated testing is
the systematic testing for constructing the uncover errors within the interface. The testing was
done with sample data. The developed system has run successfully for this sample data. The
need for integrated test is to find the overall system performance.
Output testing:
After performance of the validation testing, the next step is output testing. The output
displayed or generated by the system under consideration is tested by asking the user about the
format required by system.
Test plan:
The test-plan is basically a list of testcases that need to be run on the system. Some of the
testcases can be run independently for some components (report generation from the database,
for example, can be tested independently) and some of the testcases require the whole system to
be ready for their execution. It is better to test each component as and when it is ready before
integrating the components. It is important to note that the testcases cover all the aspects of the
system (ie, all the requirements stated in the RS document).
Sno Test case Title Description Expected The Result

Outcome requirement
in RS that is
being tested
1 Successful User The login to the Login should RS1 Passed

Verification system should be be successful
tried with the login and the user
assigned by the should enter in
admin and the correct to the system
password
2 Unsuccessful Login to the system Login should RS1 Passed

User with a wrong fail with an
Verification due password error „Invalid
to wrong Password‟
password
3 Unsuccessful Login to the system Login should RS1 Passed

User with a invalid login fail with an
Verification due id error „Invalid
to invalid login user id‟
id
05. IMPLEMENTATION
5.1 SOURCE CODE

Author: W3layouts
Author URL: http://w3layouts.
com
License: Creative Commons Attribution 3.0 Unported
License URL: http://creativecommons.org/licenses/by/3.0/
-->
<!DOCTYPE html>
<html>
<head>
<title>RTOManagement</title>

<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="keywords" content="Seafaring Responsive web template, Bootstrap Web
Templates, Flat Web Templates, Android Compatible web template,
Smartphone Compatible web template, free webdesigns for Nokia, Samsung, LG, SonyEricsson,
Motorola web design" />
<script type="application/x-javascript"> addEventListener("load", function() {
setTimeout(hideURLbar, 0); }, false);
function hideURLbar(){ window.scrollTo(0,1); } </script>

<link href="css/bootstrap.css" rel="stylesheet" type="text/css" media="all" />
<link href="css/style.css" rel="stylesheet" type="text/css" media="all" />

<script src="js/jquery-1.11.1.min.js"></script>

<link
href='//fonts.googleapis.com/css?family=Josefin+Sans:400,100,100italic,300,300italic,400italic
,600,600italic,700,700italic' rel='stylesheet' type='text/css'>
<link
href='//fonts.googleapis.com/css?family=Open+Sans:400,300,300italic,400italic,600,600italic,7
00,700italic,800,800italic' rel='stylesheet' type='text/css'>
</head>
<body>

<div class="header">
<div class="search">

<div class="navbar-header">
<button type="button" class="navbar-toggle collapsed" data-
toggle="collapse" data-target="#bs-example-navbar-collapse-1">
<span class="sr-only">Toggle navigation</span>
<span class="icon-bar"></span>
</button>
</div>

<div class="collapse navbar-collapse nav-wil" id="bs-example-
navbar-collapse-1">
<nav class="cl-effect-1">
<ul class="nav navbar-nav">
<li class="active"><a
href="index.jsp">Home</a></li>
<li><a href="about.jsp">About</a></li>
<li><a href="user.jsp">Users</a></li>
<li><a href="rtoofficer.jsp">RTO
Officer</a></li>
<li><a href="admin.jsp">Admin</a></li>
<li><a href="contact.jsp">Contact
Us</a></li>
</ul>
</nav>
</div>
</nav>
</div>
</div>


<div class="banner1">
</div>


<div class="about">
<div class="about-grids">
<div class="col-md-6 about-grid">
<h3>About Us</h3>
<img src="images/about.jpg" alt=" " class="img-
responsive" />
<h4>Vehicle information management system</h4>
<p>This is RTO office management system created for
RTO to maintain all records like vehicle registration such as 2 wheelers, 3 wheelers registration,
LMV, HMV, Learning licenses and permanent licenses etc. These are the main activities of RTO
office. This application manages all the data of the registered user and his vehicles.In RTO
Management System administrator has the power to verify the data entered by the user,
processing of data and provide appropriate solutions. </p>
</div>
</div>
</div>
</div>
</div>


</div>
</div>
</div>
</div>

<div class="footer-bottom">
<p>Copyright © 2018 RTO. All rights reserved |</a></p>
</div>
</div>


<script src="js/bootstrap.js"> </script>

</body>
</html>

<!DOCTYPE html>
<html>
<head>


<link
<link
</head>
<body>

->
</div>
<div class="logo">
</div>
<ul>
</ul>
</div>
</div>
</button>
</div>
navbar-collapse-1">
Officer</a></li>
Us</a></li>
</ul>
</nav>
</nav>
</div>
</div>


</div>


<div class="about">
<h3>About Us</h3>
responsive" />
</div>
</div>
</div>
</div>
</div>


</div>
</div>
</div>
</div>

</div>
</div>

</body>
</html>

<!DOCTYPE html>
<html>
<head>


<link
<link
</head>
<body>

->
</div>
<div class="logo">
</div>
<ul>
</ul>
</div>
</div>
</button>
</div>
navbar-collapse-1">
Officer</a></li>
Us</a></li>
</ul>
</nav>
</nav>
</div>
</div>


</div>


<div class="about">
<h3>About Us</h3>
responsive" />
</div>
</div>
</div>
</div>
</div>


</div>
</div>
</div>
</div>

</div>
</div>

</body>
</html>

<!DOCTYPE html>
<html>
<head>


<link
<link
</head>
<body>

->
</div>
<div class="logo">
</div>
<ul>
</ul>
</div>
</div>
</button>
</div>
navbar-collapse-1">
Officer</a></li>
Us</a></li>
</ul>
</nav>
</nav>
</div>
</div>


</div>


<div class="about">
<h3>About Us</h3>
responsive" />
</div>
</div>
</div>
</div>
</div>


</div>
</div>
</div>
</div>

</div>
</div>

</body>
</html>

<!DOCTYPE html>
<html>
<head>


<link
<link
</head>
<body>

->
</div>
<div class="logo">
</div>
<ul>
</ul>
</div>
</div>
</button>
</div>
navbar-collapse-1">
Officer</a></li>
Us</a></li>
</ul>
</nav>
</nav>
</div>
</div>


</div>


<div class="about">
<h3>About Us</h3>
responsive" />
</div>
</div>
</div>
</div>
</div>


</div>
</div>
</div>
</div>

</div>
</div>

</body>
</html>

<!DOCTYPE html>
<html>
<head>


<link
<link
</head>
<body>

->
</div>
<div class="logo">
</div>
<ul>
</ul>
</div>
</div>
</button>
</div>
navbar-collapse-1">
Officer</a></li>
Us</a></li>
</ul>
</nav>
</nav>
</div>
</div>


</div>


<div class="about">
<h3>About Us</h3>
responsive" />
</div>
</div>
</div>
</div>
</div>


</div>
</div>
</div>
</div>

</div>
</div>

</body>
</html>

<!DOCTYPE html>
<html>
<head>


<link
<link
</head>
<body>

->
</div>
<div class="logo">
</div>
<ul>
</ul>
</div>
</div>
</button>
</div>
navbar-collapse-1">
Officer</a></li>
Us</a></li>
</ul>
</nav>
</nav>
</div>
</div>


</div>


<div class="about">
<h3>About Us</h3>
responsive" />
</div>
</div>
</div>
</div>
</div>


</div>
</div>
</div>
</div>

</div>
</div>

</body>
</html>
06. SNAPSHOTS
07. CONCLUSION
9.CONCLUSION:
The application is designed in such a way that any further enhancement can be done with ease.
The system has the for easy intergration with other system. New modules can be added to
existing system with less effort.
The system has six classes. Each of these classes has various procedures and functions. In future
a new functions or procedure can be easily added in the system through these classes. Or even a
new class can be added. The system generates only limited number of reports. If more detailed
reports are required the system can be directed.
Even through the system as well as communication facility, its not enough . The mail account
information for the customer credit information. Thus by adding this module the system
transaction will be improved.
REFERENCES:
[1] https://en.wikipedia.org/wiki/combinations/
[2]https://www.w3schools.com/

Se Project

Uploaded by

Copyright:

Available Formats

Se Project

Uploaded by

Document Information

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

Se Project

Uploaded by

Copyright:

Available Formats

A PROJECT REPORT

RTO MANAGEMENT SYSTEM

For the award of the degree

Under the Guidance of

DEPARTMENT OF COMPUTER SCIENCE

Signature of the External Examiners:

With immense pleasure, we take this opportunity to express our

We would like to thanks Mr. Nagaraju Kilari, Head of the Department

Finally, we wish to thank every individual who helped us directly or

CHAPTER:1 INTRODUCTION TO THE PROJECT

1.3 MODULE DESCRIPTION 7 7-9

2.1. EXISTING SYSTEM 9

2.2. PROPOSED SYSTEM 10

2.3. REQUIREMENT SPECIFICATION 11

2.4. HARDWARE REQUIREMENTS

2.3.3. INTRODUCTION TO HTML 13

2.3.4. INTRODUCTION TO CSS 14

2.3.5. INTRODUCTION TO PHP 15

2.3.5. INTRODUCTION TO MYSQL 17-19

3.1. TABLE STRUCTURE 20-22

3.2. E-R DIAGRAM 23

CHAPTER:4 CODING AND DEVELOPMENT

4.1. SOURCE CODE 29-103

CHAPTER:5 TESTING AND IMPLEMENTATION

5.1. INTRODUCTION TO TESTING 104

5.2. TYPES OF TESTING USED 111-128

CHAPTER:6 CONCLUSION 129

6.1. FUTURE ENHANSMENT 130

RTO Management System

Users of the system

High Level Requirements

Non Functional Requirements

1. Internet Explorer 9.0 above browser compatibility

2. Proper user-id/password based user authentication to allow access to the system.

1.1 SYSTEM ANALYSIS

• System control and backup or recovery.

• User Interface Design

1.2 INPUT & OUTPUT REPRESENTATION

1.3 PROCESS MODEL USED WITH JUSTIFICATION

SDLC (Spiral Model):

Integration & Test Stage:

1.5 SYSTEM ARCHITECTURE

• Separates functionality from presentation.

• Clear separation - better understanding.

• Changes limited to well define components.

• Can be running on WWW.

• Effective network performance.

• The cost of developing the full system is reasonable.

2.2 SYSTEM CONFIGURATION:

2.3 Software over View:

Java Virtual machine

Java Runtime Environment vs. Java Development Kit

The Java Development Kit (JDK) is provided by Sun Microsystems as a basic

Java has the following properties:

Development Process with Java

J2SE is a collection of Java Programming Language API (Application programming

Key features and services of J2EE:

• Making a connection to a database

• Creating SQL or MySQL statements

• Executing that SQL or MySQL queries in the database