Spring Boot and Hibernate Many-to-Many CRUD REST API Tutorial

In this tutorial, we will demonstrate how to set up a many-to-many relationship between Student and Course entities using Spring Boot and Hibernate, and expose CRUD operations through a REST API.

Prerequisites

1. Java Development Kit (JDK) 11 or higher: Ensure JDK is installed and configured on your system.
2. Integrated Development Environment (IDE): IntelliJ IDEA, Eclipse, or any other IDE.
3. Maven: Ensure Maven is installed and configured on your system.

Step 1: Create a Spring Boot Project

1. Open your IDE and create a new Spring Boot project.
2. Use Spring Initializr or manually create the pom.xml file to include Spring Boot and other required dependencies.

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>spring-boot-many-to-many-example</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.0</version>
        <relativePath/>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Explanation

• spring-boot-starter-data-jpa: Includes Spring Data JPA with Hibernate.
• spring-boot-starter-web: Includes Spring MVC for building web applications.
• h2: An in-memory database for testing purposes.

Step 2: Configure the Application Properties

Configure the application.properties file to set up the H2 database.

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

Step 3: Create the Student Entity Class

Create a package named com.example.entity and a class named Student.

package com.example.entity;

import jakarta.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToMany(cascade = CascadeType.ALL)
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses = new HashSet<>();

    public Student() {}

    public Student(String name) {
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<Course> getCourses() {
        return courses;
    }

    public void setCourses(Set<Course> courses) {
        this.courses = courses;
    }

    public void addCourse(Course course) {
        courses.add(course);
        course.getStudents().add(this);
    }

    public void removeCourse(Course course) {
        courses.remove(course);
        course.getStudents().remove(this);
    }

    @Override
    public String toString() {
        return "Student{id=" + id + ", name='" + name + '\'' + '}';
    }
}

Explanation

• @Entity: Marks the class as an entity.
• @Id: Marks the field as the primary key.
• @GeneratedValue: Specifies the strategy for generating values for the primary key.
• @ManyToMany: Defines a many-to-many relationship with the Course entity.
• @JoinTable: Specifies the join table.
• @JoinColumn: Specifies the foreign key column for the current entity.
• @inverseJoinColumns: Specifies the foreign key column for the other entity in the relationship.

Step 4: Create the Course Entity Class

Create a class named Course in the same package.

package com.example.entity;

import jakarta.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToMany(mappedBy = "courses")
    private Set<Student> students = new HashSet<>();

    public Course() {}

    public Course(String name) {
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<Student> getStudents() {
        return students;
    }

    public void setStudents(Set<Student> students) {
        this.students = students;
    }

    @Override
    public String toString() {
        return "Course{id=" + id + ", name='" + name + '\'' + '}';
    }
}

Explanation

• @Entity: Marks the class as an entity.
• @Id: Marks the field as the primary key.
• @GeneratedValue: Specifies the strategy for generating values for the primary key.
• @ManyToMany: Defines a many-to-many relationship with the Student entity.
• mappedBy: Specifies the field in the Student entity that owns the relationship.

Step 5: Create Repository Interfaces

Create a package named com.example.repository and interfaces for Student and Course.

package com.example.repository;

import com.example.entity.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface StudentRepository extends JpaRepository<Student, Long> {}

package com.example.repository;

import com.example.entity.Course;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface CourseRepository extends JpaRepository<Course, Long> {}

Step 6: Create Service Classes

Create a package named com.example.service and service classes for Student and Course.

package com.example.service;

import com.example.entity.Student;
import com.example.entity.Course;
import com.example.repository.StudentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class StudentService {
    @Autowired
    private StudentRepository studentRepository;

    public Student save(Student student) {
        return studentRepository.save(student);
    }

    public List<Student> findAll() {
        return studentRepository.findAll();
    }

    public Student findById(Long id) {
        return studentRepository.findById(id).orElse(null);
    }

    public void deleteById(Long id) {
        studentRepository.deleteById(id);
    }

    public Student addCourse(Long studentId, Course course) {
        Student student = findById(studentId);
        if (student != null) {
            student.addCourse(course);
            return save(student);
        }
        return null;
    }

    public Student removeCourse(Long studentId, Long courseId) {
        Student student = findById(studentId);
        if (student != null) {
            Course course = student.getCourses().stream().filter(c -> c.getId().equals(courseId)).findFirst().orElse(null);
            if (course != null) {
                student.removeCourse(course);
                return save(student);
            }
        }
        return null;
    }
}

package com.example.service;

import com.example.entity.Course;
import com.example.repository.CourseRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class CourseService {
    @Autowired
    private CourseRepository courseRepository;

    public Course save(Course course) {
        return courseRepository.save(course);
    }

    public List<Course> findAll() {
        return courseRepository.findAll();
    }

    public Course findById(Long id) {
        return courseRepository.findById(id).orElse(null);
    }

    public void deleteBy

Id(Long id) {
        courseRepository.deleteById(id);
    }
}

Step 7: Create Controller Classes

Create a package named com.example.controller and controller classes for Student and Course.

package com.example.controller;

import com.example.entity.Student;
import com.example.entity.Course;
import com.example.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/students")
public class StudentController {
    @Autowired
    private StudentService studentService;

    @PostMapping
    public Student createStudent(@RequestBody Student student) {
        return studentService.save(student);
    }

    @GetMapping
    public List<Student> getAllStudents() {
        return studentService.findAll();
    }

    @GetMapping("/{id}")
    public Student getStudentById(@PathVariable Long id) {
        return studentService.findById(id);
    }

    @DeleteMapping("/{id}")
    public void deleteStudent(@PathVariable Long id) {
        studentService.deleteById(id);
    }

    @PostMapping("/{studentId}/courses")
    public Student addCourse(@PathVariable Long studentId, @RequestBody Course course) {
        return studentService.addCourse(studentId, course);
    }

    @DeleteMapping("/{studentId}/courses/{courseId}")
    public Student removeCourse(@PathVariable Long studentId, @PathVariable Long courseId) {
        return studentService.removeCourse(studentId, courseId);
    }
}

package com.example.controller;

import com.example.entity.Course;
import com.example.service.CourseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/courses")
public class CourseController {
    @Autowired
    private CourseService courseService;

    @PostMapping
    public Course createCourse(@RequestBody Course course) {
        return courseService.save(course);
    }

    @GetMapping
    public List<Course> getAllCourses() {
        return courseService.findAll();
    }

    @GetMapping("/{id}")
    public Course getCourseById(@PathVariable Long id) {
        return courseService.findById(id);
    }

    @DeleteMapping("/{id}")
    public void deleteCourse(@PathVariable Long id) {
        courseService.deleteById(id);
    }
}

Step 8: Create Main Application Class

Create a package named com.example and a class named SpringBootManyToManyExampleApplication.

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootManyToManyExampleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootManyToManyExampleApplication.class, args);
    }
}

Step 9: Run the Application

1. Run the SpringBootManyToManyExampleApplication class.
2. Use an API client (e.g., Postman) or a web browser to test the endpoints.

Testing the Endpoints

1. Create a Student:

   • URL: POST /students
   • Body:

     {
       "name": "John Doe"
     }
     

2. Create a Course:

   • URL: POST /courses
   • Body:

     {
       "name": "Math 101"
     }
     

3. Add Course to Student:

   • URL: POST /students/{studentId}/courses
   • Body:

     {
       "name": "Math 101"
     }
     

4. Get All Students:

   • URL: GET /students

5. Get Student by ID:

   • URL: GET /students/{id}

6. Delete Student by ID:

   • URL: DELETE /students/{id}

7. Get All Courses:

   • URL: GET /courses

8. Get Course by ID:

   • URL: GET /courses/{id}

9. Delete Course by ID:

   • URL: DELETE /courses/{id}

Conclusion

You have successfully created an example using Spring Boot and Hibernate to demonstrate a many-to-many relationship between Student and Course entities. This tutorial covered setting up a Spring Boot project, configuring Hibernate, creating entity classes with a many-to-many relationship, and performing CRUD operations through RESTful endpoints.