ADVANCED JAVA PROJECT

Submitted By

Devansh Sharma & [Link]

Enrolment No-
03714813123 & 05014813123

in partial fulfilment of Advanced Java Project for the award of the

degree
of

BACHELOR OF TECHNOLOGY

IN

INFORMATION TECHNOLOGY AND ENGINEERING

1
Student Information System with Modern Web Portal and Desktop Admin
Application

TABLE OF CONTENTS

Page
[Link]. Chapter
Number
1. Introduction and Background 3
2. Project Overview and Objectives 4
3. System Analysis and Design 5
4. Technology Stack and Implementation 6
5. Testing and Results 13
6. Challenges and Learning Outcomes 15
7. Conclusion and Future Scope 16
References 18

2
Introduction and Background

In the era of digital transformation, academic institutions are increasingly turning

to technology-driven solutions to manage student data, administrative tasks, and
learning outcomes. Traditional manual systems for maintaining student records
are not only time-consuming but also prone to errors and inefficiencies.

A Student Information System (SIS) is a software application designed to help

educational institutions manage all aspects of student-related data, including
personal information, academic records, attendance, and performance metrics.

With the widespread adoption of web technologies and desktop application

frameworks, it is now possible to build integrated systems that provide both a
modern web portal for students and a powerful desktop application for
administrative staff.

Java remains one of the most robust and widely used programming languages for
enterprise application development. Frameworks such as Spring Boot and
Servlets/JSP provide the foundation for scalable and maintainable web
applications, while JavaFX offers rich graphical user interface capabilities for
desktop applications.

This project focuses on building a full-stack Student Information System using

Java (JDK 17+) with a web portal for students and a desktop admin application.
The system is backed by a relational database (MySQL/PostgreSQL) and follows
the MVC architecture pattern to ensure clean, maintainable, and scalable code.

The importance of this project lies in its real-world applicability in schools,

colleges, and universities. By providing students with easy access to their marks,
attendance, and profile, and enabling administrators to perform CRUD operations
with ease, the system helps educational institutions operate more efficiently and
transparently.

3
Project Overview

The main aim of this project is to design and implement a Student Information
System that integrates a web-based student portal and a desktop-based admin
application. The system allows students to log in, view their profile, marks, and
attendance, while the admin can perform complete CRUD (Create, Read, Update,
Delete) operations on student records.

The project is developed using Java (JDK 17+) with Spring Boot for the web
module, JavaFX for the desktop admin application, and MySQL/PostgreSQL as
the backend relational database. The system follows the MVC (Model-View-
Controller) architecture to maintain a clean separation of concerns.

Objectives
• To develop a secure student login and profile management module
• To implement a marks and attendance view for students via the web
portal
• To build a full-featured admin desktop application with CRUD operations
• To follow proper MVC architecture and layered design principles
• To connect the application backend to a MySQL/PostgreSQL relational
database
• To implement input validation and basic error handling throughout the
system
• To maintain clean coding practices, meaningful variable names, and
organized folder structure

4
 System Analysis and Design

System analysis and design is a critical phase in the development of any software
project, as it defines how the system will function and interact with users. In this
project, the system is designed to handle two distinct user roles: students and
administrators, each with their own interface and set of features.
The student-facing web portal allows registered students to securely log in using
their credentials. Upon login, students can view their profile information, check
subject-wise marks, and monitor attendance records. The interface is clean,
responsive, and easy to navigate.
The administrator-facing desktop application is built using JavaFX. It provides a
rich graphical user interface that allows authorized admin personnel to manage
all student data. Admins can add new students, update existing records, view
student details, and delete records from the database through intuitive forms and
tables.
The system architecture follows the MVC (Model-View-Controller) layered
design. The Model layer contains Java entity classes that map directly to the
database tables. The View layer includes JSP pages (for the web module) and
JavaFX FXML files (for the desktop module). The Controller layer handles
business logic and mediates communication between the view and the model.
The backend database contains tables for Students, Marks, Attendance, and
Admin Credentials. All data is persisted using JDBC or Spring Data JPA. Input
validation is performed at both the frontend and backend levels to ensure data
integrity and prevent errors.
The project also maintains a well-organized folder structure separating models,
controllers, views, utilities, and configuration files. This ensures scalability and
ease of maintenance as the system evolves over time.

5
 Technology Stack and Implementation

The successful implementation of this project relies on a carefully selected

technology stack that supports both web and desktop application development.
The primary programming language used is Java (JDK 17+), which is well-
known for its platform independence, strong type system, rich ecosystem, and
enterprise-grade support.
For the web module, Spring Boot is used as the primary framework. Spring Boot
simplifies the configuration and deployment of Java web applications by
providing auto-configuration, embedded servers, and a wide range of starter
dependencies. It follows the MVC pattern and integrates seamlessly with JPA for
database interactions.
The student-facing web portal uses JSP (JavaServer Pages) for rendering dynamic
HTML content and communicates with the Spring Boot controller layer. CSS is
used for styling to ensure a modern and user-friendly interface.
For the desktop admin application, JavaFX is used as the preferred framework.
JavaFX provides a comprehensive set of UI components including TableView,
TextField, Button, and FXML-based layouts. It enables the creation of visually
rich and interactive desktop interfaces that communicate directly with the
database backend through JDBC.
The backend is connected to a MySQL relational database. The database schema
includes the following tables: Student (storing student personal details), Marks
(storing subject-wise marks per student), Attendance (storing attendance
records), and AdminCredentials (for admin authentication). All database
interactions are handled through properly parameterized queries to prevent SQL
injection.

6
CODE

7
8
 Frontend UI – Web Portal Screenshots
STUDENT LOGIN PAGE

Login screen with Student/Admin toggle, email and password fields

• Student Dashboard

Dashboard showing Total Subjects, Attendance, CGPA, Rank, Recent Marks

and Upcoming Events

9
 • My Profile Page

Profile page displaying student personal information including name, roll

number, course, semester and address

• My Marks Page

Marks page showing subject-wise internal, external and total marks with grades

10
 • Attendance Page

Attendance page with overall attendance, subject-wise progress bars, and

recent attendance records
ADMIN PORTAL

11
12
 Testing and Results

The Student Information System was thoroughly tested to verify the correctness,
reliability, and usability of all implemented features. Both manual testing and
unit-level testing were performed across the web module and the desktop admin
application.
The student login module was tested with valid and invalid credentials. The
system correctly authenticated valid users and redirected them to the dashboard,
while invalid credentials triggered appropriate error messages without
compromising security.
The marks and attendance view pages were tested with multiple student records.
The data retrieved from the database was accurately displayed in tabular format,
with correct subject names, marks, and attendance percentages for each student.

All CRUD operations performed by the admin were executed correctly and
reflected immediately in the database. The JavaFX TableView was refreshed after
each operation to show updated data without requiring a restart.
Input validation was tested by submitting empty forms, invalid email formats,
and out-of-range values. The system correctly displayed error alerts and
prevented invalid data from being inserted into the database.

13
 Challenges and Learning Outcomes

During the development of this project, several technical and design challenges
were encountered, which provided valuable learning experiences.
- One of the primary challenges was integrating the web module (Spring
Boot) and the desktop admin module (JavaFX) with the same MySQL
backend. Ensuring consistent database transactions and avoiding
connection pooling issues required careful configuration of JDBC and
Spring Data JPA.
- Setting up Spring Boot MVC with JSP views required additional
configuration since Spring Boot defaults to Thymeleaf. Configuring the
InternalResourceViewResolver and placing JSP files in the correct
directory path was a learning curve.
- Designing the JavaFX admin interface with proper TableView binding to
ObservableList objects was initially complex. Managing cell value
factories and event handlers for CRUD operations required thorough
understanding of JavaFX's data binding mechanism.
- Implementing secure authentication without external libraries required
careful handling of password comparison and session management in the
Servlet-based login flow.
- Ensuring proper input validation at both the frontend (JSP/JavaFX) and
backend (controller/DAO) levels without duplicating logic was a design
challenge that was resolved through utility validation classes.

Despite these challenges, the project provided extensive hands-on experience

with enterprise Java development, including Spring Boot, JavaFX, JDBC, MVC
architecture, and relational database design. Understanding the full-stack
development lifecycle from database design to UI rendering was the most
valuable learning outcome of this project.
Additionally, the project reinforced the importance of code organization, proper
folder structure, and clean coding practices in maintaining a scalable software
system.

14
 Conclusion and Future Scope

The Student Information System with a Modern Web Portal and Desktop Admin
Application has been successfully developed, demonstrating the effectiveness of
Java-based enterprise technologies in solving real-world institutional challenges.
The system provides a seamless experience for both students and administrators
through dedicated, role-specific interfaces.
The use of Spring Boot for the web module and JavaFX for the desktop admin
application showcased the versatility of the Java ecosystem in building multi-
platform solutions. The MVC architecture ensured a clean separation of concerns,
making the codebase modular, testable, and maintainable.
The project successfully implemented all required features including student
login and profile view, marks and attendance tracking, admin CRUD operations,
input validation, and proper database connectivity using MySQL. All modules
were tested and verified to work correctly.
In terms of future scope, there are several enhancements that can be incorporated
into this system. A password hashing mechanism using BCrypt can be added to
further secure the authentication module. Email notification support can be
integrated to alert students about low attendance or upcoming deadlines.
The web portal can be extended to include a responsive design using Bootstrap
or a modern frontend framework like React, making it accessible on mobile
devices. Additionally, a reporting feature can be added that generates PDF reports
of marks and attendance for individual students.
Role-based access control can be expanded to include teacher accounts who can
enter marks and attendance data directly into the system. Integration with an SMS
gateway for critical notifications and a dashboard with analytical charts using
libraries like JFreeChart can significantly enhance the administrative experience.
In conclusion, this project demonstrates the capability of Java technologies in
building practical, scalable, and feature-rich information systems for educational
institutions. It provides a strong foundation for further research and development
in the domain of academic management systems.

15
SUSTAINABLE DEVELOPMENT GOALS (SDG) MAPPING

"Student Information System with Modern Web Portal and Desktop

Admin Application"
is aligned with:
Sustainable Development Goal 4: Quality Education
SDG 4 focuses on ensuring inclusive and equitable quality education and
promoting lifelong learning opportunities for all. It emphasizes the use of
technology to improve access to educational resources, administrative efficiency,
and data-driven decision-making in academic institutions.

Contribution to SDG:
• Improving Academic Transparency: The system provides students
with real-time access to their marks, attendance, and academic profile.
This transparency empowers students to track their progress and make
informed decisions about their studies.
• Efficient Educational Administration: The desktop admin application
enables administrators to manage student records efficiently through
CRUD operations, reducing paperwork and manual effort. This directly
contributes to better-managed and more accountable educational
institutions.
• Digital Inclusion in Education: By providing a modern web portal
accessible from any device with a browser, the system promotes digital
inclusion and ensures that students can access their academic information
regardless of their location.

By enabling educational institutions to manage student data effectively and

giving students transparent access to their academic performance, this project
directly supports the goal of quality education and helps institutions become more
data-driven, efficient, and student-centric.

16
 References

• Spring Boot Official Documentation – [Link]

boot
• JavaFX Official Documentation – [Link]
• MySQL Reference Manual – [Link]
• Oracle Java SE 17 Documentation –
[Link]
• Baeldung Spring MVC Guide – [Link]
tutorial
• JavaFX TableView Tutorial –
[Link]

17