Advanced Student Management System

(Java CLI Edition)

Project Overview:

The Student Management System (SMS) is a Java-based command-line application designed to manage records for students, teachers, and courses. Originally created as a foundational CRUD project, it has now been fully enhanced to showcase intermediate-to-advanced Java concepts including:

• JDBC (H2) for persistent storage of students, teachers, and course assignments
• Java File I/O to export and import structured data to/from text files
• Java Streams API for efficient data filtering, sorting, and aggregation
• Multithreading to simulate concurrent processing of large student datasets
• Encapsulated OOP models using inheritance and validation via POJOs
• CLI-based analytics tools to group, count, and analyze students by grade or course
• ID-safe generation and foreign key handling with cascading deletes

Users can interact with a robust menu system to perform operations like adding or updating records, assigning courses, exporting backups, generating class rosters, or analyzing trends — all from a clean terminal interface.

This project serves as a hands-on demonstration of building maintainable, modular, and scalable Java applications using real-world development patterns.

Requirements

• Java 17 or higher
• Maven
• IntelliJ IDEA (recommended)
• H2 Database (embedded)

Installation

1. Clone the repo:

   git clone https://github.com/Tmiseray/M2-Java-Project.git
   cd M2-Java-Project

2. Open the project in IntelliJ.
3. Run Main.java to start the CLI.
4. On first run, schema.sql will automatically create all tables.

Project Structure

/src
 └── main
     ├── java
     │    ├── model              # Core entity classes (Student, Teacher, Course, Person)
     │    ├── dao                # Data Access Objects (CRUD + SQL)
     │    ├── service            # Business logic layers
     │    ├── menu               # MenuHandler with CLI logic
     │    ├── util               # Helpers: backups, analytics, threading, schema loader
     │    └── sql          
     │         └── schema.sql    # SQL schema for H2 DB
     └── Main.java               # Entry point
         

Folder Breakdown

• model/ - Java POJOs [Plain Old Java Object ] with validation (inheritance from Person)
• dao/ - Direct SQL interaction (insert, select, update, delete)
• service/ - Calls DAOs, adds business logic, data validation
• menu/ - CLI interactions and menu input handling
• util/
  • BackupUtil - export/import files
  • StudentAnalytics - streams/filters/sorting
  • StudentThreadProcessor - thread-based processing
  • SchemaLoader - auto-executes schema.sql on startup
• /backups/ - folder for exported .txt student/teacher/course data
• /rosters/ - teacher-specific rosters grouped by course
• /testLogic/ - prompt file (testingPrompts.txt) containing test scenarios used for validation

File Breakdown / Functionality

Main.java

• Loads schema
• Initializes MenuHandler
• Launches CLI loop

MenuHandler.java

• User CLI
• Maps options to services
• Submenu: Analytics & Tools

StudentService.java

• addStudent(Student)
• getStudentById(String)
• getAllStudents()
• updateStudent(Student)
• deleteStudent(String)
• assignCourseToStudent(String, String)

TeacherService.java

• Same structure as StudentService

CourseService.java

• addCourse(Course)
• getCourseById(String)
• getAllCourses()
• updateCourse(Course)
• deleteCourse(String)

BackupUtil.java

• Export to /backups/...
• Import from custom path
• File indexing

StudentAnalytics.java

• filterByGrade(int)
• countByGrade(int)
• sortAlphabetically()
• listStudentsInCourse(String)
• rosterGroupedByCourse(String, boolean)
• exportRosterToFile(String, String, List<Student>)
• printStudent(Student)

StudentThreadProcessor.java

• processConcurrently(List<Student>) — two threads, split list processing

schema.sql

• Creates tables
• Adds cascade deletes for student_courses and teacher_courses

Example Call Structure (Functional Flow)

Main
└── MenuHandler
    ├── addStudent
    │   └── StudentService
    │       └── StudentDAO
    │           └── INSERT into students
    ├── assignCoursesToStudent
    │   └── StudentService
    │       └── StudentCourseDAO
    │           └── MERGE INTO student_courses
    ├── displayAllCourses
    │   └── CourseService
    │       └── CourseDAO
    └── analyticsMenu → (filterByGrade, export, etc.)

Features Recap

• CRUD: Students, Teachers, Courses
• Course Assignment with caps (5 for students, 3 for teachers)
• H2 DB persistence (file-based)
• CLI with structured menus
• Java I/O: Import/Export
• Java Streams: Sorting, Filtering, Counting
• Java Threads: Concurrent display logic
• Smart ID generation
• Cascade-safe schema design

---

💡 Created by: T. Miseray
GitHub • LinkedIn