Download Banking Information System

CONTENTS
TABLE OF CONTENTS
TOPICS
S.N0
1.
Project Description
2.
Development Environment
3.
System Requirements
4.
Software Specification
5.
Data Flow Diagram
6.
Data Dictionary
7.
Source Code
8.
Screen Shots
9.
Conclusion
10.
Bibliography
P.NO
PROJECT
DESCRIPTION
PROJECT DESCRIPTION
Banking Information System:Banking is one of the organizations which are implementing new internet
technologies to serve their clients with their products and information. With the easy
availability of internet, almost all banks are willing to reach their client through some
portal providing information and transaction facilities of them. In addition to provide an
easier access to their client services, they are also automating their daily routine functions
like maintaining lists of transactions and generating reports. A web-based system for a
bank can be informational and transactional. An informational bank system provides
information only. On the other hand, a transactional system requires interfaces to
complete transactions which may range from a small to account enquiry to a large
business to business money transfer.
We will implement a number of basic functionalities in the proposed system like
handling of various types of accounts, managing various types of accounts, preparing
different formats of reports. A banking information system needs to be highly secure and
all transactions need careful handling. We will use Enterprise java bean in the
development of this project, which is good for developing a distributive system with
additional support for transactional security.
Analysis on Banking Information System:The basic functions in a bank includes opening a new account, modifying or
closing of an existing account, recording all kinds of transactions and generating daily or
periodical reports of them. These functions, when handled manually, may consume a
good amount of time and may create a large number of human errors. Hence, we need a
system, which automates all these jobs. The basic problems that the new system should
solve are as follows.
1. Handling a large number of requests to open new accounts, to modify account
details, and to close an account is time consuming. Managing hundreds of records in
various ledgers and files in cumbersome for bank staff.
2. Difficulty in conducting thousands of transactions like withdrawing, depositing
and transferring of money by a limited number of bank staff, often result with increase in
chances of error in recording of transaction.
All these problems require a new system, which would automate entries of client
information and recording of all client transactions. A project implementing all required
facilities for a bank will be a large project; here we are designing a simple complete with
all basic functions like opening a new account, modifying, closing an account and
carrying out transactions like withdrawing, depositing and transferring money
electronically.
Module Description:Design For the project:We design this project; the best approach is to list all modules, which would
fulfill our requirements. The requirement analysis helps in deciding module of the
project. Keeping all this in think, this project designed with this following modules and
technologies.




Login module
Bank Master module
Transaction module
Reports module
Login Module:A login module for a system, which needs protection from any unauthorized
access. The systems, like banking information system, needs to be highly secure from any
unauthorized access. Therefore, this helps to intercept all the attempts of accessing the
system and authenticates the user who is trying to access it. The user can access a secure
zone only after entering a valid user id and password. This user can be either a manager
or a clerk. A clerk can login has limited privileges, e.g. they can access only bank master
module, while a manager login can access all modules.
Bank master module:This module handles three different types of accounts, which are savings, current,
and recurring. This module provides interfaces for opening a new account, updating an
existing account, viewing of any account information, and closing all three types of
accounts. Both clerk and manager can access this module.
Transaction module:This module provides transactional functionalities like depositing, withdrawing,
and transferring money from one account to another.
Reports module:This module has been designed for all types of reports, which a bank or a client
may need. These reports show all the transactions done at a particular date or over a
period of time. There are different options for bank report and customer report. A report
required by a bank staff is a bank report and the report asked by a customer is a customer
report.
DEVELOPMENT
ENVIRONMENT
DEVELOPMENT ENVIRONMENT
HARDWARE ENVIRONMENT:SERVER: Intel(R) Pentium(R) 4 CPU 3.4 GHz Processor
 Hyper-Threading Status – Enabled
 2*512 MB DDR RAM
 160 GB SATA Hard Disk Drive
 1.44 MB Floppy Disk Drive
 AGP Card with 128 MB RAM
 17” LCD True Flat Color Monitor
 16x DVD-ROM Drive
 10/1000 MBPS Intel Active LAN Ethernet Adapter
 104 Keys Keyboard
 Optical Mouse
 6-USB Port, 2 Serial and 1 Parallel Port
CLIENT: Intel(R) Pentium(R) 4 CPU 2.0 GHz Processor
 256 MB DDR RAM
 40 GB Hard Disk Drive
 AGP Card with 8 MB RAM
 15” SVGA Digital Color Monitor
 10/1000 MBPS Intel Active LAN Ethernet Adapter
 104 Keys Keyboard
 Optical Mouse
 MyEclipse ( IDE l)
 Netbeans 5.5
 Edit Plus ( Browser)
SOFTWARE ENVIRONMENT:OPERATING SYSTEM: WINDOWS XP
FRONT END: JAVA 1.6
 JDBC 3.0
 J2EE

JSP 2.1

SERVLET 2.3

STRUTS1.1 Framework
 HTML
 XML
BACK END: Microsoft SQL Server2000
APPLICATION SERVER: BEA Web Logic 8.1
SYSTEM
REQUIREMENT
SYSTEM REQUIREMENTS
CLIENT SIDE REQUIREMENTS
Operating System: Win98 or above
IE5.0 or above
Display: 800 x 600 pixels
Memory: 32MB or above
CPU: Pentium II or above
SERVER SIDE REQUIREMENTS
Operating System: Win NT 4.0 SP6.0 or above
Apache Tomcat Server 6.0 or weblogic 8.1
Microsoft SQL Server
Java Development Kit 1.5 or above
Memory: 256 MB or above
CPU: Pentium III or above
SOFTWARE
SPECIFICATION
SOFTWARE SPECIFICATION
EJB modules which used in project:Enterprise Java Beans is a server side component for j2ee platform. It is used for
fast and simplified development of distributed, transactional, and secure applications. The
applications developed using EJB are scalable, reliable, support, portability and
reusability of the code. An application can use all three types of EJB’s. EJB helps
developers freeing them from low level system details of managing transactions, threads
and load balancing.
kinds of EJB:1.A session bean
Session Bean is a non-persistent object that implements some business logic
running on the server. One way to think of a session object is as a logical extension of the
client program that runs on the server.
Session beans are used to manage the interactions of entity and other session beans,access
resources, and generally perform tasks on behalf of the client.
There are two basic kinds of session bean: stateless and stateful.
Stateless session beans are made up of business methods that behave like procedures,
they operate only on the arguments passed to them when they are invoked. Stateless
beans are called stateless because they are transient; they do not maintain business state
between method invocations.Each invocation of a stateless business method is
independent from previous invocations. Because stateless session beans are stateless, they
are easier for the EJB container to manage, so they tend to process requests faster and use
less resources.
Stateful session beans encapsulate business logic and state specific to a client. Stateful
beans are called "stateful" because they do maintain business state between method
invocations, held in memory and not persistent. Unlike stateless session beans, clients do
not share stateful beans. When a client creates a stateful bean, that bean instance is
dedicated to service only that client. This makes it possible to maintain conversational
state, which is business state that can be shared by methods in the same stateful bean
Stateless session bean- An instance of these non-persistent EJBs provides a service
without storing an interaction or conversation state between methods. Any instance can
be used for any client.
Stateful session bean- An instance of these non-persistent EJBs maintains state across
methods and transactions. Each instance is associated with a particular client.
2.Entity bean
An instance of these persistent EJBs represents an object view of the data, usually rows
in a database. They have a primary key as a unique identifier. Entity bean persistence can
be either container-managed or bean-managed.
The entity bean is used to represent data in the database. It provides an object-oriented
interface to data that would normally be accessed by the JDBC or some other back-end
API.
More than that, entity beans provide a component model that allows bean developers to
focus their attention on the business logic of the bean, while the container takes care of
managing persistence,transactions, and access control.
There are two basic kinds of entity beans: container-managed ersistence (CMP) andbeanmanaged persistence (BMP).
Container-managed persistence beans are the simplest for the bean developer to create
and the most difficult for the EJB server to support.
This is because all the logic for synchronizing the bean's state with the database is
handled automatically by the container. This means that the bean developer doesn't need
to
write
any
data
access
logic,
while
the
EJB
server
is
supposed to take care of all the persistence needs automatically. With CMP, the container
manages the persistence of the entity bean. Vendor tools are used to map the entity fields
to the database and absolutely no database access code is written in the bean class.
The bean-managed persistence (BMP) enterprise bean manages synchronizing its state
with the database as directed by the container. The bean uses a database API to read and
write its fields to the database, but the container tells it when to do each synchronization
operation and manages the transactions for the bean automatically.
Bean-managed persistence gives the bean developer the flexibility to perform persistence
operations that are too complicated for the container or to use a data source that is not
supported by the container
3.Message driven bean
An instance of these EJBs is integrated with the Java Message Service (JMS) to
provide the ability for message-driven beans to act as a standard JMS message consumer
and perform asynchronous processing between the server and the JMS message producer.
Components of EJB Module:
We complete the code with a remote interface, a home interface, a bean class, and
some specific deployment descriptors like ejb-jar.xml. The various components created in
an EJB module are as follows:




Remote interface
Home interface
Bean class
Deployment descriptor
Remote interface
A remote interface is also known as a component interface. All business methods
are declared in the remote interface, which are to be invoked by the client. A component
interface and all methods declared in this interface through Remote Exception.
Home Interface
A home interface helps a client in getting a reference to the remote interface so
that they can call business methods declared in the remote interface. A home interface
extends EJBHome interface and creates and provides bean references to the clients.
Bean class
A bean class implements either SessionBean or EntityBean interfaces according
to its type. A bean class defines all methods declared in the interface implemented by
them. In addition to the methods from SessionBean or EntityBean interface, a bean class
also defines all business methods declared in component interface.
Deployment Descriptors:A deployment descriptors describes the relation among three files.i.e Remote
interface, Home interface and Bean implementation class. The EJB container , which is
fully responsible for the management of the enterprise java beans deployed on it, simply
looks into deployment descriptor to find out the respective home and remote interface for
an EJB.
Session Facade
Business process may need complex manipulations classes, ie.EJB. Hence, a
single process may involve a number of EJBs. Writing a client code such a process
becomes difficult because of the complex relationships among the business components.
We may have to interact with different EJB modules at once for the single process which
can make a client code more complex and hence non-manageable. This problem can be
solved by introducing a new interacting layer between client code and rest of the EJB
modules. This is nothing but the modularization of code into different methods which can
be used again and again whenever they required. Here we will introduce a new design
pattern SessionFacade.
Session Facade is a core design pattern, which defines a higher level component
that contains complex interaction among rest of the lower level components and hence
centralizes the interactions. As a name suggests, session facade is implemented as a
session enterprise bean providing a single interface to the client for all functionalities in
an application. Introduction of Session Facade decreases the network traffic and latency.
All the introduction of Session Facade, access to other business objects, like
different beans, has become local as they being accessed by Session Facade; hence we
can say that Session Facade provides a higher level of abstraction to the client. It
represents a control layer between client and the business tier.
Servlet:Servlet is a server side program and web application, Servlet takes the request
from client and processes it and gives the response. Java Servlets has security, session
management and instance persistence.
A servlet is a Java programming language class used to extend the capabilities of
servers that host applications accessed via a request-response programming model.
Although servlets can respond to any type of request, they are commonly used to extend
the applications hosted by Web servers. For such applications, Java Servlet technology
defines HTTP-specific servlet classes.
The javax.servlet and javax.servlet.http packages provide interfaces and classes for
writing servlets. All servlets must implement the servlet interface, which defines lifecycle methods.
When implementing a generic service, you can use or extend the Generic servlet
class provided with the Java Servlet API. The HttpServlet class provides methods, such
as doGet and doPost, for handling HTTP-specific services.
JSP:JavaServer Pages technology put snippets of servlet code directly into a textbased document. A JSP page is a text-based document that contains two types of text:
static template data, which can be expressed in any text-based format such as HTML,
WML, and XML, and JSP elements, which determine how the page constructs dynamic
content.
JavaServer Pages (JSP) technology enables Web developers and designers to
rapidly develop and easily maintain, information-rich, dynamic Web pages that leverage
existing business systems. As part of the Java technology family, JSP technology enables
rapid development of Web-based applications that are platform independent. JSP
technology separates the user interface from content generation, enabling designers to
change the overall page layout without altering the underlying dynamic content.
The JavaServer PagesTM (JSP) technology provides a simplified, fast way to
create web pages that display dynamically generated content. JSP technology was
designed to make it easier and faster to build web-based applications that work with a
wide variety of web servers, application servers, browsers and development tools.
The JSP Approach to Web Application Development
In developing the JSP specification, Sun Microsystems worked with a number of
leading web server, application server and development tool vendors, as well as a diverse
and experienced development community. The result is an approach that balances
portability with ease-of-use for application and page developers.
JSP technology speeds the development of dynamic web pages in a number of ways:
Separating content generation from presentation
Using JSP technology, web page developers use HTML or XML tags to design
and format the results page. They use JSP tags or scriptlets to generate the dynamic
content (the content that changes according to the request, such as requested account
information or the price of a specific bottle of wine). The logic that generates the content
is encapsulated in tags and JavaBeans components and tied together in scriptlets, all of
which are executed on the server side. If the core logic is encapsulated in tags and beans,
then other individuals, such as web masters and page designers can edit the JSP page
without affecting the generation of the content.
On the server, a JSP engine interprets JSP tags and scriptlets, generates content
(for example, by accessing JavaBeans components, accessing a database with JDBC TM
technology, or including files), and sends the results back in the form of an HTML (or
XML) page to the browser. This helps authors protect proprietary code while ensuring
complete portability for any HTML-based web browser.
Emphasizing Reusable Components
Most JSP pages rely on reusable, cross-platform components (JavaBeans or
Enterprise JavaBeansTM components) to perform the more complex processing required
of the application. Developers can share and exchange components that perform common
operations, or make them available to larger user or customer communities. The
component-based approach speeds overall development and lets organizations leverage
their existing expertise and development efforts for optimal results.
Simplifying Page Development with tags
Web page developers are not always programmers familiar with scripting
languages. The JavaServer Pages technology encapsulates much of the functionality
required for dynamic content generation in easy-to-use, JSP-specific XML tags. Standard
JSP tags can access and instantiate JavaBeans components, set or retrieve bean attributes,
download applets, and perform other functions that are otherwise more difficult and timeconsuming to code.
The JSP Page Components:
A JSP directive passes information to the JSP engine. In this case, the first line
indicates the location of some Java programming language extensions to be accessible
from this page. Directives are enclosed in <%@ and %> markers.
Fixed template data: Any tags that the JSP engine does not recognize it passes on
with the results page. Typically, these will be HTML or XML tags. This includes the
Unordered List and H1 tags in the example above.
JSP actions, or tags: These are typically implemented as standard tags or
customized tags, and have XML tag syntax.
An expression: The JSP engine evaluates anything between <%== and %>
markers. A scriptlet is a small script that performs functions not supported by tags or ties
everything together. The native scripting language for JSP 1.0 software is based on the
Java programming language.
JSP Directives
JSP pages use JSP directives to pass instructions to the JSP engine. These may
include the following:
JSP Page Directives communicate page-specific information, such as buffer and
thread information or error handling.
Language Directives specify the scripting language, along with any extensions.
The Include Directive (shown in the example above) can be used to include an external
document in the page. A good example is a copyright file or company information, file -it is easier to maintain this file in one central location and include it in several pages than
to update it in each JSP page. However, the included file can also be another JSP file.
A taglib Directive indicates a library of custom tags that the page can invoke.
JSP Tags
Most JSP processing will be implemented through JSP-specific XML-based tags.
JSP 1.0 includes a number of standard tags, referred to as the core tags. These include:
jsp:useBean This tag declares the usage of an instance of a JavaBeans component. If the
Bean does not already exist, then the JavaBean component instantiates and registers the
tag.
jsp:setProperty This sets the value of a property in a Bean.
jsp:getProperty This tag gets the value of a Bean instance property, converts it to a
string, and puts it in the implicit object "out".
jsp:include
jsp:forward
The 1.1 releases will include additional standard tags. The advantage of tags is
that they are easy to use and share between applications. The real power of a tag-based
syntax comes with the development of custom tag libraries, in which tool vendors or
others can create and distribute tags for specific purposes.
Scripting Elements
JSP pages can includes include small scripts, called scriptlets, in a page. A scriplet
is a code fragment, executed at request time processing. Scriptlets may be combined with
static elements on the page (as in the example above) to create a dynamically generated
page.
Scripts are delineated within <% and %> markers. The scripting language engine
will evaluate anything within those markers.
The JSP specification supports all of the usual script elements, including expressions and
declarations.
Application Models for JSP Pages
A JSP page is executed by a JSP engine, which is installed in a web server or a
JSP-enabled application server. The JSP engine receives requests from a client to a JSP
page, and generates responses from the JSP page to the client.
JSP pages are typically compiled into Java Servlets. Java Servlets are a standard
Java extension, described in more detail at www.java.sun.com. The page developer has
access to the complete Java application environment, with all of the scalability and
portability of the Java technology-enabled family.
When a JSP page is first called, if it does not yet exist, it is compiled into a Java
Servlet class and stored in the server memory. This enables very fast responses for
subsequent calls to that page. (This avoids the CGI-bin problem of spawning new
processes for each HTTP request, or the runtime parsing required by server-side
includes.)
JSP pages may be included in a number of different application architectures or
models. JSP pages may be used in combination with different protocols, components and
formats. The following sections describe a few of the possibilities.
The Future for JSP Technology
JSP technology is designed to be an open, extensible standard for building
dynamic web pages. Developers will use JSP pages to create portable web applications
that can run with different web and application servers for different markets, using
whatever authoring tools fit their market and their needs.
By working with a consortium of industry leaders, Sun has ensured that the JSP
specification is open and portable. You should be able to author JSP pages anywhere and
deploy them anywhere, using any client and server platforms. Over time, tool vendors
and others will extend the functionality of the platform by providing customized tag
libraries for specialized functions.
Java Script
JavaScript may be considered a derivative of the programming language Java. But
while both are tools for providing interactivity into web pages, they are as different as
bananas and papayas.
Java is a complex programming environment where you create packaged
("compiled") software applications that you can insert into a web page. The learning
curve for Java is monumental at best (despite claims of the expanding number of software
tools). On the other hand, JavaScript offers a simpler set of programming instructions that
you can enter directly among the HTML formatting of your web pages, and code that can
be easily accessed and modified.
Before JavaScript, to create interactive forms (web pages with fields, buttons, and
menus) we needed to write computer programs ("CGI" scripts) that resided on and ran
from a web server. But with JavaScript, you can perform many form tasks without
connecting to a web server. In the jargon, we are processing on the "client-side".
Even better, JavaScript allows you to create content that is dynamic, so that the code
inside one web page can produce many different types of displays and features depending
on the viewer's actions, including the images that change when you move the mouse over
a graphic.
JavaScript combined with the absolute screen positioning available in web
browsers that support HTML 4.0 provide what is known as Dynamic HTML, or
DHTML.
Advantages of JavaScript
As stated above, JavaScript provides interactivity for your web pages without
relying on server-side "CGI") programming, which means your pages can be interactive
even when you are not connected to the Internet. Since the code is typed directly into
your HTML files, you can create Javascript with software as simple as a plain text editor.
You can quickly test and modify JavaScript code. JavaScript functionality is built into
most newer web browsers since 1996, so there is no extra software for the viewer to
download or install.
JavaScript also provides useful commands for testing the viewer’s capability to
view other types of web multimedia (i.e. whether they have Shockwave installed).
Although not all web browsers may support JavaScript, there are fairly reliable methods
for you to direct viewers to alternative pages.
Because of its wide use, there are numerous reference sites for learning about JavaScript
as well as many sites to download free code that you can use. We'll share a few with you
in the next section.
Disadvantages of JavaScript
If you lack experience in programming, JavaScript will look daunting to you.
Often, it is not clear how the code works when you examine the HTML source. Long,
complicated JavaScript can add quite a bit of download time to your HTML page.
Although JavaScript is supported on the two major web browsers, there are a few
differences that may cause problems. Many of the graphic HTML creation tools do not
handle JavaScript very well.
Microsoft SQL Server
Relational Database Concepts
Databases contain data that's specifically organized. A database can be as simple
as a flat file (a single computer file with data usually in a tabular form) containing names
and telephone numbers of one's friends, or as elaborate as the worldwide reservation
system of a major airline. During the 90s, the relational data access scheme came to the
forefront. Relational scheme views data as rows of information. Each row contains
columns of data, called fields. The main concept in the relational scheme is that the data
is uniform. Each row contains the same number of columns. One such collection of rows
and columns is called a table. Many such tables form a relational database. Tables contain
records. There are three types of data record relationships between records:
One-to-one. One record in a table is related to at least one record in another table.
One-to-many relationship. One record in a table could be associated with many records in
another table.
Many-to-many relationships. Many records in a table could be associated with many
records in another table.
Features of RDBMS
A relational DBMS must be able to manage databases entirely through its
relational capabilities
All information in a relational database (including table and column names) is
represented explicitly as values in tables
Guaranteed access--Every value in a relational database is guaranteed to be accessible by
using a combination of the table name, primary key value, and column name
Systematic null value support--The DBMS provides systematic support for the treatment
of null values (unknown or inapplicable data), distinct from default values, and
independent of any domain
Active, online relational catalog--The description of the database and its contents
is represented at the logical level as tables and can therefore be queried using the
database language
View updating--All views that are theoretically updateable can be updated through the
system
Set-level insertion, update, and deletion--The DBMS supports not only set-level
retrievals but also set-level inserts, updates, and deletes
Physical data independence--Application programs and ad hoc programs are logically
unaffected when physical access methods or storage structures are altered
Logical data independence--Application programs and ad hoc programs are
logically unaffected, to the extent possible, when changes are made to the table structures
Integrity independence--The database language must be capable of defining integrity
rules. They must be stored in the online catalog, and they cannot be bypassed
Distribution independence--Application programs and ad hoc requests are
logically unaffected when data is first distributed or when it is redistributed
No subversion--It must not be possible to bypass the integrity rules defined
through the database language by using lower-level languages.
This method has several advantages and many disadvantages. In its favor is the
fact that the physical structure of data on a disk becomes unimportant. The programmer
simply stores pointers to the next location, so data can be accessed in this manner. Also,
data can be added and deleted easily. However, different groups of information could not
be easily joined to form new information. The format of the data on the disk could not be
arbitrarily changed after the database was created. Doing so would require the creation of
a new database structure.
Microsoft SQL Server
Microsoft SQL Server is a relational database management system produced by
Microsoft. It supports Microsoft's version of Structured Query Language (SQL), the most
common database language. It is commonly used by businesses for small- to mediumsized databases, and — in the past five years — some large enterprise databases.
Brief History of SQL Server
The code base for Microsoft SQL Server (prior to version 7.0) originated in
Sybase SQL Server, and was Microsoft's entry to the enterprise-level database market,
competing against Oracle, IBM, and Sybase. Microsoft, Sybase and Ashton-Tate teamed
up to create and market the first version named SQL Server 4.2 for OS/2 (about 1989)
which was essentially the same as Sybase SQL Server 4.0 on Unix, VMS, etc. Microsoft
SQL Server for NT v4.2 was shipped around 1992 (available bundled with Microsoft
OS/2 version 1.3) and was a simple port from OS/2 to NT. Microsoft SQL Server v6.0
was the first version of SQL Server that was architect for NT and did not include any
direction from Sybase.
About the time Windows NT was coming out, Sybase and Microsoft parted ways
and pursued their own design and marketing schemes. Microsoft negotiated exclusive
rights to all versions of SQL Server written for Microsoft operating systems. Later,
Sybase changed the name of its product to Adaptive Server Enterprise to avoid confusion
with Microsoft SQL Server. Until 1994 Microsoft's SQL Server carried three Sybase
copyright notices as an indication of its origin.
Several revisions have been done independently since with improvements for
SQL Server. SQL Server 7.0 was the first true GUI based database server and was a
rewrite away from the legacy Sybase code, a variant of SQL Server 2000 was the first
commercial database for the Intel IA64 architecture. During this time there was a rivalry
between Microsoft and Oracle's servers for winning the market over enterprise
customers.
The current version, Microsoft SQL Server 2005, was released in November of
2005. The launch took place alongside Visual Studio 2005 and BizTalk Server 2006. The
SQL Server 2005 Express edition is currently available for free download. The Microsoft
SQL Server product is not just a database, it also contains (as part of the product) an
enterprise ETL tool (Integration Services), Reporting Server, OLAP and messaging
technologies specifically Service Broker.
Versions for Windows
1993 - SQL Server 4.21 for Windows NT
1995 - SQL Server 6.0, codenamed SQL95
1996 - SQL Server 6.5, codenamed Hydra
1999 - SQL Server 7.0, codenamed Sphinx
1999 - SQL Server 7.0 OLAP, codenamed Plato
2000 - SQL Server 2000 32-bit, codenamed Shiloh
2003 - SQL Server 2000 64-bit, codenamed Liberty
2005 - SQL Server 2005, codenamed Yukon
Next release - codenamed Katmai
Description
MS SQL Server uses a variant of SQL called T-SQL, or Transact-SQL, an
implementation of SQL-92 (the ISO standard for SQL, certified in 1992) with some
extensions. T-SQL mainly adds additional syntax for use in stored procedures, and affects
the syntax of transactions support. (Note that SQL standards require (ACID) Atomic,
Consistent, and Isolated, Durable transactions.) MS SQL Server and Sybase/ASE both
communicate over networks using an application-level protocol called Tabular Data
Stream (TDS). The TDS protocol has also been implemented by the FreeTDS project
([1]) in order to allow more kinds of client applications to communicate with MS SQL
Server and Sybase databases. MS SQL Server also supports Open Database Connectivity
(ODBC).
Variants
A stripped-down version of Microsoft SQL Server known as MSDE (Microsoft
SQL Server Desktop Engine) is distributed with products such as Visual Studio, Visual
FoxPro, Microsoft Access, ASP.NET Web Matrix, and other products. MSDE has some
restrictions: a limit of 2 GB databases, and it comes with no GUI tools to administer it. It
also has a workload governor, which reduces its speed once you exceed 8 concurrent
workloads on the engine.
Microsoft recently released the successor to MSDE, dubbed SQL Server Express.
Similar to MSDE, SQL Express includes all the core functionality of SQL Server and the
workload governor was removed, but places restrictions on the scale of databases. It will
only utilize a single CPU, 1 GB of RAM, and imposes a maximum size of 4 GB per
database (log sizes don't count). Microsoft provides a separate download ("feature pack")
for the Express edition that includes less feature rich version of Reporting Services. SQL
Express also doesn't include enterprise features such as Analysis Services, Data
Transformation Services, and Notification Services. Unlike MSDE, SQL Express
includes a management console, called SQL Server Management Studio Express.
JDBC
The Java Database Connectivity (JDBC) of the Java Enterprise APIs is the first of
such cross-platform, cross-database approaches to database access from Java programs.
The Enterprise APIs also consist have Remote Method Invocation (RMI) and
serialization APIs (for Java programs to Marshall objects across namespaces and invoke
methods in remote objects), Java IDL (Interface Definition Language) for communicating
with CORBA, and other object-oriented systems. The JDBC APIs and the JDBC-ODBC
Bridge, you can access and interact effectively with almost all databases from Java
applets and applications.
JDBC Drivers
JDBC Drivers are set of classes that enable the Java application to communicate
with databases. Java.sql that ships with JDK contains various classes for using relational
databases. But these classes do not provide any implementation only the behaviors are
defined. The actual implementations are done in third-party drivers. Third party vendors
implement the java.sql.Driver interface in their database driver.
JDBC technology drivers fit into one of four categories:
1. A JDBC-ODBC bridge provides JDBC API access via one or more ODBC
drivers. Note that some ODBC native code and in many cases native database client code
must be loaded on each client machine that uses this type of driver. Hence, this kind of
driver is generally most appropriate when automatic installation and downloading of a
Java technology application is not important. For information on the JDBC-ODBC
Bridge driver provided by Sun.
2. A native-API partly Java technology-enabled driver converts JDBC calls into
calls on the client API for Oracle, Sybase, Informix, DB2, or other DBMS. Note that, like
the bridge driver, this style of driver requires that some binary code be loaded on each
client machine.
3. A net-protocol fully Java technology-enabled driver translates JDBC API calls
into a DBMS-independent net protocol which is then translated to a DBMS protocol by a
server. This net server middleware is able to connect all of its Java technology-based
clients to many different databases. The specific protocol used depends on the vendor. In
general, this is the most flexible JDBC API alternative. It is likely that all vendors of this
solution will provide products suitable for Intranet use. In order for these products to also
support Internet access they must handle the additional requirements for security, access
through firewalls, etc., that the Web imposes. Several vendors are adding JDBC
technology-based drivers to their existing database middleware products.
4. A native-protocol fully Java technology-enabled driver converts JDBC
technology calls into the network protocol used by DBMSs directly. This allows a direct
call from the client machine to the DBMS server and is a practical solution for Intranet
access. Since many of these protocols are proprietary the database vendors themselves
will be the primary source for this style of driver. Several database vendors have these in
progress.
The Windows 2000 Operating System:
A Brief History of Windows Operating System
In 1983 Microsoft announced its development of Windows, a graphical user
interface (GUI) for its own operating system (MS-DOS) that had shipped for IBM PC
and compatible computers since 1981. Microsoft modeled the GUI, which was first
known as Interface Manager, after that of Apple's Mac OS. Bill Gates had been shown a
Macintosh prototype by Steve Jobs early in its development, around 1981, and Microsoft
was partnered by Apple to create some of the important early Mac software, such as
Word and Excel.
The first independent version of Microsoft Windows 1.0, released in 1985, lacked
a degree of functionality and achieved little popularity. It was originally going to be
called Interface Manager, but Rowland Hanson, the head of marketing at Microsoft,
convinced the company that the name Windows would be a more appealing name to
consumers. Windows 1.0 did not provide a complete operating system, but rather
extended MS-DOS and shared the latter's inherent flaws and problems. Moreover, the
programs that shipped with the early version comprised "toy" applications with little or
limited appeal to business users.
Microsoft Windows 2.0 came out in 1987, and proved slightly more popular than
its predecessor. Much of the popularity for Windows 2.0 came by way of its inclusion as
a "run-time version" with Microsoft's new graphical applications, Excel and Word for
Windows. They could be run from MS-DOS, executing Windows for the duration of their
activity, and closing down Windows upon exit.
In late 1987 two new versions were released, named Windows/286 2.1 and
Windows/386 2.1. Windows/286 was just adding a few additions to Windows 2.0 and
still ran in real mode, but was the first version to support using the HMA, while
Windows/386 had a protected mode kernel with EMS emulation, and no, it isn't
kernel.exe (that and all Windows applications were still real mode applications, running
over the protected mode kernel by using virtual 8086 mode, which is new to the 80386
and not only that, even DOS applications ran over it), it is win386.exe.
Windows 3.0, released in May 1990, was a complete overhaul of the Windows
environment. With the capability to address memory beyond 640K and a much more
powerful user interface, independent software vendors started developing Windows
applications with vigor. The powerful new applications helped Microsoft sell more than
10 million copies of Windows, making it the best-selling graphical user interface in the
history of computing.
Windows 3.1, released in April 1992 provides significant improvements to
Windows 3.0. In its first two months on the market, it sold over 3 million copies,
including upgrades from Windows 3.0 .
Windows 3.11 added no new features but corrects some existing, mostly
network-related problems. It is replacing Windows 3.1 at the retail and OEM levels, and
the upgrade was available free from ftp.microsoft.com.
Windows NT 3.1, 94-03-01 is Microsoft's platform of choice for high-end
systems. It is intended for use in network servers, workstations and software development
machines; it will not replace Windows for DOS. While Windows NT's user interface is
very similar to that of Windows 3.1, it is based on an entirely new operating system
kernel.
Windows NT 3.5, 94-04-12 provides OLE 2.0, improved performance and
reduced memory requirements. It was released in September 1994. Windows NT 3.5
Workstation replaces Windows NT 3.1, while Windows NT 3.5 Server replaces the
Windows NT 3.1 Advanced Server.
Windows NT 4.0, ("Cairo") 94-03-15 Microsoft's project for object-oriented
Windows, and a successor to the "Daytona" release of Windows NT.
Windows 95 was released in August of 1995. A 32-bit system is providing full
pre-emptive multitasking, advanced file systems, threading, networking and more.
Includes MS-DOS 7.0, but takes over from DOS completely after starting. Also includes
a completely revised user interface.
Windows 98 was released in June of 1998. Integrated Web Browsing gives your
desktop a browser-like interface. You will 'browse' everything, including stuff on your
local computer. Active Desktop allows you to setup your desktop to be your personal
web page, complete with links and any web content. You can also place active desktop
items, such as a stock ticker, that will update automatically. Internet Explorer 4.0 New
browser that supports HTML 4.0 and has an enhanced user interface. ACPI supports
FAT32 with Conversion utility Enhanced & Efficient support for larger hard drives.
Includes a utility to convert your FAT16 to a FAT32 partition. Multiple Display Support
can expand your desktop onto up to 8, connected monitors. New Hardware support will
support the latest technology such as DVD, Firewire, USB, and AGP. Win32 Driver
model uses it driver model as Windows NT 5.0 Disk Defragmentor Wizard Enhanced
hard drive defragmentor to speed up access to files and applications.
Microsoft released Windows 2000, known during its development cycle as "NT
5.0", in February 2000. It was successfully deployed both on the server and the
workstation markets. Windows 2000, claimed by some to be the best Windows version to
date, incorporated a number of features, in particular the user interface, from Windows
98. Windows 2000 also introduced Active Directory, a near-complete replacement of NT
4's Windows Server domain model, which built on industry-standard technologies like
DNS, LDAP and Kerberos to connect machines to one another. Terminal Services,
previously only available as a separate edition of NT 4, was expanded to all server
versions.
While Windows 2000 could upgrade a computer running Windows 98, Microsoft
did not see Windows 2000 as a product designed for home users; instead, a continuation
of the Windows 95/98 product line was shipped shortly after Windows 2000 called
Windows Me.
Windows 2000 came in five editions:
Windows 2000 Professional
Windows 2000 Server
Windows 2000 Advanced Server
Windows 2000 Datacenter Server
Windows 2000 Small Business Server
DATA FLOW
DIAGRAM
Login Module
login.html
Login process.jsp
manager.html
clerk.html
If - Login fails
Return to
loginfailed.html
logout.jsp
Send to EJB
Bank Master
Manager.html / Clerk.html
openingacco
unt.html
accview.html
openingaccount_
process.jsp
viewaccount_p
rocess.jsp
opening_savac
count.jsp
opening_sav_p
rocess.jsp
accmodify.html
modifyaccount_pr
ocess.jsp
modify_sav_account.jsp
view_savacc
ount.jsp
modify_sav_process.jsp
accclose.html
accountclose
_process.jsp
Transaction Only by Manager
Withdraw.html
deposit.html
Withdraw_process.jsp
deposit_process.jsp
transfer.html
transfer_process.jsp
Send to EJB
Reports Only by Manager
Bank Reports
Customer Reports
cdate_report.html
bdate_report.html
cperiod_report.html
bperiod_report.html
cdate_process.jsp
bdate_report_process.jsp
bperiod_process.jsp
cperiod_report_process.jsp
Entity Bean
EJB Concepts
Login
SessionFacade
Session Bean
LoginRemote.java
LoginHome.java
LoginBean.java
Savings
SessionFac
adeRemote
.java
SessionFac
adeHome.j
ava
Sessi
onBe
an To
maint
ain
custo
mer
state
SavingsRemote.java
SavingsHome.java
SavingsBean.java
PKGeneratorFactory.java
DBConnectionFactory.java
ViewSaveBean.java
Current
CurrentRemote.java
CurrentHome.java
CurrentBean.java
ViewCurBean.java
Recurring
SessionFac
adeBean.ja
va
RecurringRemote.java
RecurringHome.java
RecurringBean.java
ViewRerBean.java
Transfer
TransRemote.java
TransHome.java
TransBean.java
ViewTransBean.java
DATA
DICTIONARY
Data Dictionary
Login Data Structure:Login
Field Name
Data type
Size
Primary key
Null
USERID
PASSWORD
TYPE
VARCHAR2
VARCHAR2
VARCHAR2
10
10
30
Y
N
N
N
Field Name
Datatype
Savings
Size
Primary Key
Null
ACCNO
ACCTYPE
BALANCE
NAME
VARCHAR2
VARCHAR2
NUMBER
VARCHAR2
10
20
9,2
30
Y
N
N
N
N
Field Name
Data type
Savings
Size
Primry key
Null
OPENDATE
ADDRESS
PHONE
OCCUPATION
NATION
CHEQUE
INCOME
STATUS
DOB
GENDER
DATE
VARCHAR2
NUMBER
VARCHAR2
VARCHAR2
VARCHAR2
NUMBER
VARCHAR2
DATE
VARCHAR2
Savings:-
N
50
11
20
20
20
9,2
20
15
N
N
N
Recurring Account Data Structure:-
Field Name
Data type
ACCNO
ACCTYPE
OPENDATE
BALANCE
PERIOD
MATAMT
INTEREST
NAME
ADDRESS
PHONE
OCCUPATION
NATION
INCOME
DOB
GENDER
MDATE
STATUS
VARCHAR2
VARCHAR2
DATE
NUMBER
NUMBER
NUMBER
NUMBER
VARCHAR2
VARCHAR2
NUMBER
VARCHAR2
VARCHAR2
NUMBER
DATE
VARCHAR2
DATE
VARCHAR2
Recurring
Size
10
20
Primary key
Null
Y
N
N
N
N
N
N
N
N
9,2
5,2
9,2
5,2
30
50
11
20
20
9,2
15
N
N
20
Current Account Data Structure:-
Field Name
Data Type
ACCNO
ACCTYPE
OPENDATE
BALANCE
NAME
ADDRESS
PHONE
OCCUPATION
NATION
INCOME
CHEQUE
STATUS
DOB
GENDER
VARCHAR2
VARCHAR2
DATE
NUMBER
VARCHAR2
VARCHAR2
NUMBER
VARCHAR2
VARCHAR2
NUMBER
VARCHAR2
VARCHAR2
DATE
VARCHAR2
CURRENT
Size
10
20
9,2
30
50
11
20
20
9,2
20
20
15
Primary Key
Null
Y
N
N
N
N
N
N
N
N
Reports Data Structure:-
Field Name
TRANSNO
ACCNO
NAME
ACCTYPE
TDATE
TRATYPE
TRAAMT
REPORTS
Size
Data Type
VARCHAR2
VARCHAR2
VARCHAR2
VARCHAR2
DATE
VARCHAR2
NUMBER
10
10
10
20
30
9,2
Primary Key
Y
Null
N
N
N
N
N
N
N
SOURCE CODE
Opening Current account process:<%@page import="java.util.*,java.rmi.*,
javax.ejb.*,javax.naming.*,login.*,factory.*,savings.*,SessionFacade.*,
current.*" %>
<%!
String cheque,status,ret;
java.sql.Date odate;
double balance ;%>
<%
System.out.println("in savings: ");
java.util.Date u=new java.util.Date();
odate= new java.sql.Date(u.getYear(),u.getMonth(),u.getDate());
System.out.println(odate);
cheque=request.getParameter("cheque");
status=request.getParameter("status");
balance=Double.parseDouble(request.getParameter("balance"));
ViewCurBean bean= (ViewCurBean)session.getAttribute("CURBEAN");
bean.setOpendate(odate);
bean.setCheque(cheque);
bean.setStatus(status);
bean.setBalance(balance);
SessionFacadeRemote
remote=(SessionFacadeRemote)session.getAttribute("FACADE");
ret= remote.createCurAccount(bean);
if (ret.equals("exception")){
response.sendRedirect("accoutopening_fail.html");
}
else{
session.setAttribute("ACCNO",ret);
response.sendRedirect("./view_cur_account.jsp");
}
%>
Bank Report Process – daily:<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%@ page import="java.util.*" %>
<html>
<head>
<title>Banking Information System</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-88591">
</head>
<%@page import="java.util.*,java.rmi.*, javax.ejb.*,javax.naming.*,
trans.*, SessionFacade.*" %>
<link rel="stylesheet" href="css/mystyle.css" type="text/css" />
<body>
<table width=800 align=center border=0>
<tr>
<td align=center height=65 class=banner bgcolor=#8A4F28>Banking
Information System</td>
</tr>
<tr><td>
<%! String date;
int i;
StringTokenizer st;
java.sql.Date d,d1;
java.util.Date u=new java.util.Date();
java.util.Date u1;
Collection col;
%>
<div align=center class=brownhead>Bank Daily Report<div><br>
<strong>Date:<strong> <%=new
java.sql.Date(u.getYear(),u.getMonth(),u.getDate())%>
<%
System.out.println("in date_report.jsp: ");
date= request.getParameter("date");
st = new StringTokenizer(date,"-");
i=0;
int a[]=new int[3];
while(st.hasMoreTokens()){
a[i]=Integer.parseInt(st.nextToken("-"));
System.out.println("tocken: " +a[i] );
i++;
}
d=new java.sql.Date(a[0],a[1],a[2]);
d=d.valueOf(date);
System.out.println("sql date: " + d );
SessionFacadeRemote
remote=(SessionFacadeRemote)session.getAttribute("FACADE");
col=remote.getBankReportByDate(d);
%>
<table border="0" align="center">
<tr bgcolor="#FFFFCC">
<td><strong><font color="#660000">Transaction Date
</font></strong></td>
<td><strong><font color="#660000">AccNo.</font></strong></td>
<td><strong><font color="#660000">AccountType</font></strong></td>
<td><strong><font color="#660000">Transaction Done
by</font></strong></td>
<td><strong><font color="#660000">Transaction
Type</font></strong></td>
<td><strong><font color="#660000">Transaction
Amount</font></strong></td>
</tr>
<%
if(!col.isEmpty()){
Iterator i=col.iterator();
while(i.hasNext()){
ViewTransBean bean=(ViewTransBean)i.next();
if(bean==null){
response.sendRedirect("transcation_failed.html");
}
else{ %>
<tr bgcolor="#CCCCCC">
<td><%= bean.getTdate()%></td>
<td><%=bean.getAccno()%></td>
<td><%= bean.getAcctype()%></td>
<td><%=bean.getName()%></td>
<td><%= bean.getTratype()%></td>
<td><%=bean.getTraamt()%></td>
<%
}// if
}//for while
%>
</tr>
<%}
else{
response.sendRedirect("transcation_failed.html");
}
%>
</table>
<p>&nbsp;</p>
<div align="center"><hr width=100>
<a href="reports.html" class=bblink>Back</a><hr width=100>
</div>
</td></tr>
<tr>
<td align=center class=greysmall><hr width=800>
All rights are reserved with E-Banking Solutions Pvt. Ltd.</td></tr>
</table></body></html>
DB Connection Factory:package current;
import javax.naming.*;
import java.sql.*;
import javax.sql.*;
import java.util.*;
public final class DBConnectionFactory
{
private static DBConnectionFactory factory;
Hashtable ht;
Context ctxt;
DataSource ds;
Connection con;
Map map;
private DBConnectionFactory()
{
try
{
ht=new Hashtable();
ht.put(Context.INITIAL_CONTEXT_FACTORY,"weblogic.jndi.WLInitialConte
xtFactory");
ht.put(Context.PROVIDER_URL,"t3://localhost:7001");
ctxt=new InitialContext(ht);
map=Collections.synchronizedMap(new HashMap());
}catch(Exception e){e.printStackTrace();}
}
public static DBConnectionFactory getFactory()
{
if(factory==null)
{
factory = new DBConnectionFactory();
return factory;
}
return factory;
}
public Connection getConnection (String jndiName)
{
try{
Object o=map.get(jndiName);
if(o==null)
{
ds=(DataSource)ctxt.lookup(jndiName);
map.put(jndiName,ds);
}
else
{
ds=(DataSource)o;
}
con=ds.getConnection();
}catch(Exception e){e.printStackTrace();}
return con;
}
}
Current account:Current Home interface:package current;
import java.rmi.*;
import javax.ejb.*;
public interface CurrentHome extends EJBHome{
public CurrentRemote create( String acctype, java.sql.Date opendate, double
balance,String name,String address, long phone, String occupation, String nation, double
income,String cheque,String status,java.sql.Date dob, String gender) throws
CreateException,RemoteException;
public CurrentRemote findByPrimaryKey(String pk)throws
FinderException,RemoteException;
}
Current Remote interface:-
package current;
import java.rmi.*;
import javax.ejb.*;
public interface CurrentRemote extends EJBObject{
public boolean deposit (double amt) throws RemoteException;
public boolean withdraw (double amt) throws RemoteException;
public ViewCurBean view()throws RemoteException;
public void setCurAccno(String accno ) throws RemoteException;
public String getCurAccno() throws RemoteException;
public void setCurAcctype(String acctype ) throws RemoteException;
public String getCurAcctype() throws RemoteException;
public void setCurName(String name) throws RemoteException;
public String getCurName() throws RemoteException;
public void setCurAddress(String address) throws RemoteException;
public String getCurAddress() throws RemoteException;
public void setCurPhone(long phone) throws RemoteException;
public long getCurPhone() throws RemoteException;
public void setCurOccupation(String occupation) throws RemoteException;
public String getCurOccupation() throws RemoteException;
public void setCurNation(String nation ) throws RemoteException;
public String getCurNation() throws RemoteException;
public void setCurCheque(String cheque) throws RemoteException;
public String getCurCheque() throws RemoteException;
public void setCurStatus(String status) throws RemoteException;
public String getCurStatus() throws RemoteException;
public void setCurBalance(double balance ) throws RemoteException;
public double getCurBalance() throws RemoteException;
public void setCurIncome(double income) throws RemoteException;
public double getCurIncome() throws RemoteException;
public void setCurOpendate(java.sql.Date opendate ) throws RemoteException;
public java.sql.Date getCurOpendate() throws RemoteException;
public void setCurDob(java.sql.Date dob ) throws RemoteException;
public java.sql.Date getDob() throws RemoteException;
public void setCurGender(String gender ) throws RemoteException;
public String getCurGender() throws RemoteException;
}
CurrentBean:package current;
import java.rmi.*;
import javax.ejb.*;
public abstract class CurrentBean implements EntityBean{
EntityContext ectxt;
public void setEntityContext(EntityContext ectxt){
this.ectxt=ectxt;
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
set entiy");
}
public void unsetEntityContext(){
ectxt=null;
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
unset entiy");
}
public String ejbCreate(String acctype, java.sql.Date opendate, double
balance,String name,String address, long phone, String occupation, String nation, double
income,String cheque,String status,java.sql.Date dob, String gender) throws
CreateException,RemoteException {
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
create");
this.setAccno(PKGeneratorFactory.getFactory().getStringPrimaryKey("curent","accno"))
;
this.setAcctype(acctype);
this.setOpendate(opendate);
this.setBalance(balance);
this.setName(name);
this.setAddress(address);
this.setPhone(phone);
this.setOccupation(occupation);
this.setIncome(income);
this.setNation(nation);
this.setCheque(cheque);
this.setStatus(status);
this.setDob(dob);
this.setGender(gender);
return this.getAccno();
}//end Create
public void ejbPostCreate(String acctype, java.sql.Date opendate, double
balance,String name,String address, long phone, String occupation, String nation, double
income,String cheque,String status,java.sql.Date dob, String gender) throws
CreateException,RemoteException{
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
postcreate");
}
public void
ejbRemove(){System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
remove");}
public void
ejbPassivate(){System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
pass");}
public void
ejbActivate(){System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
act");}
public void
ejbLoad(){System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
load");}
public void
ejbStore(){System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in set
store");}
public abstract void setAccno(String accno );
public abstract String getAccno();
public abstract void setAcctype(String acctype );
public abstract String getAcctype();
public abstract void setName(String name);
public abstract String getName();
public abstract void setAddress(String address);
public abstract String getAddress();
public abstract void setPhone(long phone);
public abstract long getPhone();
public abstract void setOccupation(String occupation);
public abstract String getOccupation();
public abstract void setNation(String nation );
public abstract String getNation();
public abstract void setCheque(String cheque);
public abstract String getCheque();
public abstract void setStatus(String status);
public abstract String getStatus();
public abstract void setBalance(double balance );
public abstract double getBalance();
public abstract void setIncome(double income);
public abstract double getIncome();
public abstract void setOpendate(java.sql.Date opendate );
public abstract java.sql.Date getOpendate();
public abstract void setDob(java.sql.Date dob );
public abstract java.sql.Date getDob();
public abstract void setGender(String gender );
public abstract String getGender();
/* Remote Methods *****************/
public void setCurAccno(String accno ){ this.setAccno(accno);}
public String getCurAccno(){ return this.getAccno();}
public void setCurAcctype(String acctype ){ this.setAcctype(acctype);}
public String getCurAcctype(){ return this.getAcctype();}
public void setCurName(String name){ this.setName(name);}
public String getCurName(){ return this.getName();}
public void setCurAddress(String address){ this.setAddress(address);}
public String getCurAddress(){ return this.getAddress();}
public void setCurPhone(long phone){ this.setPhone(phone);}
public long getCurPhone(){ return this.getPhone();}
public void setCurOccupation(String occupation){
this.setOccupation(occupation);}
public String getCurOccupation(){ return this.getOccupation();}
public void setCurNation(String nation ){ this.setNation(nation);}
public String getCurNation(){ return this.getNation();}
public void setCurCheque(String cheque){ this.setCheque(cheque);}
public String getCurCheque(){ return this.getCheque();}
public void setCurStatus(String status){ this.setStatus(status);}
public String getCurStatus(){ return this.getStatus();}
public void setCurBalance(double balance ){ this.setBalance(balance);}
public double getCurBalance(){ return this.getBalance();}
public void setCurIncome(double income){ this.setIncome(income);}
public double getCurIncome(){ return this.getIncome();}
public void setCurOpendate(java.sql.Date opendate ){
this.setOpendate(opendate);}
public java.sql.Date getCurOpendate(){ return this.getOpendate();}
public void setCurDob(java.sql.Date dob ){ this.setDob(dob);}
public java.sql.Date getCurDob(){ return this.getDob();}
public void setCurGender(String gender ){ this.setGender(gender);}
public String getCurGender(){ return this.getGender();};
public ViewCurBean view()throws RemoteException{
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
view()");
ViewCurBean bean=new ViewCurBean();
bean.setAccno(this.getAccno());
bean.setAcctype(this.getAcctype());
bean.setOpendate(this.getOpendate());
bean.setBalance(this.getBalance());
bean.setName(this.getName());
bean.setAddress(this.getAddress());
bean.setPhone(this.getPhone());
bean.setOccupation(this.getOccupation());
bean.setNation(this.getNation());
bean.setCheque(this.getCheque());
bean.setIncome(this.getIncome());
bean.setStatus(this.getStatus());
bean.setGender(this.getGender());
bean.setDob(this.getDob());
return bean;
}//end view
public boolean deposit (double amt) throws RemoteException{
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
dep()");
String status=this.getCurStatus();
if("open".equals(status)){
this.setCurBalance(this.getCurBalance()+amt);
return true;
}
else{
System.out.println("Closed Account");
return false;
}
}//end deposit
public boolean withdraw (double amt) throws RemoteException{
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
wit()");
String status=this.getCurStatus();
if("open".equals(status)){
if(this.getCurBalance()>=amt){
this.setCurBalance(this.getCurBalance()-amt);
return true;
}
else{
System.out.println("Low Balance");
return false;
}
}
else{
System.out.println("Closed Account");
return false;
}
}//end withdraw
}//end class
Session Facade Home:package SessionFacade;
import java.rmi.*;
import javax.ejb.*;
public interface SessionFacadeHome extends EJBHome{
public SessionFacadeRemote create() throws CreateException,RemoteException;
}
Session Facade Remote:package SessionFacade;
import java.rmi.*;
import javax.ejb.*;
import java.util.*;
import savings.*;
import recurring.*;
import login.*;
import current.*;
import trans.*;
public interface SessionFacadeRemote extends EJBObject{
public int checkUser(String userid,String type) throws RemoteException;
// creating
public String createSavAccount(ViewSavBean create) throws RemoteException;
public String createRerAccount(ViewRerBean create) throws RemoteException;
public String createCurAccount(ViewCurBean create) throws RemoteException;
public String createTransaction(ViewTransBean create) throws
RemoteException;
// viewing
public ViewSavBean viewSavAccount(String accno) throws RemoteException;
public ViewCurBean viewCurAccount(String accno) throws RemoteException;
public ViewRerBean viewRerAccount(String accno) throws RemoteException;
// modifing
public int modifySavAccount(String accno ,ViewSavBean modify) throws
RemoteException;
public int modifyRerAccount(String accno, ViewRerBean modify) throws
RemoteException;
public int modifyCurAccount(String accno, ViewCurBean modify) throws
RemoteException;
// Transactions
public int depositIntoSav(String accno,double amount) throws RemoteException;
public int depositIntoCur(String accno,double amount) throws RemoteException;
public int withdrawFromSav(String accno,double amount) throws
RemoteException;
public int withdrawFromCur(String accno,double amount) throws
RemoteException;
public int transferSToS(String src_accno,String des_accno,double amount)throws
RemoteException;
public int transferSToC(String src_accno,String des_accno,double amount)throws
RemoteException;
public int transferCToC(String src_accno,String des_accno,double amount)throws
RemoteException;
public int transferCToS(String src_accno,String des_accno,double amount)throws
RemoteException;
//Reports
public Collection getBankReportByDate(java.sql.Date date)throws
RemoteException;
public Collection getBankReportByPeriod(java.sql.Date fdate,java.sql.Date
tdate)throws RemoteException;
public Collection getCustomerReportByDate(String accno,String
acctype,java.sql.Date date)throws RemoteException;
public Collection getCustomerReportByPeriod(String accno,String
acctype,java.sql.Date fdate,java.sql.Date tdate)throws RemoteException;
// isCloseFunctions
public int isSavClose(String accno) throws RemoteException;
public int isRerClose(String accno) throws RemoteException;
public int isCurClose(String accno) throws RemoteException;
// closeFunctions
public int savClose(String accno) throws RemoteException;
public int rerClose(String accno) throws RemoteException;
public int curClose(String accno) throws RemoteException;
}
Login Html design page code:<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Banking Information System-Login</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-88591">
</head>
<link rel="stylesheet" href="css/mystyle.css" type="text/css" />
<body>
<table width=800 align=center border=0>
<tr>
<td align=center height=65 class=banner bgcolor=#8A4F28>Banking
Information System</td>
</tr>
<tr><td>
<form action="./login_process.jsp" method=post >
<table width=100% height=400 border="0">
<tr><td>
<div align=center class=brownhead>Login</div>
<p>&nbsp;</p>
<table width="400" height="129" border="1" align="center"
bgcolor="#FFFFCC">
<tr><td>
<table width="300" border="0" align="center">
<tr><td width=150>User Id</td>
<td><input name="userid" type="text" id="userid"
size=25></td></tr>
<tr><td>Password</td>
<td><input name="password" type="password" id="password"
size=25></td></tr>
<tr><td>Role</td>
<td><select name="type" id="type"><option
selected>Manager</option>
<option>Clerk</option>
</select></td></tr>
</table>
</td></tr>
</table>
<p align="center"><input name="login" type="submit" id="login"
value="Login"></p>
</td>
</tr>
</table>
</form></td></tr>
<tr>
<td align=center class=greysmall><hr width=800>
All rights are reserved with E-Banking Solutions Pvt. Ltd.</td></tr>
</table></body></html>
Login Process With Jsp Code:<%@ page import="java.util.*,java.rmi.*,
javax.ejb.*,javax.naming.*,SessionFacade.SessionFacadeHome,SessionFacade.SessionFa
cadeRemote" %>
<%!
String userid,password,type;
int ret; %>
<%
System.out.println("in login process.jsp: ");
String type =request.getParameter("type");
System.out.println("type "+ type);
userid=request.getParameter("userid");
password=request.getParameter("password");
Hashtable ht= new Hashtable();
ht.put(Context.INITIAL_CONTEXT_FACTORY,"weblogic.jndi.WLInitialConte
xtFactory");
ht.put(Context.PROVIDER_URL,"t3://localhost:7001");
InitialContext ctxt= new InitialContext(ht);
SessionFacadeHome
home=(SessionFacadeHome)ctxt.lookup("SessionFacade.SessionFacadeHome");
SessionFacadeRemote remote=home.create();
ret= remote.checkUser(userid,password);
switch(ret){
case 1:
session.setAttribute("FACADE",remote);
session.setAttribute("name", userid);
session.setAttribute("type", type);
if("Manager".equals(type))
response.sendRedirect("manager.html");
else
response.sendRedirect("userlogin_failed.html");
break;
case 2:
session.setAttribute("FACADE",remote);
session.setAttribute("name", userid);
session.setAttribute("type", type);
if("Clerk".equals(type))
response.sendRedirect("clerk.html");
else
response.sendRedirect("userlogin_failed.html");
break;
default: response.sendRedirect("userlogin_failed.html");
}
%>
Savingbean With Servlet Coding:package savings;
import java.rmi.*;
import javax.ejb.*;
public abstract class SavingsBean implements EntityBean{
EntityContext ectxt;
public void setEntityContext(EntityContext ectxt){
this.ectxt=ectxt;
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
set entiy");
}
public void unsetEntityContext(){
ectxt=null;
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
unset entiy");
}
public String ejbCreate( String acctype, java.sql.Date opendate, double
balance,String name,String address, long phone, String occupation, String nation, double
income,String cheque,String status,java.sql.Date dob, String gender) throws
CreateException,RemoteException{
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
create");
this.setAccno(PKGeneratorFactory.getFactory().getStringPrimaryKey("savings","
accno"));
this.setAcctype(acctype);
this.setBalance(balance);
this.setOpendate(opendate);
this.setName(name);
this.setAddress(address);
this.setPhone(phone);
this.setOccupation(occupation);
this.setIncome(income);
this.setNation(nation);
this.setCheque(cheque);
this.setStatus(status);
this.setDob(dob);
this.setGender(gender);
return this.getAccno();
}//end Create
public void ejbPostCreate( String acctype, java.sql.Date opendate, double
balance,String name,String address, long phone, String occupation, String nation, double
income,String cheque,String status,java.sql.Date dob, String gender) throws
CreateException,RemoteException{
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
postcreate");
}
public void
ejbRemove(){System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
remove");}
public void
ejbPassivate(){System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
pass");}
public void
ejbActivate(){System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
act");}
public void
ejbLoad(){System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
load");}
public void
ejbStore(){System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in set
store");}
public abstract String getAccno();
public abstract void setAccno(String accno );
public abstract String getAcctype();
public abstract void setAcctype(String acctype );
public abstract String getName();
public abstract void setName(String name);
public abstract String getAddress();
public abstract void setAddress(String address);
public abstract long getPhone() ;
public abstract void setPhone(long phone) ;
public abstract String getOccupation() ;
public abstract void setOccupation(String occupation) ;
public abstract String getNation() ;
public abstract void setNation(String nation ) ;
public abstract String getCheque() ;
public abstract void setCheque(String cheque) ;
public abstract String getStatus() ;
public abstract void setStatus(String status) ;
public abstract double getBalance() ;
public abstract void setBalance(double balance ) ;
public abstract double getIncome() ;
public abstract void setIncome(double income) ;
public abstract java.sql.Date getOpendate() ;
public abstract void setOpendate(java.sql.Date opendate );
public abstract java.sql.Date getDob();
public abstract void setDob(java.sql.Date dob );
public abstract String getGender();
public abstract void setGender(String gender );
public void setAccountno(String accno ){ this.setAccno(accno);}
public String getAccountno(){ return this.getAccno();}
public void setAccounttype(String acctype ){ this.setAcctype(acctype);}
public String getAccounttype(){ return this.getAcctype();}
public void setCustName(String name){ this.setName(name);}
public String getCustName(){ return this.getName();}
public void setCustAddress(String address){ this.setAddress(address);}
public String getCustAddress(){ return this.getAddress();}
public void setCustPhone(long phone){ this.setPhone(phone);}
public long getCustPhone(){ return this.getPhone();}
public void setCustOccupation(String occupation){
this.setOccupation(occupation);}
public String getCustOccupation(){ return getOccupation();}
public void setCustNation(String nation ){ this.setNation(nation);}
public String getCustNation(){ return this.getNation();}
public void setCustCheque(String cheque){ this.setCheque(cheque);}
public String getCustCheque(){ return this.getCheque();}
public void setAccountStatus(String status){ this.setStatus(status);}
public String getAccountStatus(){ return this.getStatus();}
public void setAccountBalance(double balance ){ this.setBalance(balance);}
public double getAccountBalance(){ return this.getBalance();}
public void setCustIncome(double income){ this.setIncome(income);}
public double getCustIncome(){ return this.getIncome();}
public void setAccountOpendate(java.sql.Date opendate ){
this.setOpendate(opendate);}
public java.sql.Date getAccountOpendate(){ return this.getOpendate();}
public void setCustDob(java.sql.Date dob ){ this.setDob(dob);}
public java.sql.Date getCustDob(){ return this.getDob();}
public void setCustGender(String gender ){ this.setGender(gender);}
public String getCustGender(){ return this.getGender();}
public ViewSavBean view()throws RemoteException{
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
view()");
ViewSavBean bean=new ViewSavBean();
bean.setAccno(this.getAccno());
bean.setAcctype(this.getAcctype());
bean.setOpendate(this.getOpendate());
bean.setBalance(this.getBalance());
bean.setName(this.getName());
bean.setAddress(this.getAddress());
bean.setPhone(this.getPhone());
bean.setOccupation(this.getOccupation());
bean.setNation(this.getNation());
bean.setCheque(this.getCheque());
bean.setIncome(this.getIncome());
bean.setStatus(this.getStatus());
bean.setGender(this.getGender());
bean.setDob(this.getDob());
return bean;
}//end view
public boolean deposit (double amt) throws RemoteException{
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
dep()");
String status=this.getAccountStatus();
if("open".equals(status)){
this.setAccountBalance(this.getAccountBalance() + amt );
return true;
}
else{
System.out.println("Closed Account");
return false;
}
}//end deposit
public boolean withdraw (double amt) throws RemoteException{
System.out.println("@@@@@@@@@@@@@@@@@@@@@@ in
wit()");
String status=this.getAccountStatus();
if("open".equals(status)){
if(this.getAccountBalance()>=amt){
this.setAccountBalance(this.getAccountBalance() - amt );
return true;
}
else{
System.out.println("Low Balance");
return false;
}
}
else{
System.out.println("Closed Account");
return false;
}
}//end withdraw
}
SCREEN SHOTS
CONCLUSION
CONCLUSION
The “BANKING INFORMATION SYSTEM” Internet site manages the online
system like handling of various types of accounts, managing various types of accounts,
preparing different formats of reports.
A banking information system needs to be highly secure and all transactions need
careful handling. We will use Enterprise java bean in this project, which is good for
developing a distributive system with additional support for transactional security. This
application provides users friendly screens and design.
To provide easy services we have used this new technology. This project makes
the fund transfer very easy. To satisfy their wants “BANKING INFORMATION
SYSTEM” will become a good tool to use. It satisfies all requirements to both users and
organizations. As today’s life everything done in Internet so the most important thing is
this application works on Internet. This allows a large number of people to work in it. So
the performance is very high.
Finally, we like to conclude that we put all our efforts through out the
development of our project and tried to fulfill most of the requirements of the user. Here
we can make some enhancement in the designing and retrieving of the data.
A basic design has been developed, after learning J2EE and analyzing the
specifications. Furthermore, tables have to be designed and modules are to be evolved
and reports are to be generated
BIBLIOGRAPY
BIBLIOGRAPHY
REFERRED BOOKS:
.
 Head First Java
 Kathy Sierra & Bert Bates
 Head First Servlects & JSP
 Bryan Basham,Kathy Sierra & Bert Bates
 Head First EJB
 Kathy Sierra & Bert Bates
 J2EE Professional Projects
 Pallavi Jain and Shadab Siddiqui with NIIT
 Teach Yourself SQL
 Ben Forta
WEB SITES:
 http://www.javaworld.com/javaworld/jw-06-1999/jw-06-javamail.html
 http://www.archive.org/details/arsdigita_04_java
 http://www.sun.com
 http://www.java2s.com/