Database and app orchestration in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Spring Boot REST controller method?

Consider this Spring Boot controller method that fetches a user by ID from a database using JPA. What will be the HTTP response status if the user is not found?

Spring Boot

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.Optional;

@RestController
@RequestMapping("/users")
public class UserController {

    private final UserRepository userRepository;

    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        Optional<User> user = userRepository.findById(id);
        if (user.isPresent()) {
            return ResponseEntity.ok(user.get());
        } else {
            return ResponseEntity.notFound().build();
        }
    }
}

A HTTP 200 OK with user data if found, HTTP 404 Not Found if user missing

B HTTP 500 Internal Server Error if user missing

C HTTP 204 No Content if user missing

D HTTP 400 Bad Request if user missing

💡 Hint

Look at the ResponseEntity methods used for the missing user case.

The method returns ResponseEntity.notFound().build() when the user is not found, which corresponds to HTTP 404 Not Found status. If the user is found, it returns HTTP 200 OK with the user data.

❓ state_output

intermediate

What is the value of the transaction status after this Spring Boot service method runs?

Given this service method annotated with @Transactional, what will be the transaction status after the method completes successfully?

Spring Boot

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    @Transactional
    public void placeOrder(Order order) {
        // save order to database
        // update inventory
        // send confirmation
    }
}

A Transaction is rolled back

B Transaction is left open and active

C Transaction is committed and closed

D Transaction status is unknown

💡 Hint

What does @Transactional do when no exceptions occur?

The @Transactional annotation starts a transaction at method start and commits it if the method completes without exceptions. So the transaction is committed and closed after the method finishes.

🔧 Debug

advanced

Why does this Spring Boot application fail to connect to the database?

This Spring Boot app throws a connection error at startup. What is the most likely cause?

Spring Boot

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

A Username and password are incorrect

B Driver class name is outdated; should be com.mysql.cj.jdbc.Driver

C Database URL is missing the port number

D Datasource URL should start with jdbc:postgresql://

💡 Hint

Check the driver class name for MySQL Connector/J 8+

The driver class name com.mysql.jdbc.Driver is deprecated in newer MySQL drivers. The correct driver class name is com.mysql.cj.jdbc.Driver. Using the old name causes connection failure.

📝 Syntax

advanced

Which option correctly defines a Spring Data JPA repository interface?

You want to create a repository interface for the entity Product with Long as ID type. Which option is syntactically correct?

A public interface ProductRepository extends JpaRepository<Product, Long> {}

B public class ProductRepository implements JpaRepository<Product, Long> {}

C public interface ProductRepository extends Repository<Product> {}

D public interface ProductRepository extends JpaRepository<Product> {}

💡 Hint

JpaRepository requires two generic parameters: entity and ID type.

JpaRepository is an interface and must be extended, not implemented. It requires two generic parameters: the entity class and the ID type. Option A correctly follows this pattern.

🧠 Conceptual

expert

What happens if a Spring Boot @Transactional method calls another @Transactional method in the same class?

Consider a Spring Boot service class where a public @Transactional method calls another public @Transactional method within the same class. What is the behavior of the transaction management in this case?

A An exception is thrown due to nested @Transactional calls

B Both methods run in separate transactions

C The inner method starts a new nested transaction automatically

D The inner @Transactional method runs without a transaction because Spring proxies are bypassed

💡 Hint

Think about how Spring AOP proxies work for self-invocation.

Spring uses proxies for @Transactional. When a method in the same class calls another method, the call does not go through the proxy, so the inner method's @Transactional annotation is ignored and runs without a transaction.