Spring Boot Quick Start 30 - Adding Course APIs

Summary

The video demonstrates how to create a Course API by leveraging the existing Topic API structure. It walks through copying and renaming the topic package, updating entity classes, and establishing CRUD operations for courses. Key highlights include linking courses to topics using a `Topic` member variable, designing RESTful endpoints under `/topics/{topicId}/courses`, and ensuring proper handling of topic associations during course creation and updates. The tutorial also addresses the challenge of filtering courses by topic ID and introduces strategies for maintaining database integrity while mapping entities. This guide simplifies building a relational API with Spring Data JPA.

Takeaways

• 😀 The Course API is created by copying the Topic API structure and renaming classes accordingly.
• 😀 The Course entity initially contains ID, name, and description, similar to the Topic entity.
• 😀 Each Course should eventually be linked to a Topic, allowing a topic to contain multiple courses.
• 😀 The CourseRepository extends CrudRepository to provide standard CRUD operations for courses.
• 😀 The CourseService uses the repository to implement methods for adding, updating, fetching, and deleting courses.
• 😀 The CourseController maps URLs under topics, e.g., /topics/{topicId}/courses, for nested resource access.
• 😀 Adding a course involves setting its Topic based on the topicId from the URL, even if the Topic object is incomplete.
• 😀 Updating a course follows the same pattern: the course is tied to a topic using the topicId from the URL.
• 😀 Deleting a course only requires the course ID and does not affect the topic directly.
• 😀 Proper mapping between Course and Topic in the database requires JPA annotations, like @ManyToOne and @JoinColumn, to handle foreign key relationships.
• 😀 Fetching all courses for a specific topic requires a method that filters courses based on the topicId rather than returning all courses.

Q & A

What is the first step in creating the Course API according to the script?

The first step is to copy the complete Topic package and create a new package for courses, then rename all the classes to correspond to courses.

Which member variables are initially included in the Course entity?

Initially, the Course entity contains `id`, `name`, and `description`.

How does the script suggest linking a Course to a Topic?

By adding a member variable `topic` in the Course class, which can hold a Topic instance representing the topic to which the course belongs.

How should the `getAllCourses` method URL be structured?

The URL should be structured as `/topics/{topicId}/courses`, allowing retrieval of all courses under a specific topic.

What approach is used to add a new course under a specific topic?

In the add course method, the topic ID is extracted from the path variable, a new Topic instance is created with that ID (name and description empty), and this topic is set in the course before saving it.

How is updating a course handled in the CourseController?

The update method accepts the topic ID from the path variable and the course from the request body, sets the course's topic to a new Topic instance with that ID, and then calls `courseService.updateCourse()` to save changes.

Why is it safe to create a Topic instance with only an ID when adding or updating a course?

Because JPA only maps the foreign key relationship; it does not overwrite the existing Topic data, so the empty name and description do not affect the actual topic in the database.

What CRUD operations are implemented in the CourseController?

The controller implements the following operations: get course by ID, get all courses by topic, add course, update course, and delete course.

What change needs to be made to the `CourseRepository` to support getting courses by topic?

A custom query method should be added, such as `List<Course> findByTopicId(String topicId)`, to retrieve only the courses belonging to a specific topic.

Which JPA annotations are used to map the relationship between Course and Topic?

The `@ManyToOne` annotation on the Course entity and `@JoinColumn(name = 'topic_id')` to specify the foreign key column are used to map the relationship.

How does the script differentiate between the URL structures for courses and topics?

Instead of using `/courses` at the root, the URLs are nested under topics, e.g., `/topics/{topicId}/courses`, to indicate that courses belong to specific topics.

What is the purpose of modifying the course object with a topic instance in the controller?

This ensures that the course is correctly associated with the topic based on the URL path parameter without requiring the user to provide topic details in the request body.