ONLINE BANKING

PROJECT REPORT
Submitted in partial fulfilment of the requirements for the Award of THE degree of

BACHELOR OF TECHNOLOGY IN COMPUTER ENGINEERING (2007-2011)

Project Guide Mrs.Deepti Gupta Gope Asst. Prof. (CE Deptt.) Prof. ( IT Deptt.)

Head Mentor Mr. Prosanta Asst.

DEVELOPED BY:Jatin Behl(07CE019) Vinitesh Gulati(07CE063)

CERTIFICATE
This is to certify that the project entitled Online Banking in J2EE and ORACLE undertaken by:Vinitesh&Jatin student of T.I.T&S (Bhiwani) in partial fulfilment of the requirements for the award of the degree of Bachelor of technology in Computer engineerig, embodies the work done by him under our supervision.

Project Guide: Ms. Deepti Gupta Asstt. Professor (CE Deptt.)

Project Mentor: PROSANTA GOPE Asstt. Professor (CE Deptt.)

ACKNOWLEDGEMENT
I take this opportunity to express my sincere thanks and deep gratitude to all those people who extended their whole hearted co-operation and have helped us in completing this project. With deep sense of gratitude, we express our thanks to my project guide Mr.PROSANTA GOPE his able guidance and valuable suggestion that were very much required for the completion of this project. I express my humble gratitude to Mr.Prosanta Gope for providing us useful guidance and personally inspecting my work. He has been the key factor and motivating force in successful completion of this project. Under his guidance this project never posed a problem to us. We are also thankful to our teachers who supported us in making this project a real success. Our parents who encouraged us at each and every step.

Jatin Behl(07ce019) Vinitesh Gulati(07ce063)

OBJECTIVE OF THE PROJECT

The main objective of this project is to provide easy maintenance of the customer information and their accounts in the banks. It is also used to reduce the work load by reducing the bulk paper work and also by generating automated data based reports for the review of transactions in new or old accounts of respective customers. It reduces the tedious mental task to develop a record of all the information for the customer accounts. The Online Banking System is an important part of any Bank or any type of management. This project has been developed with the objective to develop Online Banking System for any bank with very little effort. It manages the record of all the customers, their personal details, annual income and records of new & old transactions.

CONTENTS

SR.NO 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.

DESCRIPTION Introduction to the project Platform used Software development & life Cycle J2EE(Java 2 Enterprise Edition) JSP,Servlet & EJB Introduction Project Design Modules & their description E-R Diagram Future Scope of the project Conclusion Bibliography

INTRODUCTION TO THE PROJECT

Before we will start with the introduction of our project that is ONLINE BANKING, we must see what its name suggests. With this it must be clear that what sort of information is maintained in our project. So firstly, let us introduce what its name suggests. Basically our project is used to perform online transactions without going to a bank which provides more convenience to its customers. It is helpful in reducing all the paper work performed in the banks. It is an important part of any bank or any management system.

PLATFORM USED
Hardware Required(i) 512 MB RAM. (ii) Pentium 4 or equivalent processor.

Software Required(i) JDK 1.5 or 1.6 (ii) Oracle (Database) (iii) Apache Tomcat web server (iv) Eclipse

Technology Used(i) J2EE (ii) SERVLET, JSP, JDBC, JND, RMI (iii) TOMCAT SERVER or J2EE SERVER

PlatformBackup Media-

Windows 7 or VISTA

Hard Disk.

This software is developed using Windows-XP as system software and is tested to be executed on all the operating systems given above.

SYSTEM DEVELOPMENT LIFE CYCLE

Introduction: Every computer-based system has a life cycle. Just as a living beings follow a life cycle. Commercial programs such as payroll accounts, inventory and other software share a common life cycle pattern. One method of doing things may work well for a period of time. At this point investigations are made, requirements are analyzed, and new specifications are proposed and a new system is developed. The life cycle of the new system thus starts again. System development starts when management or sometimes system development personnel feel that a new system or an improvement in the existing system is required. The systems development life cycle is classically thought of as the set of activities that analysts, designers and users carry to develop and implement an information system. We can also call it software development life cycle as a software is a system is its whole.

Phases of the System Development Life Cycle :System Development Life Cycle (SDLC) is a well-defined process by which a system is conceived, developed and implemented. The system development life cycle consists of the following phases. 1. Preliminary survey or Investigation 2. Feasibility Study 3. System Analysis 4. Design of System 5. Development of Software 6. System Testing 7. Implementation and evaluation 8. Maintenance

So in my project system I have followed almost every step required to be followed while developing the system.

Preliminary Survey:-

One of the most difficult tasks of the system analyst is identifying the real problem of the existing system. Without clear understanding of the problem in the system, any further work done will lead to wastage of effort at a later stage. While doing preliminary survey for my project I found that the present system in used is a manual system. Which was not capable of fulfilling the entire requirement? At the same time manual system is responsible for wastage of time effort and money. So there is a need of computerized Bookshop information system. Feasibility Study: The next step is to examine the feasibility of the proposed system. This involves evaluating the costs and benefits of the system. While feasibility studies I found that my system is feasible in technical, economical and operational point of views.

Technical feasibility:

During this study, the analyst identifies the existing computer systems (hardware and software) of the concerned department and determines whether these technical resources are sufficient for the proposed system or not. I found my system is feasible in this point of view.

Economic Feasibility:

Economic feasibility is the most important study that determines the cost and benefits of the proposed system and compares with the budget. I found that my project is feasible in this point of view.

Operational Feasibility:

During operational feasibility study, it is determined whether the system will operate in the way that user wants or not. This test of feasibility asks if the system will work when it is developed and installed. I found that my project is also feasible in this point of view.

System Analysis:

When the systems analyst decides that the requested system is feasible and the management agrees to continue the development process the next phase of SDLC is determination of systems requirements. During the system analysis we use mainly two methods to collect that information and interview of the concern person. A part from that various tools of structure analysis like flow chart DFD are also used to make a clear understanding of the system.

Design of System:

In the system design phase, the primary objective is to identify user requirements and to build a system that satisfies these requirements, systems specialists often refer to this stage as logical design, in contrast to the process of developing program software, which is referred to as physical design. During design false of my project the first step was identification of data requirement (input requirement, storage devices, output devices etc.) In the next step I develop the database for my project in Microsoft access as back-end in the next step I moves to words form designing coding in Visual studio as front-end .In next step was connection of database with my form using ado connectivity.

Development of Software:

In this phase, the system is actually programmed. The analyst should decide whether to buy commercial software or to develop new customized programs with the help of programmers. Programmers are also responsible for documenting the program, providing an explanation of how and why certain procedure is coded in specific ways.

System Testing:

The main purpose of this phase is to find the errors and correct them. A successful test is one, which finds an error. When my system becomes ready to be implemented next step was system testing. Various type of testing procedure used by me in my project: 1. Unit testing 2.Module testing 3.Sub testing 4.System testing

Implementation and Evaluation :

Implementation consists of installing hardware, software, training of all the users and collecting data needed to use it. Therefore, this phase involves training of the users for using the system and also providing them friendly documentation to refer to. So my system ready to be almost to proposed system.

J2EE (Java 2 enterprise edition)

Introduction to Java Programming
Java is a powerful object-oriented programming language introduced by Sun Microsystems in 1995, which has built-in support to create programs with a graphical user interface (GUI), utilize the Internet, create client-server solutions, and much more. Programs written in Java can run, without change, on any of the common computer operating systems Windows 95/NT, Macintosh, and UNIX. A variant of Java programs called applets can be embedded inside a web page and execute on the computer that is viewing the page, automatically and in a secure environment. As a language, Java is closely related to C++, which is also objectoriented but retains a lot of idiosyncrasies inherited from its predecessor language C. Java has removed the inconsistent elements from C++, is exclusively object-oriented, and can be considered a modern version of C++. Because of its logical structure Java has quickly become a popular choice as a teaching language, and because of its extensive Internet support and the promise of writing programs once and using them on every operating system Java is becoming more and more accepted in industry.

2. What is Java?
Java is a programming language for producing programs which are computer, or platform independent. This simply means that the same program will run on different computers without modification. For example, WordPerfect can currently be used on PCs or Macintoshes; however different versions of the same program are required for each computer type.

Java was also the first programming language to be used to provide executable content on the WWW. In this context executable content generally refers to programs. Small programs known as applets can be written in the Java language. These applets can be loaded as part of a web page to give the page some intelligence (providing the browser supports applets). For example, an applet could be loaded as part of a WWW order form to perform calculations and display a running cost as the purchaser adds items to or removes items from the order form. This simple example demonstrates how Java is bringing new levels of interactivity to the WWW

3. J2EE Web Application Components

Java Servlets Extend off of HttpServlet JSP pages, normally for Presentation Java Beans Normally used as value objects, pass to data to JSPs Tag Libraries XML based JSP elements Web Deployment Descriptor /web-inf/web.xml

Servlet

Java Servlets/JSP are part of the Suns J2EE Enterprise Architecture that is the web development part. Java Servlet is a simple, consistent mechanism for extending the functionality of a web server. They are precompiled Java programs that are executed on the server side and require a Servlet container to run in the program and the latest Servlet Specification is 2.3. We use Servlets because they work well in a Heterogeneous Environments.They are OS and platform independent.Also they work with all major web servers (Sun App,Apache Tomcat,Jboss,etc).They have well defined Web Architecture framework and standard built in services such as: Standard Approach to Authentication Database connection pooling Complete support for sessions via cookies and/or URL re-writing A servlet has clean separation of Controller/Logic from Presentation It is more efficient than others.There are free Servlet/JSP containers and connectors that run under both UNIX and win32.

Web Deployment Descriptor: /web-inf/web.xml Part of the standard Defines servlets used in the web application Maps servlets to URLs A servlet can map to many URLs Defines resources available to the web app Defines security constraints Defines other stuff like Welcome file list Session timeout Error page mapping

Java Server Page (JSP)

It is a simplified, fast way to create dynamic web content. It is mainly HTML or XML pages with embedded Java Code.Java Beans can be a mix of template data in HTML/XML with some dynamic content. A JSP page is first converted into a Java Servlet automatically by the Servlet container, and then it is cached or executed. Latest JSP Specification is 1.2.

JSP Constructs 1: Used in JSP pages, pages that end *.jsp Comment <%-- Comment --%> Declaration <%! int x = 0; %> Expression <%= expression %> Outputs to the Response stream Like a printf to the browser Do NOT use semi-colon to terminate the line Scriplets - contains Java Code <% code fragments %>

JSP Constructs 2:<% if (value.getName().length != 0) { %> <H2>The value is: <%= value.getName() %></H2> <% } else { %> <H2>Value is empty</H2> <% } %>
1.request-Browsers Request Object(use to get HTTP headers,length etc)

Implicit objects always available in the JSP Page

2.response-HttpResponse Object

JSP Constructs 3:-

 session internal HttpSession Object pageContext application out, same as <%= %> config servlet configuration page exception JSP Directives Are messages or instructions to the JSP container

JSP Constructs 4: Do not produce any output page directive <%@ page import=com.lucek.* %> Commonly used for importing class paths include directive <%@ include file=header.htm %> Good for including static content taglib lists the tag library descriptor location Required when using tab libraries

Java Beans as Used in Web Apps

Normally used for all data transfers and business components Similar to how Java Beans are used in Swing and AWT But do not need the full implementation Must have no constructor or no-arg constructor Must have setter and getter methods for each property value JSP constructs/tags use Java Beans

JSP Actions: JSP actions are special tags that affect the output stream and are normally used with Java beans Most commonly used: <jsp:useBean>,<jsp:getProperty>,<jsp:setProperty> The code below will display the lastName property of the student bean on the output stream <jsp:useBean id="student" scope="request" class="com.lucek.dto. StudentValue" /> <jsp:getProperty name="student" property="lastName" />

Servlet Container/Engine:

Servlets/JSP requires a Container Apache Tomcat is the reference implementation of the Servlet/JSP Specs It is open source, small, install quickly,and is FREE Latest Version is 4.1.24 Web Site: jakarta.apache.org/tomcat It includes a simple HTTP 1.1 server, good enough for development and small intranets.

Tomcat Install: Requires a JDK, get 1.4.1 and install into c:\jdk or $HOME/jdk Add JAVA_HOME to your environment and the bin directory to your PATH Good practice to unpack into c:\tomcat or $HOME/tomcat Add CATALINA_HOME to your environment and the bin directory to your PATH

Tomcat Directory Structure:-

 Everything is relative to $CATALINA_HOME /bin Startup/shutdown scripts /conf Server.xml main configuration file /common common class and jar files used by Tomcat and web applications Put JDBC drivers here /server class and jar files used by Tomcat internally /shared class and jar files for all web applications /webapps This is where you put your web application in a subdirectory or external context file.

Starting Tomcat:

/bin/startup.bat or startup.sh

Point Browsers to http://localhost:8080, should see default page All the Docs are there on the default page! Check out the examples pages, good tutorials

Other Development Tools: Java IDE NetBeans Tomcat is built in, but is an older version Includes full Servlet and JSP debugging Junit Standard Automated Unit Testing Tool Jedit Programmers Editor Written in Java

Distributed Multi-tiered Applications

The J2EE platform uses a multi-tiered distributed application model. Application logic is divided into components according to function, and the various application components that make up a J2EE application are installed on different machines depending on the tier in the multitiered J2EE environment to which the application component belongs. Fig1.1 shows two multi-tiered J2EE applications divided into the tiers described in the following list. The J2EE application parts shown in Fig1.1 are presented in J2EE Components. Client-tier components run on the client machine. Web-tier components run on the J2EE server Business-tier components run on the J2EE server. Enterprise information system (EIS)-tier software runs on the EIS server. Although a J2EE application can consist of the three or four tiers shown in Fig1.1, J2EE multi-tiered applications are generally considered to be three-tiered applications because they are distributed over three different locations: client machines, the J2EE server machine, and the database or legacy machines at the back end. Threetiered applications that run in this way extend the standard two-tiered client and server model by placing a multithreaded application server between the client application and back-end storage.

Figure 1.1 Multi-tiered Applications

J2EE Components
J2EE applications are made up of components. A J2EE component is a self-contained functional software unit that is assembled into a J2EE application with its related classes and files and that communicates with other components. The J2EE specification defines the following J2EE components: Application clients and applets are components that run on the client. Java Servlet and JavaServer Pages (JSP) technology components are Web components that run on the server. Enterprise JavaBeans (EJB) components (enterprise beans) are business components that run on the server. J2EE components are written in the Java programming language and are compiled in the same way as any program in the language. The difference between J2EE components and standard Java classes is that J2EE components are assembled into a J2EE application, verified to be well formed and in compliance with the J2EE specification, and deployed to production, where they are run and managed by the J2EE server.

J2EE Clients
A J2EE client can be a Web client or an application client.

Web Clients
A Web client consists of two parts: dynamic Web pages containing various types of markup language (HTML, XML, and so on), which are generated by Web components running in the Web tier, and a Web browser, which renders the pages received from the server. A Web client is sometimes called a thin client. Thin clients usually do not do things like query databases, execute complex business rules, or connect to legacy applications. When you use a thin client, heavyweight operations like these are off-loaded to enterprise beans executing on the J2EE server where they can leverage the security, speed, services, and reliability of J2EE server-side technologies.

Applets

A Web page received from the Web tier can include an embedded applet. An applet is a small client application written in the Java programming language that executes in the Java virtual machine installed in the Web browser. However, client systems will likely need the Java Plug-in and possibly a security policy file in order for the applet to successfully execute in the Web browser. Web components are the preferred API for creating a Web client program because no plug-ins or security policy files are needed on the client systems. Also, Web components enable cleaner and more modular application design because they provide a way to separate applications programming from Web page design. Personnel involved in Web page design thus do not need to understand Java programming language syntax to do their jobs.

Web Components
J2EE Web components can be either servlets or JSP pages. Servlets are Java programming language classes that dynamically process requests and construct responses. JSP pages are text-based documents that execute as servlets but allow a more natural approach to creating static content. Static HTML pages and applets are bundled with Web components during application assembly, but are not considered Web components by the J2EE specification. Server-side utility classes can also be bundled with Web components and, like HTML pages, are not considered Web components. Like the client tier and as shown in Figure 13, the Web tier might include a JavaBeans component to manage the user input and send that input to enterprise beans running in the business tier for processing.

Business Components
Business code, which is logic that solves or meets the needs of a particular business domain such as banking, retail, or finance, is handled by enterprise beans running in the business tier. Figure 1.4 shows how an enterprise bean receives data from client programs, processes it (if necessary), and sends it to the enterprise information system tier for storage. An enterprise bean also retrieves data from storage, processes it (if necessary), and sends it back to the client program.

Figure 1.3- Web Tier and J2EE Application

Figure 1.4 Business and EIS Tiers There are three kinds of enterprise beans: session beans, entity beans, and message-driven beans. A session bean represents a transient conversation with a client.When the client finishes executing, the session bean and its data are gone. In contrast, an entity bean represents persistent data stored in one row of a database table. If the client terminates or if the server shuts down, the underlying services ensure that the entity bean data is saved.A message-driven bean combines features of a session bean and a Java Message Service (JMS) message listener, allowing a business component to receive JMS messages asynchronously. This tutorial describes entity beans and session beans.

J2EE Containers

Normally, thin-client multitiered applications are hard to write because they involve many lines of intricate code to handle transaction and state management, multithreading, resource pooling, and other complex lowlevel details. The componentbased and platform-independent J2EE architecture makes J2EE applications easy to write because business logic is organized into reusable components. In addition, the J2EE server provides underlying services in the form of a container for every component type. Because you do not have to develop these services yourself, you are free to concentrate on solving the business problem at hand.

Container Types
The deployment process installs J2EE application components in the J2EE containers illustrated in Figure 1.5.

Figure 1.5 J2EE Server and Containers

J2EE server
The runtime portion of a J2EE product. A J2EE server provides EJB and Web containers.

Enterprise JavaBeans (EJB) container

Manages the execution of enterprise beans for J2EE applications. Enterprise beans and their container run on the J2EE server.

Web container

Manages the execution of JSP page and servlet components for J2EE applications. Web components and their container run on the J2EE server.

Application client container

Manages the execution of application client components. Application clients and their container run on the client.

Applet container
Manages the execution of applets. Consists of a Web browser and Java Plug-in running on the client together.

Enterprise Bean Developer

An enterprise bean developer performs the following tasks to deliver an EJB JAR file that contains the enterprise bean: Writes and compiles the source code Specifies the deployment descriptor Bundles the .class files and deployment descriptor into an EJB JAR file.

Web Component Developer

A Web component developer performs the following tasks to deliver a WAR file containing the Web component: Writes and compiles servlet source code Writes JSP and HTML files Specifies the deployment descriptor for the Web component Bundles the .class, .jsp, .html, and deployment descriptor files in the WAR file

J2EE Application Client Developer

An application client developer performs the following tasks to deliver a JAR file containing the J2EE application client: Writes and compiles the source code Specifies the deployment descriptor for the client Bundles the .class files and deployment descriptor into the JAR file

Application Assembler
The application assembler is the company or person who receives application component JAR files from component providers and assembles them into a J2EE application EAR file. The assembler or deployer can edit the deployment descriptor directly or use tools that correctly add XML tags according to interactive selections. A software developer performs the following tasks to deliver an EAR file containing the J2EE application: Assembles EJB JAR and WAR files created in the previous phases into a J2EE application (EAR) file Specifies the deployment descriptor for the J2EE application Verifies that the contents of the EAR file are well formed and comply with the J2EE specification

Database Access
The relational database provides persistent storage for application data. A J2EE implementation is not required to support a particular type of database, which means that the database supported by different J2EE products can vary. See the Release Notes included with the J2EE SDK download for a list of the databases currently supported by the reference implementation.

J2EE APIs
The Java 2 Platform, Standard Edition (J2SE) SDK is required to run the J2EE SDK and provides core APIs for writing J2EE components, core development tools, and the Java virtual machine. The J2EE SDK provides the following APIs to be used in J2EE applications.

Enterprise JavaBeans Technology 2.0

An enterprise bean is a body of code with fields and methods to implement modules of business logic. You can think of an enterprise bean as a building block that can be used alone or with other enterprise beans to execute business logic on the J2EE server. There are three kinds of enterprise beans: session beans, entity beans, and message-driven beans. Enterprise beans often interact with databases. One of the benefits of entity beans is that you do not have to write any SQL code or use the JDBC API directly to perform database access operations; the EJB container handles this for you. However, if you override the default container-managed persistence for any reason, you will need to use the JDBC API.

JDBC API 2.0

The JDBC API lets you invoke SQL commands from Java programming language methods. You use the JDBC API in an enterprise bean when you override the default container-managed persistence or have a session bean access the database. With container-managed persistence, database access operations are handled by the container, and your enterprise bean implementation contains no JDBC code or SQL commands. You can also use the JDBC API from a servlet or JSP page to access the database directly without going through an enterprise bean.The JDBC API has two parts: an application-level interface used by the application components to access a database, and a service provider interface to attach a JDBC driver to the J2EE platform.

Java Servlet Technology 2.3

Java Servlet technology lets you define HTTP-specific servlet classes. A servlet class extends the capabilities of servers that host applications accessed by way of a request-response programming model. Although servlets can respond to any type of request, they are commonly used to extend the applications hosted by Web servers.

JavaServer Pages Technology 1.2

JavaServer Pages technology lets you put snippets of servlet code directly into a text-based document. A JSP page is a text-based document that contains two types of text: static template data, which can be expressed in any text-based format such as HTML, WML, and XML, and JSP elements, which determine how the page constructs dynamic content.

Java Message Service 1.0

The JMS is a messaging standard that allows J2EE application components to create, send, receive, and read messages. It enables distributed communication that is loosely coupled, reliable, and asynchronous.

Java Naming and Directory Interface 1.2

The JNDI provides naming and directory functionality. It provides applications with methods for performing standard directory operations, such as associating attributes with objects and searching for objects using their attributes. Using JNDI, a J2EE application can store and retrieve any type of named Java object. Because JNDI is independent of any specific implementations, applications can use JNDI to access multiple naming and directory services, including existing naming and directory services such as LDAP, NDS, DNS, and NIS. This allows J2EE applications to coexist with legacy applications and systems.

Java Authentication and Authorization Service 1.0

The Java Authentication and Authorization Service (JAAS) provides a way for a J2EE application to authenticate and authorize a specific user or group of users to run it. JAAS is a Java programming language version of the standard Pluggable Authentication Module (PAM) framework that extends the Java 2 Platform security architecture to support user-based authorization.

Tools
The J2EE reference implementation provides an application deployment tool and an array of scripts for assembling, verifying, and deploying J2EE applications and managing your development and production environments. See Appendix B for a discussion of the tools.

Application Deployment Tool

The J2EE reference implementation provides an application deployment tool (deploytool) for assembling, verifying, and deploying J2EE applications. There are two versions: command line and GUI. The GUI tool includes wizards for: Packaging, configuring, and deploying J2EE applications Packaging and configuring enterprise beans Packaging and configuring Web components Packaging and configuring application clients Packaging and configuring resource adaptors In addition, configuration information can be set for each component and module type in the tabbed inspector panes.

Scripts
Table 11 lists the scripts included with the J2EE reference implementation that let you perform operations from the command line.

Creating the J2EE Application

The sample application contains three J2EE components: an enterprise bean, a J2EE application client, and a Web component. Before building these components, you will create a new J2EE application called ConverterApp and will store it in an EAR file named ConverterApp.ear. 1. In deploytool, select FileNewApplication. 2. Click Browse. 3. In the file chooser, navigate to j2eetutorial/examples/src/ejb/converter. 4. In the File Name field, enter ConverterApp.ear. 5. Click New Application. 6. Click OK.

Creating the Enterprise Bean

An enterprise bean is a server-side component that contains the business logic of an application. At runtime, the application clients execute the business logic by invoking the enterprise beans methods.

The enterprise bean in our example is a stateless session bean called ConverterEJB. The source code for ConverterEJB is in the j2eetutorial/examples/src/ejb/converter directory.

Coding the Enterprise Bean

The enterprise bean in this example requires the following code: Remote interface Home interface Enterprise bean class

Coding the Remote Interface

A remote interface defines the business methods that a client may call. The business methods are implemented in the enterprise bean code. The source code for the Converter remote interface follows: import javax.ejb.EJBObject; import java.rmi.RemoteException; import java.math.*; public interface Converter extends EJBObject { public BigDecimal dollarToYen(BigDecimal dollars) throws RemoteException; public BigDecimal yenToEuro(BigDecimal yen) throws RemoteException; }

Coding the Home Interface

A home interface defines the methods that allow a client to create, find, or remove an enterprise bean. The ConverterHome interface contains a single create method, which returns an object of the remote interface type. Here is the source code for the ConverterHome interface: import java.io.Serializable; import java.rmi.RemoteException; import javax.ejb.CreateException;

import javax.ejb.EJBHome; public interface ConverterHome extends EJBHome { Converter create() throws RemoteException, CreateException; }

Coding the Enterprise Bean Class

The enterprise bean class for this example is called ConverterBean. This class implements the two business methods, dollarToYen and yenToEuro that the Converter remote interface defines. The source code for the ConverterBean class follows: import java.rmi.RemoteException; import javax.ejb.SessionBean; import javax.ejb.SessionContext; import java.math.*; public class ConverterBean implements SessionBean { BigDecimal yenRate = new BigDecimal("121.6000"); BigDecimal euroRate = new BigDecimal("0.0077"); public BigDecimal dollarToYen(BigDecimal dollars) { BigDecimal result = dollars.multiply(yenRate); return result.setScale(2,BigDecimal.ROUND_UP); } public BigDecimal yenToEuro(BigDecimal yen) { BigDecimal result = yen.multiply(euroRate); return result.setScale(2,BigDecimal.ROUND_UP); } public ConverterBean() {} public void ejbCreate() {} public void ejbRemove() {} public void ejbActivate() {} public void ejbPassivate() {} public void setSessionContext(SessionContext sc) {} }

Compiling the Source Files

Now you are ready to compile the remote interface (Converter.java), home interface (ConverterHome.java), and the enterprise bean class (Converter-Bean.java). 1. In a terminal window, go to the j2eetutorial/examples directory. 2. Type the following command: ant converter This command compiles the source files for the enterprise bean and the J2EE application client. It places the resulting class files in the j2eetutorial/examples/build/ejb/converter directory (not the src directory).

Creating the J2EE Application Client

A J2EE application client is a program written in the Java programming language.At runtime, the client program executes in a different virtual machine than the J2EE server.The J2EE application client in this example requires two different JAR files. The first JAR file is for the J2EE component of the client. This JAR file contains theclients deployment descriptor and its class files. When you run the New Application Client wizard, the deploytool utility automatically creates the JAR file and stores it in the applications EAR file. Defined by the J2EE Specification, the JAR file is portable across all compliant J2EE servers. The second JAR file contains stub classes that are required by the client program at runtime. These stub classes enable the client to access the enterprise beans that are running in the J2EE server. Because this second JAR file is not covered by the J2EE Specification, it is implementation specific, intended only for the J2EE SDK.The ConverterClient.java source code illustrates the basic tasks performed by the client of an enterprise bean: Locating the home interface Creating an enterprise bean instance Invoking a business method

Locating the Home Interface

The ConverterHome interface defines life-cycle methods such as create. Before the ConverterClient can invoke the create method, it must locate and instantiate an object whose type is ConverterHome. This is a four-step process. 1. Create an initial naming context. Context initial = new InitialContext(); The Context interface is part of the Java Naming and Directory Interface (JNDI). A naming context is a set of name-to-object bindings. A name that is bound within a context is the JNDI name of the object. An InitialContext object, which implements the Context interface, provides the starting point for the resolution of names. All naming operations are relative to a context. 2. Obtain the environment naming context of the application client. Context myEnv = (Context)initial.lookup("java:comp/env");The java: comp/env name is bound to the environment naming context of the ConverterClient component. 3. Retrieve the object bound to the name ejb/SimpleConverter. Object objref = myEnv.lookup("ejb/SimpleConverter");The ejb/ SimpleConverter name is bound to an enterprise bean reference, a logical name for the home of an enterprise bean. In this case, the ejb/ SimpleConverter name refers to the ConverterHome object. The names of enterprise beans should reside in the java:com/env/ejb subcontext. 4. Narrow the reference to a ConverterHome object. ConverterHome home =(ConverterHome) PortableRemoteObject.narrow(objref,ConverterHome.class);

Creating an Enterprise Bean Instance

To create the bean instance, the client invokes the create method on the ConverterHome object. The create method returns an object whose type is Converter. The remote Converter interface defines the business methods of the bean that the client may call. When the client invokes the create method, the EJB container instantiates the bean and then invokes the ConverterBean.ejb-Create method. The client invokes the create method as follows: Converter currencyConverter = home.create();

Creating the Web Client

The Web client is contained in the JSP page j2eetutorial/examples/ src/ejb/converter/index.jsp. A JSP page is a text-based document that contains static template data, which can be expressed in any text-based format such as HTML, WML, and XML; and JSP elements, which construct dynamic content.

Coding the Web Client

The statements (in bold in the following code) for locating the home interface, creating an enterprise bean instance, and invoking a business method are nearly identical to those of the J2EE application client. The parameter of the lookup method is the only difference; the motivation for using a different name is discussed in Specifying the JNDI Names .The classes needed by the client are declared with a JSP page directive (enclosed within the <%@ %> characters). Because locating the home interface and creating the enterprise bean are performed only once, this code appears in a JSP declaration (enclosed within the <%! %> characters) that contains the initialization method, jspInit, of the JSP page. The declaration is followed by standard HTML markup for creating a form with an input field. A scriptlet (enclosed within the <% %> characters) retrieves a parameter from the request and converts it to a BigDecimal object. Finally, JSP expressions (enclosed within <%= %> characters) invoke the enterprise beans business methods and insert the result into the stream of data returned to the client.

<%@ page import="Converter,ConverterHome,javax.ejb.*, javax.naming.*, javax.rmi.PortableRemoteObject, java.rmi.RemoteException" %> <%!private Converter converter = null; public void jspInit() { try { InitialContext ic = new InitialContext(); Object objRef = ic.lookup("java:comp/env/ejb/TheConverter"); ConverterHome home = (ConverterHome)PortableRemote Object.narrow(objRef, ConverterHome.class); converter = home.create(); } catch (RemoteException ex) { ... } } ... %> <html> <head> <title>Converter</title> </head> <body bgcolor="white"> <h1><center>Converter</center></h1> <hr> <p>Enter an amount to convert :</p> <form method="get"> <input type="text" name="amount" size="25"> <br> <p> <input type="submit" value="Submit"> <input type="reset" value="Reset"> </form> <%String amount = request.getParameter("amount"); if ( amount != null && amount.length() > 0 ) { BigDecimal d = new BigDecimal (amount); %>

<p><%= amount %> dollars are <%= converter.dollarToYen(d) %> Yen. <p><%= amount %> Yen are <%= converter.yenToEuro(d) %> Euro. <% } %> </body> </html>

Compiling the Web Client

The J2EE server automatically compiles Web clients that are JSP pages. If the Web client were a servlet, you would have to compile it.

Deploying the J2EE Application

Now that the J2EE application contains the components, it is ready for deployment. 1. Select the ConverterApp application. 2. Select ToolsDeploy. 3. In the Introduction dialog box, confirm that ConverterApp is shown for the Object to Deploy and that localhost is shown for the Target Server. 4. Select the checkbox labeled Return Client Jar. 5. In the text field that appears, enter the full path name for the file ConverterAppClient.jar so that it will reside in the j2eetutorial/ examples/src/ejb/converter subdirectory. The ConverterAppClient.jar file contains the stub classes that enable remote access to Converter EJB. 6. Click Next. 7. In the JNDI Names dialog box, verify the names you entered in the previous section. 8. Click Next. 9. In the WAR Context Root dialog box, enter converter in the Context Root field. When you run theWeb client, the converter context root will be part of the URL.

10. Click Next. 11. In the Review dialog box, click Finish. 12. In the Deployment Progress dialog box, click OK when the deployment completes.

Running the J2EE Application Client

To run the J2EE application client, perform the following steps:1. In a terminal window, go to the j2eetutorial /examples/src/ejb/ converter directory. 2. Verify that this directory contains the ConverterApp.ear and ConverterAppClient.jar files. 3. Set the APPCPATH environment variable to ConverterAppClient. jar. 4. Type the following command (on a single line):runclient -client ConverterApp.ear -name ConverterClient-textauth 5. The client container prompts you to log in. Enter guest for the user name and guest123 for the password. 6. In the terminal window, the client displays these lines: Binding name:java:comp/env/ejb/SimpleConverter 12160.000.77 Unbinding name:java:comp/env/ejb/SimpleConverter

Other Enterprise Bean Features

The topics that follow apply to both session and entity beans.

Accessing Environment Entries

Stored in an enterprise beans deployment descriptor, an environment entry is a name-value pair that allows you to customize the beans business logic without changing its source code. An enterprise bean that calculates discounts, for example, might have an environment entry named Discount Percent. Before deploying the beans application, you could run deploytool and assign Discount Percent a value of .05 on the Env.Entries tab. When you run the application, the enterprise bean fetches the .05 value from its environment. In the following code example, the applyDiscount method uses environment entries to calculate a discount based on the purchase amount. First, the method locates the environment naming context by invoking lookup with the java:comp/env parameter. Then it calls lookup on the environment to get the values for the Discount Level and Discount Percent names. For example, if you assign a value of .05 to the Discount Percent name in deploytool, the code will assign .05 to the

discountPercent variable. The applyDiscount method, which follows, is in the CheckerBean class. public double applyDiscount(double amount) { try { double discount; Context initial = new InitialContext(); Context environment =(Context)initial.lookup("java:comp/env"); Double discountLevel =(Double)environment.lookup("Discount Level"); Double discountPercent =(Double)environment.lookup("Discount Percent"); if (amount >= discountLevel.doubleValue()) { discount = discountPercent.doubleValue(); } else { discount = 0.00; } return amount * (1.00 - discount); } catch (NamingException ex) { throw new EJBException("NamingException: "+ex.getMessage()); } }

Entity Bean Class

The sample entity bean class is called SavingsAccountBean. As you look through its code, note that it meets the requirements of any entity bean with bean-managed persistence. First of all, it implements the following: EntityBean interface Zero or more ejbCreate and ejbPostCreate methods Finder methods Business methods Home methods

In addition, an entity bean class with bean-managed persistence has these requirements: The class is defined as public. The class cannot be defined as abstract or final. It contains an empty constructor. It does not implement the finalize method.

The EntityBean Interface

The EntityBean interface extends the EnterpriseBean interface, which extends the Serializable interface. The EntityBean interface declares a number of methods, such as ejbActivate and ejbLoad, which you must implement in your entity bean class. These methods are discussed in later sections.

The ejbCreate Method

When the client invokes a create method, the EJB container invokes the corresponding ejbCreate method. Typically, an ejbCreate method in an entity bean performs the following tasks: Inserts the entity state into the database Initializes the instance variables Returns the primary key The ejbCreate method of SavingsAccountBean inserts the entity state into the database by invoking the private insertRow method, which issues the SQL INSERT statement. Here is the source code for the ejbCreate method: Public String ejbCreate(String id, String firstName,String lastName, BigDecimal balance) throws CreateException { if (balance.signum() == -1) { throw new CreateException ("A negative initial balance is not allowed."); } try {

insertRow(id, firstName, lastName, balance); } catch (Exception ex) { throw new EJBException("ejbCreate: " +ex.getMessage()); } this.id = id; this.firstName = firstName; this.lastName = lastName; this.balance = balance; return id; } Although the SavingsAccountBean class has just one ejbCreate method, an enterprise bean may contain multiple ejbCreate methods. For an example, see the CartEJB.java source code in the j2eetutorial/examples/src/ejb/cart directory. When writing an ejbCreate method for an entity bean, be sure to follow these rules: The access control modifier must be public. The return type must be the primary key. The arguments must be legal types for the Java RMI API. The method modifier cannot be final or static. The throws clause may include the javax.ejb.CreateException and exceptions that are specific to your application. An ejbCreate method usually throws a CreateException if an input parameter is invalid. If an ejbCreate method cannot create an entity because another entity with the same primary key already exists, it should throw a javax.ejb. DuplicateKeyException (a subclass of CreateException). If a client receives a CreateException or a DuplicateKeyException, it should assume that the entity was not created. The state of an entity bean may be directly inserted into the database by an application that is unknown to the J2EE server. For example, a SQL script might insert a row into the savingsaccount table. Although the entity bean for this row was not created by an ejbCreate method, the bean can be located by a client program.

The ejbPostCreate Method

For each ejbCreate method, you must write an ejbPostCreate method in the entity bean class. The EJB container invokes ejbPostCreate immediately after it calls ejbCreate. Unlike the ejbCreate method, the ejbPostCreate method can invoke the getPrimaryKey and getEJB Object methods of the EntityContext interface. For more information on the getEJB Object method, see the section passing an Enterprise Beans Object Reference. Often, your ejbPostCreate methods will be empty. The signature of an ejbPostCreate method must meet the following requirements: The number and types of arguments must match a corresponding ejbCreate method. The access control modifier must be public. The method modifier cannot be final or static. The return type must be void. The throws clause may include the javax.ejb.CreateException and exceptions that are specific to your application.

The ejbRemove Method

A client deletes an entity bean by invoking the remove method. This invocation causes the EJB container to call the ejbRemove method, which deletes the entity state from the database. In the Savings Account Beanclass, the ejbRemove method invokes a private method named deleteRow, which issues a SQL DELETE statement. The ejbRemove method is short: public void ejbRemove() { try { deleteRow(id); catch (Exception ex) { throw new EJBException("ejbRemove: " +ex.getMessage()); } } If the ejbRemove method encounters a system problem, it should throw the javax.ejb.EJBException. If it encounters an application error, it

should throw a javax.ejb.RemoveException. For a comparison of system and application exceptions, see the section Handling Exceptions. An entity bean may also be removed directly by a database deletion. For example, if a SQL script deletes a row that contains an entity bean state, then that entity bean is removed.

The ejbLoad and ejbStore Methods

If the EJB container needs to synchronize the instance variables of an entity bean with the corresponding values stored in a database, it invokes the ejbLoad and ejbStore methods. The ejbLoad method refreshes the instance variables from the database, and the ejbStore method writes the variables to the database. The client may not call ejbLoad and ejbStore. If a business method is associated with a transaction, the container invokes ejb-Load before the business method executes. Immediately after the business method executes, the container calls ejbStore. Because the container invokes ejbLoad and ejbStore, you do not have to refresh and store the instance variables in your business methods. The SavingsAccountBean class relies on the container to synchronize the instance variables with the database. Therefore, the business methods of SavingsAccountBean should be associated with transactions. If the ejbLoad and ejbStore methods cannot locate an entity in the underlying database, they should throw the javax.ejb.NoSuch Entity Exception. This exception is a subclass of EJBException. Because EJBException is a subclass of RuntimeException, you do not have to include it in the throws clause. When NoSuchEntityException is thrown, the EJB container wraps it in a RemoteException before returning it to the client. In the SavingsAccountBean class, ejbLoad invokes the loadRow method, which issues a SQL SELECT statement and assigns the retrieved data to the instance variables. The ejbStore method calls the storeRow method, which stores the instance variables in the database with a SQL UPDATE statement. Here is the codefor the ejbLoad and ejbStore methods:

public void ejbLoad() { try { loadRow(); } catch (Exception ex) { throw new EJBException("ejbLoad: " +ex.getMessage()); } } public void ejbStore() { try { storeRow(); } catch (Exception ex) { throw new EJBException("ejbStore: " +ex.getMessage()); } }

The Finder Methods

The finder methods allow clients to locate entity beans. The SavingsAccount-Client program locates entity beans with three finder methods: SavingsAccount jones = home.findByPrimaryKey("836"); ... Collection c = home.findByLastName("Smith"); ... Collection c = home.findInRange(20.00, 99.00); For every finder method available to a client, the entity bean class must implement a corresponding method that begins with the prefix ejbFind. The SavingsAccountBean class, for example, implements the ejbFindBy LastName method as follows: public Collection ejbFindByLastName(String lastName) throws FinderException { Collection result; try { result = selectByLastName(lastName); } catch (Exception ex) {

throw new EJBException("ejbFindByLastName " +ex.getMessage()); } return result; } The finder methods that are specific to your application, such as ejbFindBy- LastName and ejbFindInRange, are optionalbut the ejbFindByPrimaryKey method is required. As its name implies, the ejbFindByPrimaryKey method accepts as an argument the primary key, which it uses to locate an entity bean. In the SavingsAccount Bean class, the primary key is the id variable. Here is the code for the ejbFindByPrimaryKey method: public String ejbFindByPrimaryKey(String primaryKey) throws FinderException { boolean result; try { result = selectByPrimaryKey(primaryKey); } catch (Exception ex) { throw new EJBException("ejbFindByPrimaryKey: " + ex.getMessage()); } if (result) { return primaryKey; } else { throw new ObjectNotFoundException ("Row for id " + primaryKey + " not found."); } } The ejbFindByPrimaryKey method may look strange to you, because it uses a primary key for both the method argument and return value. However, remember that the client does not call ejbFindByPrimary Key directly. It is the EJB container that calls the ejbFindByPrimary Key method. The client invokes the findByPrimaryKey method, which is defined in the home interface. The following list summarizes the rules for the finder methods that you implement in an entity bean class with bean-managed persistence:

 The ejbFindByPrimaryKey method must be implemented. A finder method name must start with the prefix ejbFind. The access control modifier must be public. The method modifier cannot be final or static. The arguments and return type must be legal types for the Java RMI API.(This requirement applies only to methods defined in a remote not localhome interface.) The return type must be the primary key or a collection of primary keys. The throws clause may include the javax.ejb.FinderException and exceptions that are specific to your application. If a finder method returns a single primary key and the requested entity does not exist, the method should throw the javax.ejb.ObjectNotFoundException (a subclass of FinderException). If a finder method returns a collection of primary keys and it does not find any objects, it should return an empty collection.

The Business Methods

The business methods contain the business logic that you want to encapsulate within the entity bean. Usually, the business methods do not access the database, allowing you to separate the business logic from the database access code. The SavingsAccountBean class contains the following business methods: public void debit(BigDecimal amount) throws InsufficientBalanceException { if (balance.compareTo(amount) == -1) { throw new InsufficientBalanceException(); } balance = balance.subtract(amount); } public void credit(BigDecimal amount) { balance = balance.add(amount); } public String getFirstName() { return firstName; }

public String getLastName() { return lastName; } public BigDecimal getBalance() { return balance; } The SavingsAccountClient program invokes the business methods as follows: BigDecimal zeroAmount = new BigDecimal("0.00"); SavingsAccount duke = home.create("123", "Duke", "Earl",Zero Amount); ... duke.credit(new BigDecimal("88.50")); duke.debit(new BigDecimal("20.25")); BigDecimal balance = duke.getBalance(); The requirements for the signature of a business method are the same for both session and entity beans: The method name must not conflict with a method name defined by the EJB architecture. For example, you cannot call a business method ejb-Create or ejbActivate. The access control modifier must be public. The method modifier cannot be final or static. The arguments and return types must be legal types for the Java RMI API. This requirement applies only to methods defined in a remotenot localhome interface.The throws clause may include the exceptions that you define for your application.The debit method, for example, throws the Insufficient Balance Exception. To indicate a system-level problem, a business method should throw the javax.ejb.EJBException.

The Home Methods

A home method contains the business logic that applies to all entity beans of a particular class. In contrast, the logic in a business method

applies to a single entity bean, an instance with a unique identity. During a home method invocation, the instance has neither a unique identity nor a state that represents a business object. Consequently, a home method must not access the beans persistence state (instance variables). (For container-managed persistence, a home method also must not access relationships.) Typically, a home method locates a collection of bean instances and invokes business methods as it iterates through the collection. This approach is taken by the ejbHomeChargeForLowBalance method of the SavingsAccountBean class. The ejbHomeChargeForLowBalance method applies a service charge to all savings accounts with balances less than a specified amount. The method locates these accounts by invoking the findInRange method. As it iterates through the collection of SavingsAccount instances, the ejbHomeChargeForLowBalance method checks the balance and invokes the debit business method. Here is the source code of the ejbHomeChargeForLowBalance method: public void ejbHomeChargeForLowBalance( BigDecimal minimumBalance, BigDecimal charge) throws InsufficientBalanceException { try { SavingsAccountHome home = (SavingsAccountHome)context.get EJBHome(); Collection c = home.findInRange(new BigDecimal("0.00"), minimumBalance.subtract(new BigDecimal("0.01"))); Iterator i = c.iterator(); while (i.hasNext()) { SavingsAccount account = (SavingsAccount)i.next(); if (account.getBalance().compareTo(charge) == 1) { account.debit(charge); } } } catch (Exception ex) { throw new EJBException("ejbHomeChargeForLowBalance: " + ex.getMessage()); } }

The home interface defines a corresponding method named chargeForLowBalance. Since the interface provides the client view, the SavingsAccountClient program invokes the home method as follows: SavingsAccountHome home; ... home.chargeForLowBalance(new BigDecimal("10.00"), new BigDecimal("1.00"));In the entity bean class, the implementation of a home method must adhere to these rules: A home method name must start with the prefix ejbHome. The access control modifier must be public. The method modifier cannot be static. The throws clause may include exceptions that are specific to your application; it must not throw the java.rmi.RemoteException.

Home Interface
The home interface defines the methods that allow a client to create and find an entity bean. The SavingsAccountHome interface follows: import java.util.Collection; import java.math.BigDecimal; import java.rmi.RemoteException; import javax.ejb.*; public interface SavingsAccountHome extends EJBHome { public SavingsAccount create(String id, String firstName, String lastName, BigDecimal balance) throws RemoteException, CreateException; public SavingsAccount findByPrimaryKey(String id) throws FinderException, RemoteException; public Collection findByLastName(String lastName)

Remote Interface

The remote interface extends javax.ejb.EJBObject and defines the business methods that a remote client may invoke. Here is the SavingsAccount remote interface: import javax.ejb.EJBObject; import java.rmi.RemoteException; import java.math.BigDecimal; public interface SavingsAccount extends EJBObject { public void debit(BigDecimal amount) throws InsufficientBalanceException, RemoteException; public void credit(BigDecimal amount) throws RemoteException; public String getFirstName() throws RemoteException; public String getLastName() throws RemoteException; public BigDecimal getBalance() throws RemoteException; }

Handling Exceptions
The exceptions thrown by enterprise beans fall into two categories: system and application. A system exception indicates a problem with the services that support an application. Examples of these problems include the following: a database connection cannot be obtained; a SQL insert fails because the database is full, or a lookup method cannot find the desired object. If your enterprise bean encounters a system- level problem, it should throw a javax.ejb.EJBException. The container will wrap the EJBException in a RemoteException, which it passes back to the client. Because the EJBException is a subclass of the RuntimeException, you do not have to specify it in the throws clause of the method declaration. If a system exception is thrown, the EJB container might destroy the bean instance. Therefore, a system exception cannot be handled by the beans client program; it requires intervention by a system administrator. An application exception signals an error in the business logic of an enterprise bean. There are two types of application exceptions: customized and predefined. A

customized exception is one that youve coded yourself, such as the InsufficentBalanceException thrown by the debit business method of the SavingsAccountEJB example. The javax.ejb package includes several predefined exceptions that are designed to handle common problems. For example, an ejb-Create method should throw a CreateException to indicate an invalid input parameter. When an enterprise bean throws an application exception, the container does not wrap it in another exception. The client should be able to handle any application exception it receives. If a system exception occurs within a transaction, the EJB container rolls back the transaction. However, if an application exception is thrown within a transaction, the container does not roll back the transaction.

Method Name Exception It Throws Reason for Throwing

-ejbCreate -CreateException An input parameter is invalid. - ejbFindByPrimaryKey(and other finder methods that return a single object)ObjectNotFoundException (subclass of FinderException) The database row for the requested entity bean cannot be found. -ejbRemove-RemoveExceptionThe entity beans row cannot be deleted from the database. -ejbLoad-NoSuchEntityException.The database row to be loaded cannot be found. -ejbStore-NoSuchEntityException.The database row to be updated cannot be found. (All methods) EJBException A system problem has been encountered.

Entity Bean Class

For container-managed persistence, the code of the entity bean class must meet the syntax requirements. First, the class must be defined as public and abstract. Also, the class must implement the following: The EntityBean interface Zero or more ejbCreate and ejbPostCreate methods The get and set access methods, defined as abstract, for the persistent and relationship fields

 Any select methods, defining them as abstract The home methods The business methods The entity bean class must not implement these methods: The finder methods The finalize method

Differences between Container-Managed and BeanManaged Code

Because it contains no calls to access the database, an entity bean with container managed persistence requires a lot less code than one with bean-managed persistence.

Difference between Container-Managed & BeanManaged

Class definition Abstract Not abstract Database access calls Generated by tools Coded by developers Persistent state Represented by virtual persistent fields Coded as instance variables Note that for both types of persistence, the rules for implementing business and home methods are the same.

A Message-Driven Bean Example

Since message-driven beans are based on the Java Message Service (JMS) technology, to understand the example in this chapter you should already be familiar with basic JMS concepts such as queues and messages. This chapter describes the source code of a simple message-driven bean example. Before proceeding, you should read the basic conceptual information in the section What Is a Message-Driven Bean?

The Message-Driven Bean Class

The code for the SimpleMessageEJB class illustrates the requirements of a message-driven bean class: It implements the MessageDrivenBean and MessageListener interfaces. The class is defined as public. The class cannot be defined as abstract or final. It implements one onMessage method. It implements one ejbCreate method and one ejbRemove method. It contains a public constructor with no arguments. It must not define the finalize method. Unlike session and entity beans, message-driven beans do not have the remote orlocal interfaces that define client access. Client components do not locate message-driven beans and invoke methods on them. Although message-driven beansdo not have business methods, they may contain helper methods that are invoked internally by the onMessage method.

The onMessage Method

When the queue receives a message, the EJB container invokes the onMessagemethod of the message-driven bean. In the SimpleMessage Bean class, theonMessage method casts the incoming message to a TextMessage and displaysthe text: public void onMessage(Message inMessage) { TextMessage msg = null; try { if (inMessage instanceof TextMessage) {

msg = (TextMessage) inMessage; System.out.println ("MESSAGE BEAN: Message received: "+ msg.getText()); } else { System.out.println ("Message of wrong type: "+ inMessage.getClass().getName()); } } catch (JMSException e) { e.printStackTrace(); mdc.setRollbackOnly(); } catch (Throwable te) { te.printStackTrace(); } }

The ejbCreate and ejbRemove Methods

The signatures of these methods have the following requirements: The access control modifier must be public. The return type must be void. The modifier cannot be static or final. The throws clause must not define any application exceptions. The method has no arguments. In the SimpleMessageBean class, the ejbCreate and ejbRemove methods are empty.

Running the SimpleMessageEJB Example

Starting the J2EE Server
To view the output of the message-driven bean, you must start the server in verbose mode: j2ee verbose

Creating the Queue

1. Create the queue with the j2eeadmin command: j2eeadmin -addJmsDestination jms/MyQueue queue

2. Verify that the queue was created: j2eeadmin -listJmsDestination

Deploying the Application

1. In deploytool, open the j2eetutorial/examples/ears/Simple MessageApp.ear file (FileOpen). 2. Deploy the SimpleMessageApp application (ToolsDeploy). In the Introduction dialog box, make sure that you select the Return Client JAR checkbox.

Running the Client

1. In a terminal window, go to the j2eetutorial/examples/ears directory. 2. Set the APPCPATH environment variable to SimpleMessage AppClient.jar. 3. Type the following command on a single line: runclient -client SimpleMessageApp.ear -nameSimpleMessage Client -textauth 4. At the login prompts, enter j2ee for the user name and j2ee for the password. 5. The client displays these lines: Sending message: This is message 1 Sending message: This is message 2 Sending message: This is message 3 6. In the terminal window in which youve started the J2EE server (in verbose mode), the following lines should be displayed: MESSAGE BEAN: Message received: This is message 1 MESSAGE BEAN: Message received: This is message 2 MESSAGE BEAN: Message received: This is message 3

Project design

Basic

Flow of System
Gives log deta in ils Gives log details in

EMPLOYEE
Get custom details er S rches the DB ea Delete & m odify Accounts

CUSTOMER

n Gives Reg Details

ONLINE BANKING

Get Account deta ils Gives tra ction details nsa

MODULES & THEIR DESCRIPTION

Customer login:
In this page customers User-id and Password is checked and only the authorized customers are allowed to

access it. This is a security feature to avoid entry of unauthorized users.

Employee login:
It includes logins for those employees who work there inside the bank. It is only for NFB(National Film Board) employees. This page is made in JSP.

Home Page:
This page is displayed when a new customer first logins into his/her account. It contains links for other operations such as transaction, searching etc.

Sign-Up Form:
This page is used for giving registration details by the new customer to the site who has opened his account recently in the respective bank. In this a customer has to give his/her personal details like full name, annual income, phone number and also have to submit them for future use.

Transaction Form:
This page helps us to store the current and previous transactions done in his/her account and the medium of transaction.

View statement:
This form is used by the bank employees for searching the account details of the customers in their databases. The searching for account details can be done in two ways: By account id

Administrator Page:
This page is used for deleting all the information of a respective customer who has closed his account from the bank by using his/her account-id.

Update Page:

This page is used for updating or modifying any information regarding personal or account details of a customer by using his/her registration-id.

E-R Diagram
DATA TYPE NOTNU LL

USER_NA ME

PASSWO RD

PRIMA RY

COL_NA ME

SIZ E

USER

US ES

SEL_COL_G EN

TABLES
The table SEL_COL_GEN contains the following information: Sr.No Name of the variable
1. 2. 3. 4. 5. DATA TYPE NOTNULL PRIMARY SIZE COL_NAME

Constraint

Information
Stores the type of data selected by the user. If NOTNULL is checked by the user or not. If primary is checked by the user or not. Size provided by the user. Name of the column

The table USER stores the following information:Sr.No Name of the variable Constraint Information 1. USER_NAME Users name 2. PASSWORD Password to his account.

FUTURE SCOPE OF THIS PROJECT

In future this will prove out to be very helpful for the customers who have to go very far away in banks for depositing their money and for cash withdraws. It provides:-

 Better retrieval of records. Customer Record Maintenance. Multiple criteria based reporting. Transaction Entry Balance update and retrieval. Unit Master Entry and Item Master entry. Taking security into consideration, the customer account had to be password protected. I had two options, an encrypted password hidden in the registry or a file stored on disk (most secure but slower) or using a password hidden in the tag property in a control (less secure but faster and easier to code).I chose the latter as the former would be unnecessary, bulky in coding and it would take far too long to develop an effective algorithm for ciphering and deciphering.

CONCLUSION
The conclusion of this report is that after reading you will be able to make and run web application programs in Java and create other real world applications by paying much more attention to Java programming. One can also understand and

familiar with various J2EE technology which includes Servlets, JSP, EJB (Enterprise Java Beans) etc. Java can be used as the front-end for preparing any project. These java applications are needed to employ full functionality of the project. The reporting is done through various parameters passed from the form. In this application there is transaction entry and customer record system. This application is useful for person who needs money transaction in day to day working. Now he will find it easier because this is a combine application with all required utilities. Error handling has been done in this project.

Bibliography
NIIT Study material Sun Microsystems-Student Guide The Complete Reference(J2EE)

www.Google.com Fundamentals of Java programming-By Balaguruswami