How zxlawdx/nextfit works
Project type and purpose
• NextFit is a hybrid desktop + microservice application:
– Desktop client: JavaFX-based UI (src/main/java & FXML/CSS in src/main/resources).
– Back-end microservice: Python FastAPI (main.py + requirements.txt).
– Local persistence: SQLite database (src/main/database/database_system.db).
– Container orchestration: Dockerfiles (nextfit.dockerfile, integration.dockerfile) and docker-compose.yml.
File structure
• Top-level directories:
– src/main/java/dbsystem & src/main/java/system → Java packages for persistence and UI/controllers/business logic.
– src/main/resources/system/layouts & css → JavaFX view definitions.
– src/main/database → SQLite files and DB schema.
– src/main/appplayer (optional Python modules).
– main.py + requirements.txt → Python FastAPI entrypoint and dependencies.
– Dockerfiles & docker-compose.yml → container build and service orchestration.
• Build scripts:
– build.gradle, settings.gradle, gradlew scripts → Java build.
– requirements.txt → Python dependencies.
Key insights from README
• Core features: AI interaction, meal management, user auth, data viz.
• Technology stack: JavaFX, SQLite, FastAPI, Docker.
• Two containers: a JavaFX client image & a Python API service.
Main components & relationships
a. JavaFX Client
– Layers:
• Presentation: FXML + controllers (DashboardController, Chat, etc.).
• Business logic: system.Session, ScreenManager, LocalAIClient.
• Persistence: dbsystem.DatabaseConnector + DAOs.
– Interaction:
• JDBC → SQLite (database_system.db).
• HTTP/REST → FastAPI microservice for AI inference.
b. Python FastAPI Service
– main.py defines API endpoints (e.g., /recommend, /chat).
– Loads AI model (via Ollama or local engine).
– Returns JSON responses to Java client.
c. Database
– SQLite file stored under src/main/database.
– Accessed directly by Java via JDBC.
d. AI Model
– Hosted in the Python container (or external Ollama process).
– Communicated over HTTP.
e. Containerization & Orchestration
– nextfit.dockerfile → builds JavaFX image.
– integration.dockerfile → builds Python API image.
– docker-compose.yml → brings up both services.
Architectural patterns & principles
• Desktop MVC: FXML views + JavaFX controllers → separation of concerns.
• Layered architecture: UI → service layer → data access layer → database.
• Microservice: Python FastAPI as separate service for AI logic.
• Containerization: isolates Java and Python runtimes, simplifies deployment.
Essential elements checklist
– Clear, distinct labels for each component.
• Desktop UI
• Business/Service layer
• Database
• AI microservice
• External AI engine
– Docker Compose boundary.