This project moves persistence from manually implemented DAO classes to Spring Data JPA repositories. Common CRUD operations are provided by repository interfaces, while project-specific queries are expressed through derived query methods and explicit @Query declarations.

Compared to the Hibernate / JPA version, this approach significantly reduces the amount of data-access code and allows the application to focus more on validation, business logic, and user-facing behavior.

The service and repository layers support the core school-management operations for groups, students, courses, and student-course enrollments.

Unlike the previous Hibernate / JPA project, persistence operations are no longer implemented through manual DAO classes with direct EntityManager usage. Instead, the application delegates data access to Spring Data JPA repository interfaces.

The console UI exposes the following user-facing actions:

• Find all groups with a student count less than or equal to a given number.
• List all students enrolled in a course by course name.
• Add a new student.
• Delete a student by student ID.
• Assign a student to a course.
• Remove a student from one of their courses.

This diagram shows the main structural blocks of the Spring Data JPA version. It highlights the transition from manually implemented DAO classes to repository-based persistence through Spring Data JPA.

In this project, the console UI still exposes the same school-management actions, but the persistence layer now works through Spring Data JPA repository interfaces instead of custom DAO implementations.

The main flow is:

Spring Boot Entry Point → Console UI → Service Layer → Repository Layer → Spring Data JPA → Hibernate / JPA → PostgreSQL

The PlantUML source for this diagram is stored in:

docs/diagrams/application-structure.puml

The rendered SVG diagram is stored in:

docs/diagrams/application-structure.svg

The application uses the same school-management database schema as the previous projects in the series: academic groups, students, courses, and a many-to-many relation between students and courses.

The database structure remains unchanged from the earlier repositories in the series. This makes it easier to compare how the persistence layer evolves while the domain model stays consistent.

In this repository, the schema is still managed through Flyway migrations, but application code interacts with the data through Spring Data JPA repositories for entities such as Student, Group, and Course.

The PlantUML source for this diagram is stored in:

docs/diagrams/database-schema.puml

The rendered SVG diagram is stored in:

docs/diagrams/database-schema.svg

This option is intended for quickly trying the released application. The source repository is not required.

The commands below are intended for Bash or WSL.

IMAGE=yuriikorolkov/school-application-spring-data-jpa:1.0.0

docker pull "$IMAGE"

The immutable version tag 1.0.0 is recommended for reproducible runs. The latest tag points to the most recently published release.

docker network create school-data-jpa-demo

docker run -d --rm \
  --name school-data-jpa-postgres \
  --network school-data-jpa-demo \
  -e POSTGRES_DB=school_console_app \
  -e POSTGRES_USER=school_demo \
  -e POSTGRES_PASSWORD=local-demo-password \
  --health-cmd="pg_isready -U school_demo -d school_console_app" \
  --health-interval=5s \
  --health-timeout=5s \
  --health-retries=10 \
  postgres:16

until docker inspect \
  -f '{{.State.Health.Status}}' \
  school-data-jpa-postgres \
  | grep -q '^healthy$'; do
  echo "Waiting for PostgreSQL..."
  sleep 2
done

docker run --rm -it \
  --name school-data-jpa-app \
  --network school-data-jpa-demo \
  -e SPRING_DATASOURCE_URL=jdbc:postgresql://school-data-jpa-postgres:5432/school_console_app \
  -e SPRING_DATASOURCE_USERNAME=school_demo \
  -e SPRING_DATASOURCE_PASSWORD=local-demo-password \
  "$IMAGE"

The application starts in interactive console mode. Select q to exit.

docker stop school-data-jpa-postgres
docker network rm school-data-jpa-demo

The PostgreSQL container uses temporary storage in this demo, so its data is removed during cleanup.

This option is intended for development and testing changes made to the source code.

The local startup scripts automatically:

• build the executable Spring Boot JAR;
• optionally run Maven tests;
• validate the Docker Compose configuration;
• build the application Docker image;
• start PostgreSQL;
• run the application in interactive console mode.

Maven tests are skipped by default to make repeated local startup faster.

chmod +x run.sh

./run.sh

./run.sh --run-tests

./run.sh --reset-database

./run.sh --postgres-password "my-local-password"

./run.sh \
  --run-tests \
  --reset-database

./run.sh \
  --reset-database \
  --postgres-password "my-local-password"

./run.sh \
  --run-tests \
  --reset-database \
  --postgres-password "my-local-password"

./run.sh --help

powershell -ExecutionPolicy Bypass -File .\run.ps1

.\run.ps1

.\run.ps1 -RunTests

.\run.ps1 -ResetDatabase

.\run.ps1 -PostgresPassword "my-local-password"

.\run.ps1 `
  -RunTests `
  -ResetDatabase

.\run.ps1 `
  -ResetDatabase `
  -PostgresPassword "my-local-password"

.\run.ps1 `
  -RunTests `
  -ResetDatabase `
  -PostgresPassword "my-local-password"

.\run.ps1 -RunTests -ResetDatabase -PostgresPassword "my-local-password"

After the console application exits, PostgreSQL remains available and its data is preserved for the next startup.

Linux or WSL:

POSTGRES_PASSWORD=local-dev-password \
  docker compose down

Windows PowerShell:

$env:POSTGRES_PASSWORD = "local-dev-password"
docker compose down
Remove-Item Env:POSTGRES_PASSWORD

This stops and removes the containers and network while preserving the PostgreSQL volume.

Linux or WSL:

POSTGRES_PASSWORD=local-dev-password \
  docker compose down \
    --volumes \
    --remove-orphans

Windows PowerShell:

$env:POSTGRES_PASSWORD = "local-dev-password"
docker compose down --volumes --remove-orphans
Remove-Item Env:POSTGRES_PASSWORD

This also removes the PostgreSQL volume and all locally stored application data.

The same cleanup can be performed automatically during the next startup.

Linux or WSL:

./run.sh --reset-database

Windows PowerShell:

.\run.ps1 -ResetDatabase

This section is intended for local development when PostgreSQL is already available and configured for the application.

Run the test suite:

./mvnw clean test

Build the executable Spring Boot JAR:

./mvnw clean package

Run the packaged application:

java -jar target/SchoolApplicationDataJPA-1.0.0.jar

The application still requires PostgreSQL to be available according to the configured datasource properties. For a fully prepared local environment, prefer the Docker-based startup scripts described above.