🏦 Banking Application REST API

A comprehensive and secure Banking Application REST API built with Spring Boot 3.4.3, providing complete banking operations including user management, account handling, transactions, and net banking capabilities.

📋 Table of Contents

Features
Tech Stack
Prerequisites
Installation
Configuration
API Endpoints
Testing with Postman
Project Structure
Security
Contributing
License
Contact

✨ Features

🔐 Authentication & Authorization

JWT-based Authentication - Secure token-based authentication system
Spring Security Integration - Role-based access control
Custom User Details Service - Personalized user authentication

👤 User Management

User registration and login
Secure password encryption
User profile management
Admin user search functionality

💳 Account Management

Create and manage bank accounts
Link users to accounts
View account details
Account balance tracking

💰 Transaction Operations

Deposit - Add money to accounts
Withdrawal - Withdraw money from accounts
Net Banking - Transfer money between accounts
Balance Inquiry - Check current account balance
Real-time transaction processing

📖 Passbook Management

View transaction history
Complete passbook details
Account-wise transaction records
Sender and receiver details tracking

🛡️ Security Features

JWT token validation
Custom exception handling
Data validation
SQL injection prevention
Secure API endpoints

📊 Admin Features

Search and manage users
User registration
System-wide user overview

🛠️ Tech Stack

Backend:

Java 17
Spring Boot 3.4.3
Spring Data JPA
Spring Security
Spring Validation

Database:

PostgreSQL

Security:

JWT (JSON Web Tokens) - io.jsonwebtoken 0.12.5
BCrypt Password Encoder

Tools & Libraries:

Lombok - Reduce boilerplate code
MapStruct 1.5.5 - Object mapping
Apache Commons Text 1.10.0
Apache Commons Collections 4.4
Maven - Dependency management

Testing:

Tested extensively with Postman
All endpoints verified and working

📦 Prerequisites

Before running this application, make sure you have:

Java Development Kit (JDK) 17 or higher
PostgreSQL 12 or higher
Maven 3.6+ (or use included Maven wrapper)
Postman (for API testing)
Git (for version control)

🚀 Installation

1. Clone the Repository

git clone https://github.com/Krishal-Modi/Banking-Application-Rest-API.git
cd Banking-Application-Rest-API/BankingApplication

2. Configure Database

Create a PostgreSQL database:

CREATEDATABASEBankingApplication;

Update the database credentials in src/main/resources/application.properties:

spring.datasource.url=jdbc:postgresql://localhost:5432/BankingApplication
spring.datasource.username=your_username
spring.datasource.password=your_password

3. Build the Project

Using Maven wrapper (recommended):

# Windows
mvnw.cmd clean install
# Linux/Mac
./mvnw clean install

Or using Maven:

mvn clean install

4. Run the Application

# Windows
mvnw.cmd spring-boot:run
# Linux/Mac
./mvnw spring-boot:run

The application will start on http://localhost:8086

⚙️ Configuration

Application Properties

Key configurations in application.properties:

# Server Portserver.port=8086
# Database Configurationspring.datasource.url=jdbc:postgresql://localhost:5432/BankingApplication
spring.datasource.username=postgres
spring.datasource.password=root
# JPA Configurationspring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

JWT Configuration

JWT secret key and expiration can be configured in JwtUtil.java

📡 API Endpoints

Authentication Endpoints

User Login

POST /user/loginContent-Type: application/json
{
"email": "user@example.com",
"password": "password123"
}

Response: JWT Token

Admin Endpoints

Register New User

POST /admin/signUpContent-Type: application/json
{
"name": "John Doe",
"email": "john@example.com",
"password": "secure_password",
"phoneNumber": "1234567890",
"roles": "USER"
}

Search Users

GET /admin/search?search=johnAuthorization: Bearer {jwt_token}

Account Endpoints

Create Account

POST /userAccount/addingAccountAuthorization: Bearer {jwt_token}Content-Type: application/json
{
"accountNumber": 1234567890,
"accountType": "SAVINGS",
"balance": 1000.00
}

View Passbook

GET /userAccount/passbookAuthorization: Bearer {jwt_token}

Net Banking (Money Transfer)

PUT /userAccount/netBankingAuthorization: Bearer {jwt_token}Content-Type: application/x-www-form-urlencodedsenderAccountNumber=1234567890receiverAccountNumber=0987654321amount=500

Transaction Endpoints

Deposit Money

PUT /transaction/depositAuthorization: Bearer {jwt_token}Content-Type: application/json
{
"accountNumber": 1234567890,
"amount": 1000.00
}

Withdraw Money

PUT /transaction/withdrawalAuthorization: Bearer {jwt_token}Content-Type: application/json
{
"accountNumber": 1234567890,
"amount": 500.00
}

Check Balance

GET /transaction/currentBalance/{accountNumber}Authorization: Bearer {jwt_token}

🧪 Testing with Postman

This API has been thoroughly tested with Postman to ensure all endpoints work correctly.

Getting Started with Postman

Download Postman from postman.com
Import Collection (Optional - Create your own)
- Create a new collection called "Banking API"
- Add all endpoints mentioned above
Setup Environment Variables
- Create variables:
  - base_url: http://localhost:8086
  - jwt_token: (Will be set after login)
Testing Flow
Step 1: Register a User
```
POST {{base_url}}/admin/signUp
```
Step 2: Login
```
POST {{base_url}}/user/login
```
Copy the JWT token from response
Step 3: Set Authorization
- Add header: Authorization: Bearer {your_jwt_token}
Step 4: Create Account
```
POST {{base_url}}/userAccount/addingAccount
```
Step 5: Test Transactions
- Deposit money
- Withdraw money
- Check balance
- Transfer money (net banking)
Step 6: View Passbook
```
GET {{base_url}}/userAccount/passbook
```

Postman Testing Tips

Use Environment Variables for base URL and tokens
Enable Auto-Refresh Tokens if tokens expire
Save Example Responses for documentation
Use Tests Tab to add assertions
Create Collection Runner for automated testing

Common Postman Test Scripts

// Save JWT token automatically after loginpm.test("Status code is 200",function(){pm.response.to.have.status(200);});varjsonData=pm.response.text();pm.environment.set("jwt_token",jsonData);

📁 Project Structure

BankingApplication/
├── src/
│ ├── main/
│ │ ├── java/com/example/BankingApplication/
│ │ │ ├── BankingApplication.java # Main application class
│ │ │ ├── config/
│ │ │ │ └── SpringSecurity.java # Security configuration
│ │ │ ├── controller/ # REST controllers
│ │ │ │ ├── AccountController.java
│ │ │ │ ├── AdminController.java
│ │ │ │ ├── TransactionalController.java
│ │ │ │ └── UserController.java
│ │ │ ├── entity/ # JPA entities
│ │ │ │ ├── Account.java
│ │ │ │ ├── Passbook.java
│ │ │ │ └── User.java
│ │ │ ├── exceptions/ # Custom exceptions
│ │ │ │ ├── DataNotFoundException.java
│ │ │ │ ├── DataValidationException.java
│ │ │ │ └── handler/
│ │ │ │ └── GlobalExceptionHandler.java
│ │ │ ├── filter/ # Security filters
│ │ │ │ └── JwtFilter.java
│ │ │ ├── mapper/ # MapStruct mappers
│ │ │ │ ├── AccountMapper.java
│ │ │ │ ├── PassbookMapper.java
│ │ │ │ └── UserMapper.java
│ │ │ ├── model/ # DTOs
│ │ │ │ ├── AccountModel.java
│ │ │ │ ├── LoanModel.java
│ │ │ │ ├── NetBankingModel.java
│ │ │ │ ├── PassbookAccountModel.java
│ │ │ │ ├── PassbookModel.java
│ │ │ │ ├── ReceiverModel.java
│ │ │ │ ├── SenderModel.java
│ │ │ │ ├── TransactionalModel.java
│ │ │ │ ├── UserAccountModel.java
│ │ │ │ ├── UserModel.java
│ │ │ │ ├── UserPassbookModel.java
│ │ │ │ └── error/
│ │ │ │ ├── ErrorResponse.java
│ │ │ │ └── ErrorType.java
│ │ │ ├── repository/ # JPA repositories
│ │ │ │ ├── AccountRepository.java
│ │ │ │ ├── PassbookRepository.java
│ │ │ │ └── UserRepository.java
│ │ │ ├── service/ # Business logic
│ │ │ │ ├── AccountService.java
│ │ │ │ ├── AdminService.java
│ │ │ │ ├── CustomUserDetailsService.java
│ │ │ │ ├── TransactionalService.java
│ │ │ │ └── UserService.java
│ │ │ └── utils/ # Utility classes
│ │ │ └── JwtUtil.java
│ │ └── resources/
│ │ └── application.properties # Application configuration
│ └── test/ # Test files
├── mvnw # Maven wrapper (Unix)
├── mvnw.cmd # Maven wrapper (Windows)
└── pom.xml # Maven dependencies

🔒 Security

Authentication Flow

User sends credentials to /user/login
Server validates credentials
JWT token is generated and returned
Client includes token in Authorization header for subsequent requests
Server validates token using JwtFilter

Security Measures

Password Encryption: BCrypt encoding for password storage
JWT Tokens: Stateless authentication
Request Filtering: JWT validation on protected endpoints
Custom Exception Handling: Secure error messages
Input Validation: Bean validation on all inputs
SQL Injection Prevention: JPA/Hibernate parameterized queries

Best Practices Implemented

✅ Token-based authentication
✅ Password hashing
✅ Role-based access control
✅ Global exception handling
✅ Input validation
✅ Secure headers
✅ Database connection pooling

🤝 Contributing

Contributions are welcome! Here's how you can help:

Fork the repository
Create a feature branch
```
git checkout -b feature/AmazingFeature
```
Commit your changes
```
git commit -m 'Add some AmazingFeature'
```
Push to the branch
```
git push origin feature/AmazingFeature
```
Open a Pull Request

Contribution Guidelines

Follow Java coding conventions
Write meaningful commit messages
Add comments for complex logic
Update documentation if needed
Test your changes thoroughly with Postman

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

📧 Contact

Krishal Modi

GitHub: @Krishal-Modi
Project Link: https://github.com/Krishal-Modi/Banking-Application-Rest-API

🙏 Acknowledgments

Spring Boot Documentation
PostgreSQL Community
JWT.io for JWT implementation guidance
Postman for excellent API testing tools
Open source community

📈 Future Enhancements

⭐️ Star this repo if you find it helpful! ⭐️

Made with ❤️ by Krishal Modi

Name		Name	Last commit message	Last commit date
BankingApplication		BankingApplication
LICENSE		LICENSE
README.md		README.md

Latest commit

History

Folders and files

Repository files navigation