Why JPA matters for database access in Spring Boot - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use JPA instead of plain SQL in Spring Boot?

Which of the following best explains why JPA is preferred over writing plain SQL queries directly in Spring Boot applications?

A JPA only works with NoSQL databases, so it is not suitable for relational databases.

B JPA requires writing more SQL queries manually, giving developers full control over database access.

C JPA disables transaction management, making database operations faster but less safe.

D JPA automatically maps Java objects to database tables, reducing boilerplate code and improving maintainability.

💡 Hint

Think about how JPA helps connect Java code with database tables.

JPA helps by automatically linking Java objects to database tables. This means developers write less SQL and focus more on Java code, making the app easier to maintain.

❓ component_behavior

intermediate

JPA Entity Behavior in Spring Boot

Given a JPA entity with a field annotated as @Id and @GeneratedValue, what happens when you save a new entity instance using a Spring Data JPA repository?

Spring Boot

import jakarta.persistence.*;

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

  // getters and setters
}

// In a Spring Boot service:
Product p = new Product();
p.setName("Book");
productRepository.save(p);

Long savedId = p.getId();

A The id field remains null because JPA does not generate IDs automatically.

B The id field is automatically assigned a unique value by the database after saving.

C An exception is thrown because the id field must be set manually before saving.

D The id field is set to zero by default after saving.

💡 Hint

Consider what @GeneratedValue does in JPA.

The @GeneratedValue annotation tells JPA to let the database generate a unique ID when the entity is saved. After saving, the entity's id field is updated with this value.

📝 Syntax

advanced

Correct JPQL Query Syntax in Spring Data JPA

Which of the following JPQL queries correctly selects all users with the last name 'Smith' using Spring Data JPA?

Spring Boot

public interface UserRepository extends JpaRepository<User, Long> {
  @Query("?1")
  List<User> findByLastName();
}

A "SELECT u FROM User u WHERE u.lastName = 'Smith'"

B "SELECT * FROM users WHERE lastName = 'Smith'"

C "FROM User WHERE lastName = 'Smith'"

D "SELECT u FROM User u WHERE lastName = 'Smith'"

💡 Hint

JPQL uses entity names and fields, not table names or *.

JPQL queries use entity class names and their fields. Option A correctly uses 'SELECT u FROM User u WHERE u.lastName = 'Smith''.

❓ state_output

advanced

Effect of Transactional Annotation on JPA Repository Save

In a Spring Boot service method annotated with @Transactional, what happens if an exception is thrown after saving an entity with a JPA repository?

Spring Boot

@Service
public class UserService {
  @Autowired
  private UserRepository userRepository;

  @Transactional
  public void createUser(String name) {
    User user = new User();
    user.setName(name);
    userRepository.save(user);
    if (true) {
      throw new RuntimeException("Fail");
    }
  }
}

A The save operation is rolled back, so the user is not saved in the database.

B The user is saved despite the exception because save() commits immediately.

C The exception is ignored and the transaction commits normally.

D The database connection is closed but the user is saved.

💡 Hint

Think about what @Transactional does when exceptions occur.

The @Transactional annotation rolls back the entire transaction if a RuntimeException occurs, so the save is undone.

🔧 Debug

expert

Diagnosing LazyInitializationException in JPA

A Spring Boot application using JPA throws a LazyInitializationException when accessing a collection property of an entity outside a transaction. Which option best explains why this happens?

A The entity class is missing the @Entity annotation, so JPA does not manage it.

B The entity was saved without an ID, causing the collection to be null.

C The collection was not fetched eagerly and the session is closed when accessed, so JPA cannot load it lazily.

D The database connection was lost, so JPA cannot fetch any data.

💡 Hint

LazyInitializationException usually relates to session and fetching strategy.

LazyInitializationException occurs when JPA tries to load a lazy collection but the session (transaction) is closed. The collection was not loaded eagerly, so it cannot be accessed outside the transaction.