How swam-6/expensetracker works
What this project is (type + purpose)
This is a classic Java EE-style (Jakarta/Servlet) monolithic web application packaged as a WAR, deployed to Apache Tomcat 10.1, using JSP for views and JDBC (PreparedStatement) to MySQL for persistence. It implements an Expense Tracker with full CRUD, plus grouped/monthly/category summaries, using an explicit MVC split:
• Controller: ExpenseServlet
• Model/Data access: ExpenseDAO, Expense entity, DBUtil
• View: JSPs (expense-list.jsp, expense-form.jsp, index.jsp)
• Runtime container (Tomcat)
• Request routing (web.xml + servlet mapping)
• MVC request lifecycle
• DB connectivity (JDBC)
• Deployment artifact and build pipeline (Maven → WAR)
What the file tree tells you to include (structure → architecture)
From the tree:
Backend (Java)
• com.expense.servlet.ExpenseServlet.java
• com.expense.dao.ExpenseDAO.java
• com.expense.util.DBUtil.java
Own component for connection management (Driver, URL, username/password). Show it as the point where the JDBC driver is used.
• com.expense.model.Expense.java
Entity/DTO passed between servlet ↔ DAO ↔ JSP.
Frontend (JSP)
• index.jsp
Acts as entrypoint/redirect to listing route (per README). Show it as “landing/redirect view.”
• expense-list.jsp
View that renders grouped expenses. Important: it implies the servlet provides grouped/aggregated data (or raw list + JSP grouping).
• expense-form.jsp
View for add/edit.
Web configuration
• WEB-INF/web.xml
Build/packaging
• pom.xml, Maven wrapper
“Build: Maven → WAR artifact”.
• Runtime dependencies (implicit): MySQL JDBC driver via Maven (even if not shown in the tree).
Goal: show who uses it and what external systems exist.
Include these nodes:
• User (actor)
• Browser
• MySQL Database (expense_tracker, table expense)
• Browser ⇄ Web App (HTTP requests/responses)
• Web App ⇄ MySQL (JDBC / SQL)
Goal: show runtime containers and where code runs.
• Client device
• Browser (renders HTML/CSS from JSP output)
• Application server host
• Apache Tomcat 10.1 (Servlet container)
• Deployed artifact: ExpenseTracker.war / “war exploded”
• Database host
• MySQL 8.0 (schema expense_tracker)
Connections:
• Browser → Tomcat: HTTP
• Tomcat → MySQL: TCP + JDBC
• That JSPs are compiled/served by Tomcat (JSP engine) and servlets run in the same container.
• Environment separation if relevant (Dev machine often hosts both Tomcat + MySQL locally).
Goal: show MVC and internal boundaries as *separate components*, not just “Java app”.
Web layer
• index.jsp (entry / redirect)
• expense-list.jsp (list + grouping UI)
• expense-form.jsp (create/edit UI)
• web.xml (URL mapping / servlet config)
Controller
• ExpenseServlet
Domain/model
• Expense (POJO/DTO)
Data access
• ExpenseDAO (CRUD + queries)
• DBUtil (Connection factory / JDBC configuration)
Database
• MySQL table expense(id, title, amount, category, date)
• Browser → index.jsp → (redirect) → ExpenseServlet
• Browser → ExpenseServlet → (forward) → expense-list.jsp / expense-form.jsp
• ExpenseServlet → ExpenseDAO
• ExpenseDAO → DBUtil (get connection)
• ExpenseDAO → MySQL (SQL statements)
• ExpenseServlet → Expense (construct/parse)
• ExpenseServlet → JSP (sets request attributes / model)
Create at least these sequences:
List expenses (GET /expenses)
Browser → Tomcat → ExpenseServlet
ExpenseServlet → ExpenseDAO → MySQL (SELECT)
ExpenseDAO → ExpenseServlet (List<Expense> or grouped data)
ExpenseServlet → expense-list.jsp (forward + attributes)
expense-list.jsp → Browser (HTML)
Add expense (POST /expenses?action=add) (or equivalent)
Browser submits form → ExpenseServlet
ExpenseServlet validates/parses → ExpenseDAO.insert(expense) → MySQL (INSERT)
ExpenseServlet → Browser (redirect to list)
Edit/Delete similarly (UPDATE/DELETE + redirect)
In each sequence, label payloads:
• Request parameters: title, amount, category, date, id
• Response: HTML page or redirect
MVC is real here (not just a buzzword)
• JSPs do not talk to DB directly (they’re views).
• Servlet owns orchestration (routing, deciding which JSP, calling DAO).
• DAO owns SQL (and depends on DBUtil).
• DBUtil owns connection details (driver/url/user/pass).
“Single servlet handles all actions” is an architectural hotspot
Make that explicit:
• ExpenseServlet with internal “Action Router” responsibility:
• list
• showForm(add/edit)
• create
• update
• delete
Grouping and summary computation
• Either DAO returns aggregated/grouped result sets (SQL GROUP BY / ORDER BY)
• Or Servlet groups in-memory (maps by month/category)
• ExpenseDAO (if SQL-driven) or
• ExpenseServlet (if Java-driven)
Labels directly on nodes:
• Java 17
• Servlet API / JSP
• Tomcat 10.1
• JDBC (PreparedStatement)
• MySQL 8.0
• Maven (build → WAR)
• ExpenseTracker:war exploded (IntelliJ deployment) / WAR packaging