@ManyToOne relationship in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this @ManyToOne mapping when fetching a child entity?

Given the following JPA entities, what will be printed when fetching a Book entity and accessing its author field?

Spring Boot

import jakarta.persistence.*;

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

    // getters and setters
}

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

    @ManyToOne
    @JoinColumn(name = "author_id")
    private Author author;

    // getters and setters
}

// In a service method:
Book book = entityManager.find(Book.class, 1L);
System.out.println(book.getAuthor().getName());

A Prints null because the author is not fetched automatically

B Prints the name of the author linked to the book with id 1

C Throws NullPointerException because author is not initialized

D Throws a compilation error due to missing annotations

💡 Hint

Consider the default fetch type of @ManyToOne and what happens when you access the related entity.

The default fetch type for @ManyToOne is EAGER, so the related Author entity is fetched automatically when the Book is loaded. Therefore, accessing book.getAuthor().getName() prints the author's name.

📝 Syntax

intermediate

Which option correctly defines a @ManyToOne relationship with a custom join column?

Choose the correct code snippet that defines a @ManyToOne relationship with a join column named category_id in a Product entity.

A

@ManyToOne
@JoinColumn(name = "category_id")
private Category category;

B

@ManyToOne
@JoinColumn("category_id")
private Category category;

C

@ManyToOne
@JoinColumn(columnName = "category_id")
private Category category;

D

@ManyToOne
@JoinColumn(name = category_id)
private Category category;

💡 Hint

Remember the correct attribute name for specifying the column name in @JoinColumn.

The correct attribute to specify the join column name is name. Option A uses @JoinColumn(name = "category_id") which is correct. Option A misses the attribute name, C uses a wrong attribute columnName, and D misses quotes around the string.

🔧 Debug

advanced

Why does this @ManyToOne mapping cause a runtime LazyInitializationException?

Consider this code snippet:

Book book = entityManager.find(Book.class, 1L);
entityManager.close();
System.out.println(book.getAuthor().getName());

Why does accessing book.getAuthor().getName() throw a LazyInitializationException?

A Because the default fetch type of @ManyToOne is LAZY and the entity manager is closed before accessing the author

B Because the Book entity is detached and cannot access any fields

C Because the @JoinColumn is missing, so the relationship is not mapped

D Because the author field is null and accessing getName() causes the exception

💡 Hint

Check the default fetch type of @ManyToOne and when the related entity is loaded.

By default, @ManyToOne fetch type is EAGER, but if it is explicitly set to LAZY, the related entity is not loaded until accessed. If the entity manager is closed before accessing the lazy field, a LazyInitializationException occurs because the proxy cannot load the data.

❓ state_output

advanced

What is the state of the owning side after this code runs?

Given these entities:

@Entity
class Order {
  @Id
  Long id;

  @ManyToOne
  Customer customer;
}

@Entity
class Customer {
  @Id
  Long id;

  String name;
}

And this code:

Order order = new Order();
Customer customer = new Customer();
customer.setName("Alice");
order.setCustomer(customer);
entityManager.persist(customer);
entityManager.persist(order);
entityManager.flush();

What is true about the database state after flush?

A Order is saved but customer_id in Order is null because Customer has no id yet

B Only Customer is saved because Order depends on Customer but is not persisted

C Neither entity is saved because Customer must be saved before setting in Order

D Both Customer and Order are saved, and Order's customer_id column references the Customer's id

💡 Hint

Think about the order of persisting and how JPA handles relationships.

Both entities are persisted explicitly. The Customer gets an id when persisted. The Order references the Customer, so the foreign key column customer_id in Order points to the Customer's id. The flush writes both to the database.

🧠 Conceptual

expert

Which statement about @ManyToOne and cascading is correct?

Consider a @ManyToOne relationship from Invoice to Client. Which of these statements about cascading operations is true?

A CascadeType.REMOVE on @ManyToOne deletes the Invoice when Client is deleted

B CascadeType.ALL on @ManyToOne is required to save the Client when saving Invoice

C CascadeType.ALL on @ManyToOne causes operations on Invoice to propagate to Client, which can lead to unintended deletes

D CascadeType.PERSIST on @ManyToOne prevents saving Invoice without an existing Client

💡 Hint

Think about the direction of cascading and what happens when you delete the owning entity.

Cascading from the many side (@ManyToOne) to the one side means operations on the child entity (Invoice) propagate to the parent (Client). Using CascadeType.ALL can cause deleting an Invoice to delete its Client, which is usually unintended. Typically, cascading is set from the one side to the many side.