google-site-verification: google61fe8ba583a51912.html
MACRO NEPAL
Building a Hospital Management System in Java: A Comprehensive Guide
awiskar acharya
November 9, 2025
1:54 pm

A Hospital Management System (HMS) is a comprehensive software solution that manages the day-to-day operations of a healthcare facility. This article provides a complete guide to designing and implementing a robust HMS using Java, covering architecture, key modules, and best practices.

System Architecture Overview

A well-designed HMS follows a multi-layer architecture:

Presentation Layer (Java Swing/JavaFX/Web) ↓ Business Layer (Spring Boot/Java EE) ↓ Data Access Layer (JPA/Hibernate) ↓ Database (MySQL/PostgreSQL)

Core Modules and Features

1. Patient Management

  • Patient registration and profile management
  • Medical history tracking
  • Appointment scheduling
  • Billing and payments

2. Doctor Management

  • Doctor profiles and schedules
  • Specialty and department management
  • Availability tracking

3. Appointment System

  • Online booking
  • Schedule management
  • Reminders and notifications

4. Medical Records

  • Electronic Health Records (EHR)
  • Prescription management
  • Lab test results
  • Treatment history

5. Billing and Insurance

  • Invoice generation
  • Insurance claim processing
  • Payment tracking

6. Pharmacy & Inventory

  • Medicine stock management
  • Supplier information
  • Prescription fulfillment

7. Laboratory Management

  • Test orders and results
  • Lab technician assignments
  • Report generation

Database Design

Core Entity-Relationship Diagram:

Patient ←→ Appointment ←→ Doctor ↓ ↓ ↓ MedicalRecord Billing Department ↓ ↓ ↓ Prescription ← Medicine LabTest

Implementation Code

1. Domain Models (JPA Entities)

Patient Entity:

@Entity @Table(name = "patients") public class Patient { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(nullable = false) private String firstName; @Column(nullable = false) private String lastName; @Column(unique = true) private String email; private String phone; private Date dateOfBirth; private String gender; private String address; private String bloodGroup; private String emergencyContact; @OneToMany(mappedBy = "patient") private List<Appointment> appointments; @OneToMany(mappedBy = "patient") private List<MedicalRecord> medicalRecords; // Constructors, getters, setters public Patient() {} public Patient(String firstName, String lastName, String email) { this.firstName = firstName; this.lastName = lastName; this.email = email; } }

Doctor Entity:

@Entity @Table(name = "doctors") public class Doctor { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String firstName; private String lastName; private String email; private String phone; private String specialization; private String qualification; private Integer yearsOfExperience; private String licenseNumber; @Enumerated(EnumType.STRING) private Department department; @OneToMany(mappedBy = "doctor") private List<Appointment> appointments; @OneToMany(mappedBy = "doctor") private List<MedicalRecord> medicalRecords; public enum Department { CARDIOLOGY, NEUROLOGY, ORTHOPEDICS, PEDIATRICS, DERMATOLOGY, ONCOLOGY, RADIOLOGY, EMERGENCY } // Constructors, getters, setters }

Appointment Entity:

@Entity @Table(name = "appointments") public class Appointment { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @ManyToOne @JoinColumn(name = "patient_id") private Patient patient; @ManyToOne @JoinColumn(name = "doctor_id") private Doctor doctor; private Date appointmentDate; private Time appointmentTime; private Integer duration; // in minutes @Enumerated(EnumType.STRING) private AppointmentStatus status; private String reason; private String notes; public enum AppointmentStatus { SCHEDULED, CONFIRMED, IN_PROGRESS, COMPLETED, CANCELLED, NO_SHOW } // Constructors, getters, setters }

Medical Record Entity:

@Entity @Table(name = "medical_records") public class MedicalRecord { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @ManyToOne @JoinColumn(name = "patient_id") private Patient patient; @ManyToOne @JoinColumn(name = "doctor_id") private Doctor doctor; private Date visitDate; private String diagnosis; private String symptoms; private String treatment; private String notes; @OneToMany(mappedBy = "medicalRecord") private List<Prescription> prescriptions; // Constructors, getters, setters }

Prescription Entity:

@Entity @Table(name = "prescriptions") public class Prescription { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @ManyToOne @JoinColumn(name = "medical_record_id") private MedicalRecord medicalRecord; private String medicineName; private String dosage; private String frequency; private Integer duration; // in days private String instructions; // Constructors, getters, setters }

2. Repository Layer (Spring Data JPA)

Patient Repository:

@Repository public interface PatientRepository extends JpaRepository<Patient, Long> { Optional<Patient> findByEmail(String email); List<Patient> findByLastNameContainingIgnoreCase(String lastName); @Query("SELECT p FROM Patient p WHERE p.dateOfBirth BETWEEN :startDate AND :endDate") List<Patient> findPatientsByBirthDateRange(@Param("startDate") Date startDate, @Param("endDate") Date endDate); Long countByDateOfBirthAfter(Date date); }

Appointment Repository:

@Repository public interface AppointmentRepository extends JpaRepository<Appointment, Long> { List<Appointment> findByDoctorAndAppointmentDate(Doctor doctor, Date date); List<Appointment> findByPatientAndStatus(Patient patient, Appointment.AppointmentStatus status); List<Appointment> findByAppointmentDateBetween(Date startDate, Date endDate); @Query("SELECT a FROM Appointment a WHERE a.doctor = :doctor AND a.appointmentDate = :date AND a.status = 'SCHEDULED'") List<Appointment> findScheduledAppointmentsByDoctorAndDate(@Param("doctor") Doctor doctor, @Param("date") Date date); }

3. Service Layer

Patient Service:

@Service @Transactional public class PatientService { @Autowired private PatientRepository patientRepository; public Patient registerPatient(Patient patient) { // Validate patient data if (patientRepository.findByEmail(patient.getEmail()).isPresent()) { throw new IllegalArgumentException("Patient with this email already exists"); } return patientRepository.save(patient); } public Optional<Patient> getPatientById(Long id) { return patientRepository.findById(id); } public List<Patient> searchPatients(String keyword) { return patientRepository.findByLastNameContainingIgnoreCase(keyword); } public Patient updatePatient(Long id, Patient patientDetails) { Patient patient = patientRepository.findById(id) .orElseThrow(() -> new RuntimeException("Patient not found")); patient.setFirstName(patientDetails.getFirstName()); patient.setLastName(patientDetails.getLastName()); patient.setPhone(patientDetails.getPhone()); patient.setAddress(patientDetails.getAddress()); return patientRepository.save(patient); } public void deletePatient(Long id) { Patient patient = patientRepository.findById(id) .orElseThrow(() -> new RuntimeException("Patient not found")); patientRepository.delete(patient); } }

Appointment Service:

@Service @Transactional public class AppointmentService { @Autowired private AppointmentRepository appointmentRepository; @Autowired private PatientRepository patientRepository; @Autowired private DoctorRepository doctorRepository; public Appointment scheduleAppointment(Appointment appointment) { // Validate appointment constraints validateAppointment(appointment); return appointmentRepository.save(appointment); } private void validateAppointment(Appointment appointment) { // Check if doctor is available List<Appointment> existingAppointments = appointmentRepository .findScheduledAppointmentsByDoctorAndDate( appointment.getDoctor(), appointment.getAppointmentDate() ); for (Appointment existing : existingAppointments) { if (isTimeOverlap(existing, appointment)) { throw new IllegalArgumentException("Doctor is not available at this time"); } } } private boolean isTimeOverlap(Appointment existing, Appointment newAppointment) { // Implement time overlap logic return false; // Simplified } public List<Appointment> getDoctorAppointments(Long doctorId, Date date) { Doctor doctor = doctorRepository.findById(doctorId) .orElseThrow(() -> new RuntimeException("Doctor not found")); return appointmentRepository.findByDoctorAndAppointmentDate(doctor, date); } public void cancelAppointment(Long appointmentId) { Appointment appointment = appointmentRepository.findById(appointmentId) .orElseThrow(() -> new RuntimeException("Appointment not found")); appointment.setStatus(Appointment.AppointmentStatus.CANCELLED); appointmentRepository.save(appointment); } }

4. REST Controller Layer

Patient Controller:

@RestController @RequestMapping("/api/patients") @CrossOrigin(origins = "http://localhost:3000") public class PatientController { @Autowired private PatientService patientService; @GetMapping public ResponseEntity<List<Patient>> getAllPatients() { List<Patient> patients = patientService.getAllPatients(); return ResponseEntity.ok(patients); } @GetMapping("/{id}") public ResponseEntity<Patient> getPatientById(@PathVariable Long id) { Patient patient = patientService.getPatientById(id) .orElseThrow(() -> new RuntimeException("Patient not found")); return ResponseEntity.ok(patient); } @PostMapping public ResponseEntity<Patient> createPatient(@RequestBody Patient patient) { Patient savedPatient = patientService.registerPatient(patient); return ResponseEntity.status(HttpStatus.CREATED).body(savedPatient); } @PutMapping("/{id}") public ResponseEntity<Patient> updatePatient(@PathVariable Long id, @RequestBody Patient patientDetails) { Patient updatedPatient = patientService.updatePatient(id, patientDetails); return ResponseEntity.ok(updatedPatient); } @DeleteMapping("/{id}") public ResponseEntity<Void> deletePatient(@PathVariable Long id) { patientService.deletePatient(id); return ResponseEntity.noContent().build(); } @GetMapping("/search") public ResponseEntity<List<Patient>> searchPatients(@RequestParam String keyword) { List<Patient> patients = patientService.searchPatients(keyword); return ResponseEntity.ok(patients); } }

Appointment Controller:

@RestController @RequestMapping("/api/appointments") public class AppointmentController { @Autowired private AppointmentService appointmentService; @PostMapping public ResponseEntity<Appointment> scheduleAppointment(@RequestBody Appointment appointment) { Appointment savedAppointment = appointmentService.scheduleAppointment(appointment); return ResponseEntity.status(HttpStatus.CREATED).body(savedAppointment); } @GetMapping("/doctor/{doctorId}") public ResponseEntity<List<Appointment>> getDoctorAppointments( @PathVariable Long doctorId, @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") Date date) { List<Appointment> appointments = appointmentService.getDoctorAppointments(doctorId, date); return ResponseEntity.ok(appointments); } @PutMapping("/{id}/cancel") public ResponseEntity<Void> cancelAppointment(@PathVariable Long id) { appointmentService.cancelAppointment(id); return ResponseEntity.ok().build(); } @GetMapping("/patient/{patientId}") public ResponseEntity<List<Appointment>> getPatientAppointments(@PathVariable Long patientId) { // Implementation return ResponseEntity.ok(Collections.emptyList()); } }

5. Configuration and Main Application

Application Properties:

# application.properties spring.datasource.url=jdbc:mysql://localhost:3306/hospital_db spring.datasource.username=root spring.datasource.password=password spring.jpa.hibernate.ddl-auto=update spring.jpa.show-sql=true spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect server.port=8080

Main Application Class:

@SpringBootApplication public class HospitalManagementSystemApplication { public static void main(String[] args) { SpringApplication.run(HospitalManagementSystemApplication.class, args); } @Bean public CommandLineRunner demoData(PatientRepository patientRepo, DoctorRepository doctorRepo) { return args -> { // Initialize sample data Patient patient1 = new Patient("John", "Doe", "[email protected]"); patient1.setPhone("123-456-7890"); patient1.setDateOfBirth(Date.from(LocalDate.of(1985, 5, 15) .atStartOfDay(ZoneId.systemDefault()).toInstant())); patientRepo.save(patient1); Doctor doctor1 = new Doctor(); doctor1.setFirstName("Sarah"); doctor1.setLastName("Smith"); doctor1.setSpecialization("Cardiology"); doctor1.setDepartment(Doctor.Department.CARDIOLOGY); doctor1.setLicenseNumber("MED123456"); doctorRepo.save(doctor1); }; } }

Advanced Features Implementation

1. Billing System

Billing Service:

@Service public class BillingService { @Autowired private BillingRepository billingRepository; public Bill generateBill(Long appointmentId, List<ServiceCharge> charges) { Appointment appointment = // fetch appointment Bill bill = new Bill(); bill.setAppointment(appointment); bill.setBillDate(new Date()); bill.setServices(charges); double total = charges.stream() .mapToDouble(ServiceCharge::getAmount) .sum(); bill.setTotalAmount(total); return billingRepository.save(bill); } public void processPayment(Long billId, Payment payment) { Bill bill = billingRepository.findById(billId) .orElseThrow(() -> new RuntimeException("Bill not found")); bill.setPaymentStatus(PaymentStatus.PAID); bill.setPaymentDate(new Date()); billingRepository.save(bill); } }

2. Reporting Module

Report Service:

@Service public class ReportService { public HospitalStatistics generateMonthlyReport(int year, int month) { HospitalStatistics stats = new HospitalStatistics(); stats.setTotalPatients(patientRepository.countByRegistrationMonth(year, month)); stats.setTotalAppointments(appointmentRepository.countByMonth(year, month)); stats.setRevenue(billingRepository.getMonthlyRevenue(year, month)); return stats; } }

Security Implementation

Security Configuration:

@Configuration @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .csrf().disable() .authorizeHttpRequests(authz -> authz .requestMatchers("/api/public/**").permitAll() .requestMatchers("/api/patients/**").hasAnyRole("DOCTOR", "ADMIN") .requestMatchers("/api/doctors/**").hasRole("ADMIN") .anyRequest().authenticated() ) .httpBasic(); return http.build(); } @Bean public UserDetailsService userDetailsService() { UserDetails doctor = User.builder() .username("doctor") .password(passwordEncoder().encode("password")) .roles("DOCTOR") .build(); UserDetails admin = User.builder() .username("admin") .password(passwordEncoder().encode("admin")) .roles("ADMIN") .build(); return new InMemoryUserDetailsManager(doctor, admin); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } }

Testing

Patient Service Test:

@SpringBootTest class PatientServiceTest { @Autowired private PatientService patientService; @Autowired private PatientRepository patientRepository; @Test void testRegisterPatient() { Patient patient = new Patient("Test", "User", "[email protected]"); Patient savedPatient = patientService.registerPatient(patient); assertNotNull(savedPatient.getId()); assertEquals("Test", savedPatient.getFirstName()); } @Test void testRegisterPatientWithDuplicateEmail() { Patient patient1 = new Patient("John", "Doe", "[email protected]"); patientService.registerPatient(patient1); Patient patient2 = new Patient("Jane", "Doe", "[email protected]"); assertThrows(IllegalArgumentException.class, () -> { patientService.registerPatient(patient2); }); } }

Frontend Integration (Basic Example)

Simple HTML/JavaScript Client:

<!DOCTYPE html> <html> <head> <title>Hospital Management System</title> <script src="https://unpkg.com/axios/dist/axios.min.js"></script> </head> <body> <div id="app"> <h1>Patient Registration</h1> <form id="patientForm"> <input type="text" id="firstName" placeholder="First Name" required> <input type="text" id="lastName" placeholder="Last Name" required> <input type="email" id="email" placeholder="Email" required> <button type="submit">Register Patient</button> </form> <div id="patientList"></div> </div> <script> const API_BASE = 'http://localhost:8080/api'; // Register patient document.getElementById('patientForm').addEventListener('submit', async (e) => { e.preventDefault(); const patient = { firstName: document.getElementById('firstName').value, lastName: document.getElementById('lastName').value, email: document.getElementById('email').value }; try { const response = await axios.post(`${API_BASE}/patients`, patient); alert('Patient registered successfully!'); loadPatients(); } catch (error) { alert('Error registering patient: ' + error.response.data.message); } }); // Load patients async function loadPatients() { try { const response = await axios.get(`${API_BASE}/patients`); const patients = response.data; const patientList = document.getElementById('patientList'); patientList.innerHTML = '<h2>Patients</h2>' + patients.map(p => `<div>${p.firstName} ${p.lastName} - ${p.email}</div>`).join(''); } catch (error) { console.error('Error loading patients:', error); } } // Initial load loadPatients(); </script> </body> </html>

Deployment Considerations

Docker Configuration:

FROM openjdk:17-jdk-slim VOLUME /tmp COPY target/hospital-management-system-1.0.0.jar app.jar ENTRYPOINT ["java","-jar","/app.jar"]

docker-compose.yml:

version: '3.8' services: app: build: . ports: - "8080:8080" environment: - SPRING_DATASOURCE_URL=jdbc:mysql://db:3306/hospital_db depends_on: - db db: image: mysql:8.0 environment: - MYSQL_ROOT_PASSWORD=password - MYSQL_DATABASE=hospital_db volumes: - db_data:/var/lib/mysql volumes: db_data:

Best Practices

  1. Data Validation: Always validate input data
  2. Exception Handling: Implement global exception handling
  3. Logging: Use SLF4J for comprehensive logging
  4. Security: Implement proper authentication and authorization
  5. Documentation: Use Swagger for API documentation
  6. Testing: Maintain high test coverage
  7. Monitoring: Implement health checks and metrics

Conclusion

Building a Hospital Management System in Java requires careful planning and implementation of various modules. This guide provides:

  • Modular architecture for scalability
  • RESTful APIs for integration
  • Comprehensive entity relationships
  • Security implementation
  • Testing strategies

The system can be extended with additional features like:

  • Real-time notifications
  • Mobile app integration
  • AI-powered diagnostics
  • Telemedicine capabilities
  • Advanced analytics and reporting

By following this structure, you can create a robust, maintainable, and scalable Hospital Management System that meets the complex needs of modern healthcare facilities.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper