Spring Data JPA Quiz - MCQ - Multiple Choice Questions

Q. Which of the following is NOT a valid way to enable Spring Data integration in a project?

A Adding dependencies to pom.xml or gradle build. B Using <context:component-scan> to pick up repositories. C Letting Spring Boot auto-configuration wire repositories. D Manually configuring a data source bean.

Q. What is the purpose of the `Predicate` functional interface in Java 8?

A To produce results. B To consume values. C To filter elements based on a boolean condition. D To transform values.

Q. Which of the following is NOT true about Spring Data repositories?

A They can be defined for both entities and value objects. B They provide CRUD support automatically. C Derived method names can express custom queries. D They only work with relational databases.

Q. Which of the following code snippets demonstrates the correct configuration of a Spring Data JPA Repository?

A Extends `JpaRepository` with no extra code.

public interface UserRepository extends JpaRepository<User, Long> {

}

B Extends `CrudRepository`.

public interface UserRepository extends CrudRepository<User, Long> {

}

C Extends a non-existent `JpaDao`.

public interface UserRepository extends JpaDao<User, Long> {

}

D Extends `JpaRepository` (duplicate of option A).

public interface UserRepository extends JpaRepository<User, Long> {

}

Q. Which code snippet demonstrates the correct usage of a derived query method in Spring Data JPA?

A Uses `findByUsername`.

public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);
}

B Uses `getUserByUsername`.

public interface UserRepository extends JpaRepository<User, Long> {
    User getUserByUsername(String username);
}

C Uses `findByEmail`.

public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
}

D Uses `findUserByEmail`.

public interface UserRepository extends JpaRepository<User, Long> {
    User findUserByEmail(String email);
}

Q. Which annotation is used to define a named query in Spring Data JPA?

A Uses `@Query(name = "findUserByUsername")`.

@Query(name = "findUserByUsername")

B Uses `@NamedQuery(name = "findUserByUsername")`.

@NamedQuery(name = "findUserByUsername")

C Uses `@NamedQuery("findUserByUsername")`.

@NamedQuery("findUserByUsername")

D Uses `@NamedQuery(value = "findUserByUsername")`.

@NamedQuery(value = "findUserByUsername")

Q. Which snippet shows a typical `@Transactional` method in Spring Data JPA?

A Default transactional save.

@Transactional
public void saveUser(User user) {
    userRepository.save(user);
}

B Specifies propagation.

@Transactional(propagation = Propagation.REQUIRED)
public void saveUser(User user) {
    userRepository.save(user);
}

C Custom rollback rule.

@Transactional(rollbackFor = Exception.class)
public void saveUser(User user) {
    userRepository.save(user);
}

D Read-only transaction while writing.

@Transactional(readOnly = true)
public void saveUser(User user) {
    userRepository.save(user);
}

Q. Which snippet shows correct usage of the `@Query` annotation in Spring Data JPA?

A JPQL selecting from entity names.

@Query("SELECT u FROM User u WHERE u.username = :username")
public User findByUsername(@Param("username") String username);

B Native query selecting from table.

@Query(value = "SELECT * FROM users WHERE username = :username", nativeQuery = true)
public User findByUsername(@Param("username") String username);

C JPQL mistakenly using `*`.

@Query("SELECT * FROM User u WHERE u.username = :username")
public User findByUsername(@Param("username") String username);

D Native query but JPQL style select clause.

@Query(value = "SELECT u FROM users u WHERE u.username = :username", nativeQuery = true)
public User findByUsername(@Param("username") String username);

Q. Which snippet correctly uses `@JoinColumn` in Spring Data JPA?

A `@OneToOne` owning side with join column.

@OneToOne
@JoinColumn(name = "address_id")
private Address address;

B Inverse side indicated via `mappedBy`.

@OneToOne(mappedBy = "user")
private Address address;

C `@ManyToOne` also using join column.

@ManyToOne
@JoinColumn(name = "address_id")
private Address address;

D `@ManyToOne` with `mappedBy` (invalid pairing).

@ManyToOne(mappedBy = "user")
private Address address;

Q. Which snippet demonstrates correct `@OneToMany` usage in Spring Data JPA?

A Inverse side with `mappedBy = "user"`.

@OneToMany(mappedBy = "user")
private List<Order> orders;

B Owning side using `@JoinColumn`.

@OneToMany
@JoinColumn(name = "user_id")
private List<Order> orders;

C Incorrect `@ManyToOne` with list.

@ManyToOne
@JoinColumn(name = "user_id")
private List<Order> orders;

D `mappedBy = "orders"` on users list.

@OneToMany(mappedBy = "orders")
private List<User> users;

Q. Which snippet shows the proper use of `@ManyToMany` in Spring Data JPA?

A Declares join table `user_role`.

@ManyToMany
@JoinTable(
    name = "user_role",
    joinColumns = @JoinColumn(name = "user_id"),
    inverseJoinColumns = @JoinColumn(name = "role_id")
)
private List<Role> roles;

B Inverse side via `mappedBy = "users"`.

@ManyToMany(mappedBy = "users")
private List<Role> roles;

C Incorrect `@OneToMany` mapping.

@OneToMany(mappedBy = "users")
private List<Role> roles;

D Missing join table definition.

@ManyToMany
@JoinColumn(name = "role_id")
private List<Role> roles;

Q. What is the purpose of the `@Transactional` annotation in Spring Data JPA?

A It defines a named query. B It marks a method as transactional. C It defines a foreign key column. D It defines a custom JPQL query.

Q. What is the purpose of the `@GeneratedValue` annotation in Spring Data JPA?

A Define a named query. B Mark a method as transactional. C Define a foreign key column. D Automatically generate a primary key value.

Search Tutorials

Spring Data JPA Quiz - MCQ - Multiple Choice Questions

Popular Posts

See Also