A production-ready Spring Boot REST API for personal finance management with JWT authentication, expense/income tracking, real-time analytics, and comprehensive CRUD operations. Built with Spring Security, MySQL, and modern best practices.

• Features
• Tech Stack
• Project Structure
• Prerequisites
• Installation
• Configuration
• API Documentation
• Database Schema
• Security
• Contributing
• License

• 🔐 JWT-based authentication
• 🔑 Secure password encryption
• 👤 User registration and login
• 🔄 Token refresh mechanism
• 📧 Email notifications
• 🔒 Role-based access control

• ➕ Create, read, update, and delete expenses
• 🏷️ Categorize expenses
• 📊 Track spending patterns
• 🔍 Filter and search expenses
• 📅 Date-based expense tracking

• 💵 Record income transactions
• 📈 Track income sources
• 📊 Income analytics

• 📊 Financial statistics
• 📉 Spending trends
• 💹 Income vs Expense comparison
• 📅 Monthly/Yearly reports

• 👤 User profile management
• ⚙️ Account settings
• 📧 Email preferences

• Spring Boot 3.x - Application framework
• Spring Security - Authentication & Authorization
• Spring Data JPA - Data persistence
• Hibernate - ORM framework

• MySQL 8.0 - Primary database
• HikariCP - Connection pooling

• JWT (JSON Web Tokens) - Stateless authentication
• BCrypt - Password hashing

• Maven - Dependency management

• Lombok - Reduce boilerplate code
• ModelMapper - Object mapping
• Jakarta Validation - Input validation

ExpenseTracker/
├── src/
│   ├── main/
│   │   ├── java/com/example/ExpenseTracker/
│   │   │   ├── Controller/
│   │   │   │   ├── AuthController.java
│   │   │   │   ├── ExpenseController.java
│   │   │   │   ├── IncomeController.java
│   │   │   │   ├── ProfileController.java
│   │   │   │   └── StatsController.java
│   │   │   │
│   │   │   ├── DTO/
│   │   │   │   ├── ExpenseDTO.java
│   │   │   │   ├── GraphDTO.java
│   │   │   │   ├── IncomeDTO.java
│   │   │   │   └── StatsDTO.java
│   │   │   │
│   │   │   ├── Entity/
│   │   │   │   ├── Expense.java
│   │   │   │   ├── Income.java
│   │   │   │   └── UserEntity.java
│   │   │   │
│   │   │   ├── Filter/
│   │   │   │   └── JwtRequestFilter.java
│   │   │   │
│   │   │   ├── IO/
│   │   │   │   ├── AuthRequest.java
│   │   │   │   ├── AuthResponse.java
│   │   │   │   ├── ProfileRequest.java
│   │   │   │   ├── ProfileResponse.java
│   │   │   │   └── ResetPasswordRequest.java
│   │   │   │
│   │   │   ├── Repository/
│   │   │   │   ├── ExpenseRepository.java
│   │   │   │   ├── IncomeRepository.java
│   │   │   │   └── UserRepository.java
│   │   │   │
│   │   │   ├── Service/
│   │   │   │   ├── Stats/
│   │   │   │   │   ├── StatsService.java
│   │   │   │   │   └── StatsServiceImpl.java
│   │   │   │   ├── AppUserDetailsService.java
│   │   │   │   ├── EmailService.java
│   │   │   │   ├── ExpenseService.java
│   │   │   │   ├── ExpenseServiceImpl.java
│   │   │   │   ├── IncomeService.java
│   │   │   │   ├── IncomeServiceImpl.java
│   │   │   │   ├── ProfileService.java
│   │   │   │   └── ProfileServiceImpl.java
│   │   │   │
│   │   │   ├── SpringConfig/
│   │   │   │   ├── CustomAuthenticationEntryPoint.java
│   │   │   │   └── SecurityConfig.java
│   │   │   │
│   │   │   └── Util/
│   │   │       └── JwtUtil.java
│   │   │
│   │   └── resources/
│   │       ├── application.properties
│   │       ├── application-dev.properties
│   │       ├── application-prod.properties
│   │       ├── static/
│   │       └── templates/
│   │
│   └── test/
│       └── java/com/example/ExpenseTracker/
│
├── .gitignore
├── pom.xml
└── README.md

Before running this application, ensure you have the following installed:

• Java 17+ - Download
• Maven 3.6+ - Download
• MySQL 8.0+ - Download
• Git - Download

git clone https://github.com/yourusername/expense-tracker-backend.git
cd expense-tracker-backend

CREATE DATABASE expense_tracker;

Update src/main/resources/application.properties:

# Application Name
spring.application.name=ExpenseTracker

# Database Configuration
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/expense_tracker?useSSL=false&serverTimezone=Asia/Kolkata&allowPublicKeyRetrieval=true
spring.datasource.username=root
spring.datasource.password=YOUR_PASSWORD

# JPA/Hibernate Configuration
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
spring.jpa.properties.hibernate.format_sql=true

# JWT Configuration
jwt.secret.key=YOUR_SECRET_KEY_HERE

mvn clean install

mvn spring-boot:run

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

spring.datasource.url=jdbc:mysql://localhost:3306/expense_tracker
spring.jpa.show-sql=true

spring.datasource.url=jdbc:mysql://your-production-db:3306/expense_tracker
spring.jpa.show-sql=false

Generate a secure secret key:

openssl rand -base64 64

Add to your properties file:

jwt.secret.key=<your-generated-key>

http://localhost:8080

POST /api/auth/register
Content-Type: application/json

{
  "username": "john_doe",
  "email": "[email protected]",
  "password": "SecurePass123!"
}

POST /api/auth/login
Content-Type: application/json

{
  "email": "[email protected]",
  "password": "SecurePass123!"
}

Response:

{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  "userId": 1,
  "email": "[email protected]",
  "username": "john_doe"
}

All expense endpoints require JWT authentication:

Authorization: Bearer <your-jwt-token>

POST /api/expenses
Content-Type: application/json

{
  "title": "Grocery Shopping",
  "amount": 1500.00,
  "date": "2024-10-23",
  "category": "Food",
  "description": "Weekly groceries"
}

GET /api/expenses?page=0&size=10

GET /api/expenses/{id}

PUT /api/expenses/{id}
Content-Type: application/json

{
  "title": "Updated Grocery Shopping",
  "amount": 1600.00,
  "date": "2024-10-23",
  "category": "Food",
  "description": "Weekly groceries - updated"
}

DELETE /api/expenses/{id}

POST /api/income
Content-Type: application/json

{
  "title": "Monthly Salary",
  "amount": 50000.00,
  "date": "2024-10-01",
  "category": "Salary",
  "description": "October salary"
}

GET /api/income?page=0&size=10

PUT /api/income/{id}
Content-Type: application/json

DELETE /api/income/{id}

GET /api/stats/dashboard

Response:

{
  "totalIncome": 50000.00,
  "totalExpense": 25000.00,
  "balance": 25000.00,
  "latestIncomes": [...],
  "latestExpenses": [...],
  "minExpense": 100.00,
  "maxExpense": 5000.00
}

GET /api/stats/chart

GET /api/profile

PUT /api/profile
Content-Type: application/json

{
  "username": "john_doe_updated",
  "email": "[email protected]"
}

POST /api/profile/reset-password
Content-Type: application/json

{
  "oldPassword": "OldPass123!",
  "newPassword": "NewPass123!"
}

CREATE TABLE user_entity (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(255) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    password VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

CREATE TABLE expense (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    title VARCHAR(255) NOT NULL,
    amount DECIMAL(19,2) NOT NULL,
    date DATE NOT NULL,
    category VARCHAR(100),
    description TEXT,
    user_id BIGINT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES user_entity(id)
);

CREATE TABLE income (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    title VARCHAR(255) NOT NULL,
    amount DECIMAL(19,2) NOT NULL,
    date DATE NOT NULL,
    category VARCHAR(100),
    description TEXT,
    user_id BIGINT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES user_entity(id)
);

1. User registers/logs in with credentials
2. Server validates credentials
3. Server generates JWT token
4. Client stores token (localStorage/sessionStorage)
5. Client includes token in Authorization header for subsequent requests
6. Server validates token and processes request

• Passwords are hashed using BCrypt algorithm
• Minimum password requirements enforced
• Secure password reset mechanism

Configure allowed origins in SecurityConfig.java:

@Bean
public CorsConfigurationSource corsConfigurationSource() {
    CorsConfiguration configuration = new CorsConfiguration();
    configuration.setAllowedOrigins(Arrays.asList("http://localhost:3000"));
    configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE"));
    configuration.setAllowedHeaders(Arrays.asList("*"));
    configuration.setAllowCredentials(true);
    
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", configuration);
    return source;
}

mvn test

mvn clean test jacoco:report

The API uses standard HTTP status codes:

{
  "timestamp": "2024-10-23T10:15:30",
  "status": 400,
  "error": "Bad Request",
  "message": "Invalid input data",
  "path": "/api/expenses"
}

• Connection Pooling: HikariCP for efficient database connections
• Pagination: Implemented for large datasets
• Caching: Strategic caching for frequently accessed data
• Lazy Loading: Hibernate lazy loading for optimal performance

Create a Dockerfile:

FROM openjdk:17-jdk-slim
WORKDIR /app
COPY target/expense-tracker-0.0.1-SNAPSHOT.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

Build and run:

docker build -t expense-tracker-backend .
docker run -p 8080:8080 expense-tracker-backend

The application is ready to deploy on:

• AWS EC2
• Heroku
• Google Cloud Platform
• Azure

Contributions are welcome! Please follow these steps:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

• Follow Java naming conventions
• Write meaningful commit messages
• Add comments for complex logic
• Write unit tests for new features

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

Your Name

• GitHub: @yourusername
• LinkedIn: Your LinkedIn
• Email: [email protected]

• Spring Boot Community
• JWT.io for authentication guidance
• MySQL Documentation
• Stack Overflow Community

For support, email [email protected] or open an issue in the repository.