A layered banking application demonstrating Java web development, JDBC database access, Servlet request handling, JSP/JSTL, business-layer separation, custom exception handling, Maven build management, and WAR deployment.
- About
- Features
- Architecture
- Project Demonstration
- Technologies Used
- Java and Backend Concepts
- Request Flow
- Project Structure
- Database
- Maven Build and WAR Packaging
- Getting Started
- How to Use
- Error Handling
- Future Enhancements
- Learning Outcomes
- Author
The Advance Java Web Banking Application is a server-side Java web application that simulates common banking operations through a browser-based interface.
The application builds on core Java and JDBC concepts and applies them to a complete web application using:
Java → JDBC → MySQL → Maven → Jakarta Servlets → JSP/JSTL → Layered Architecture → WAR → Apache Tomcat
The application supports:
- 🏦 Opening a bank account
- 💰 Depositing money
- 💸 Withdrawing money
- 🔄 Transferring money between accounts
- 📄 Viewing account statements
- 🔎 Searching accounts
- 📋 Listing accounts
⚠️ Handling business and HTTP errors through dedicated error pages
The main focus of the project is understanding how a Java web application's presentation, request handling, business logic, database access, exception handling, build process, and deployment work together.
Create a new customer account by providing:
- Customer name
- Account type
- Initial deposit
Deposit money into an existing account.
Withdraw money after validating the account and available balance.
Transfer money from one account to another.
The operation validates:
- Sender account
- Receiver account
- Transfer amount
- Sender's available balance
Search an account and view its transaction history.
The application provides operations for:
- Searching for a specific account
- Listing available accounts
The application provides dedicated error pages for important application and business failures.
Examples include:
- Account not found
- Insufficient balance
- Validation errors
- Database errors
- HTTP 404 — Page Not Found
- HTTP 500 — Internal Server Error
The application follows a layered architecture that separates HTTP handling, business logic, database operations, and presentation.
USER / BROWSER
│
│ HTTP Request
▼
┌─────────────────────┐
│ JSP Pages │
│ HTML + JSTL + CSS │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Servlets │
│ Request Handling │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ BankService │
│ Business Logic │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Repository │
│ JDBC / SQL │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ MySQL │
│ Database │
└─────────────────────┘
| Layer | Responsibility |
|---|---|
| JSP | Presentation and user interface |
| Servlet | HTTP request/response handling |
| Service | Banking and business rules |
| Repository | Database operations and SQL |
| Domain | Application data and entities |
| Exceptions | Application-specific failure handling |
| MySQL | Persistent data storage |
This separation keeps the application modular and makes individual layers easier to understand, maintain, and extend.
The repository contains GIF demonstrations of the main application workflows.
| Technology | Purpose |
|---|---|
| Java 25 | Core application development |
| JDBC | Database connectivity |
| MySQL | Persistent data storage |
| Jakarta Servlets | HTTP request and response handling |
| JSP | Server-side presentation |
| JSTL | JSP presentation logic |
| HTML/CSS | Web interface |
| Maven | Dependency and build management |
| Apache Tomcat | Servlet container and deployment |
| Git | Version control |
| GitHub | Repository hosting |
This project demonstrates practical application of several Java and backend development concepts.
- Object-Oriented Programming
- Encapsulation
- Abstraction
- Interfaces
- Enums
- Classes and objects
- Exception handling
- Custom exceptions
- JDBC
- SQL
- PreparedStatement
- ResultSet
- CRUD operations
- Database connectivity
- Layered architecture
- Repository pattern
- Service layer
- Separation of concerns
- DTO usage
- Domain models
- Validation
- HTTP request/response handling
- Servlets
- JSP
- JSTL
web.xml- Error-page configuration
- WAR packaging
- Servlet-container deployment
- Maven dependencies
- Maven lifecycle
- Maven packaging
- Git and GitHub
A typical request travels through the application as follows:
Browser
│
│ HTTP Request
▼
Servlet
│
▼
Service
│
▼
Repository
│
▼
MySQL
│
▼
Repository
│
▼
Service
│
▼
Servlet
│
▼
JSP
│
▼
Browser
Withdraw.jsp
│
▼
WithdrawServlet
│
▼
BankService
│
├── Validate account
├── Validate amount
└── Validate balance
│
▼
AccountRepository
│
▼
MySQL
│
▼
TransactionRepository
│
▼
Success / Error JSP
This request flow demonstrates how a browser request is processed through different backend layers rather than placing all application logic inside a Servlet or JSP.
advancejavabankingapp/
│
├── pom.xml
├── README.md
├── LICENSE
├── .gitignore
│
├── README-assets/
│ ├── banner.png
│ └── gifs/
│ ├── OpenAccount.gif
│ ├── Deposit.gif
│ ├── Withdraw.gif
│ ├── Transfer.gif
│ ├── AccountStatement.gif
│ ├── ListAccountsAndSearchAccount.gif
│ └── AccountNotFoundAndInsufficientAmount.gif
│
└── src/
└── main/
├── java/
│ ├── config/
│ │ └── ApplicationContextListener.java
│ │
│ ├── controller/
│ │ ├── main/
│ │ │ └── Main.java
│ │ ├── AccountDTO.java
│ │ ├── AccountStatementServlet.java
│ │ ├── DepositServlet.java
│ │ ├── ListAccountsServlet.java
│ │ ├── OpenAccountServlet.java
│ │ ├── SearchAccountServlet.java
│ │ ├── TransferServlet.java
│ │ └── WithdrawServlet.java
│ │
│ ├── domain/
│ │ ├── Account.java
│ │ ├── Customer.java
│ │ ├── Transaction.java
│ │ └── Type.java
│ │
│ ├── exceptions/
│ │ ├── AccountNotFoundException.java
│ │ ├── InsufficientBalanceException.java
│ │ └── ValidationException.java
│ │
│ ├── repository/
│ │ ├── AccountRepository.java
│ │ ├── CustomerRepository.java
│ │ └── TransactionRepository.java
│ │
│ ├── services/
│ │ └── impl/
│ │ └── BankService.java
│ │
│ └── util/
│ ├── DBConnection.java
│ └── Validation.java
│
├── resources/
│ └── schema.sql
│
└── webapp/
├── index.jsp
├── OpenAccount.jsp
├── Deposit.jsp
├── Withdraw.jsp
├── Transfer.jsp
├── AccountStatement.jsp
├── ListAccounts.jsp
├── SearchAccount.jsp
├── CloseUpPage.jsp
│
├── error/
│ ├── 404.jsp
│ ├── 500.jsp
│ ├── AccountNotFound.jsp
│ ├── Database.jsp
│ ├── InsufficientBalance.jsp
│ └── Validation.jsp
│
├── css/
│ └── style.css
│
└── WEB-INF/
└── web.xml
The application uses MySQL for persistent storage.
The database schema is provided in:
src/main/resources/schema.sql
- Start the MySQL server.
- Open MySQL Workbench or the MySQL command line.
- Create the database required by the application.
- Execute
schema.sql. - Verify that the required tables have been created.
- Configure the database connection for your local environment.
The database connection is handled by:
src/main/java/util/DBConnection.java
Configure:
Database URL
Username
Password
Use your own local database credentials. Do not commit personal or production database passwords to GitHub.
Customer
│
│ 1
│
│ *
Account
│
│ 1
│
│ *
Transaction
Java Application
│
▼
JDBC Driver
│
▼
MySQL Connection
│
▼
PreparedStatement
│
▼
SQL Query
│
▼
ResultSet / Database Update
Maven is used to manage project dependencies, compilation, and packaging.
The central Maven configuration is:
pom.xml
Because this is a Java web application, it is packaged as a WAR:
<packaging>war</packaging>mvn clean compilemvn clean packageThe generated WAR file is placed inside:
target/
For this project:
target/advancejavabankingapp.war
The WAR can then be deployed to an Apache Tomcat webapps/ directory.
Install the following:
- Java JDK 25 or compatible JDK
- Maven
- MySQL
- Apache Tomcat
- Git
You can use an IDE such as IntelliJ IDEA, Eclipse, or VS Code.
git clone https://github.com/ateeburrahaman3/Advance-Java-Web-Banking-Application.gitNavigate into the project:
cd Advance-Java-Web-Banking-ApplicationStart MySQL and execute:
src/main/resources/schema.sql
Then configure the local database credentials in:
src/main/java/util/DBConnection.java
Use your own username and password.
java -versionThe project is configured for Java 25.
mvn -versionMake sure Maven is using the intended JDK.
Run:
mvn clean packageIf the build succeeds, Maven generates:
target/advancejavabankingapp.war
Copy:
target/advancejavabankingapp.war
into:
<TOMCAT_HOME>/webapps/
Start Apache Tomcat.
Tomcat will deploy the WAR as a web application.
Open:
http://localhost:8080/advancejavabankingapp/
The banking application's web interface should appear.
Once the application is running:
Provide:
- Customer name
- Account type
- Initial deposit
Submit the form to create the customer and account.
Provide:
- Account number
- Amount
The balance is updated and the transaction is recorded.
Provide:
- Account number
- Amount
- Note
The application checks the account and available balance before processing the withdrawal.
Provide:
- Sender account
- Receiver account
- Amount
The application validates both accounts, the amount, and the sender's available balance before processing the transfer.
Provide an account number to view account information and transaction history.
View available accounts stored in the database.
Search for an account using its account number.
The application uses custom exceptions and web.xml error mappings to provide dedicated error pages.
| Error | Handling |
|---|---|
| Account does not exist | AccountNotFoundException |
| Insufficient balance | InsufficientBalanceException |
| Invalid input | ValidationException |
| Database failure | Database/SQL error handling |
| Invalid URL | HTTP 404 |
| Unexpected server failure | HTTP 500 |
Conceptually:
Application / HTTP Error
│
▼
web.xml
│
▼
Dedicated Error JSP
This keeps technical exception details away from the normal user interface and provides clearer feedback when an operation fails.
The current application provides a foundation for moving toward a modern Java backend stack.
Potential next steps include:
- 🌐 Spring Boot REST API
- 🗄️ Spring Data JPA / Hibernate
- 🔐 Spring Security
- 🔑 JWT-based authentication
- 👥 Role-based authorization
- 📄 RESTful API documentation with OpenAPI/Swagger
- 🧪 Automated unit and integration testing
- 📝 Structured application logging
- 📊 Transaction pagination and filtering
- 🐳 Docker containerization
- ☁️ Cloud deployment
- ⚛️ React-based frontend
- 📈 Monitoring and production observability
This project helped strengthen practical understanding of:
- Building a Java web application from the ground up
- Designing layered backend applications
- Handling HTTP requests using Servlets
- Creating dynamic web pages using JSP/JSTL
- Connecting Java applications to MySQL using JDBC
- Writing database operations using repositories
- Separating business rules from database and presentation logic
- Designing and using custom exceptions
- Managing dependencies with Maven
- Packaging Java web applications as WAR files
- Deploying applications using Apache Tomcat
- Using Git and GitHub for version control
Java Backend Development
Java · JDBC · MySQL · Servlets · JSP · JSTL · Maven · Apache Tomcat
Software Engineering
OOP · Layered Architecture · Repository Pattern · Service Layer · Exception Handling · Validation · Separation of Concerns
Development Tools
Git · GitHub · Maven · MySQL Workbench · IDE
Electronics & Communication Engineering Graduate
Aspiring Java Backend Developer
📧 Email: ateeburrahaman3@gmail.com
🔗 LinkedIn: https://www.linkedin.com/in/ateeb-ur-rahaman/
🐙 GitHub: https://github.com/ateeburrahaman3
If you found this project useful or interesting, consider giving the repository a ⭐ on GitHub.