Spring Boot MCQ Questions – Page 42 of 49

Q: Which of the following is NOT a common use case for `ResponseEntity` in a Spring Boot application?

C) Handling database transactions and ensuring data consistency.. `ResponseEntity` is concerned with HTTP response construction, not with database transaction management. Transaction handling is typically managed by services and `@Transactional` annotations.

Q: What error will occur when Spring Boot tries to initialize the following component?

A) java.lang.IllegalArgumentException: Cannot convert value of type 'java.lang.String' to required type 'boolean'. In SpEL, the `+` operator performs string concatenation when applied to strings. Thus, `'true' + 'false'` evaluates to the string `"truefalse"`. Spring then attempts to convert this string to a `boolean`, which it cannot do, resulting in an `IllegalArgumentException`.

Q: In the `@RequestMapping("/products/{id}")` annotation, what does `{id}` represent?

C) A path variable that will be extracted from the URL. The `{id}` syntax within `@RequestMapping` denotes a URI template variable, which allows a portion of the URI to be treated as a variable and captured by a method parameter using `@PathVariable`.

Q: What will be the outcome when running this Spring Boot application?

B) org.springframework.beans.factory.NoSuchBeanDefinitionException. The `@Bean("mysqlStore")` annotation explicitly names the bean "mysqlStore". The `@Qualifier("databaseStore")` on the `DataManager` attempts to inject a bean named "databaseStore" (the method name), which does not exist in the context, resulting in a `NoSuchBeanDefinitionException`.

Q: Given `application.properties` contains `app.name=WebApp` and the following Java code, what does it print?

A) Application: WEBAPP. The @Value annotation can combine property placeholders (${...}) and SpEL expressions (#{...}). The '${app.name}' placeholder is resolved first to 'WebApp', then the SpEL `toUpperCase()` function is applied, and finally string concatenation occurs.

Q: Consider the Spring Boot application above. If it's packaged as `myapp.jar` and executed from the command line as `java -jar myapp.jar --app.message='Hello JAR!'`, what will be the output from the `CommandLineRunner`?

A) App Message: Hello JAR!. Command-line arguments have the highest precedence in Spring Boot's externalized configuration, overriding any default values provided in `@Value` annotations or other property sources.

Q: What is the primary function of a `ViewResolver` in Spring MVC?

C) To resolve a logical view name returned by a controller into a concrete view implementation.. A `ViewResolver` component takes a logical view name (e.g., 'home') and determines which specific view technology (e.g., a Thymeleaf template, a JSP file) should be used to render the response.

Q: What kind of error will occur when Spring Boot tries to start an application containing these two services?

B) A `BeanCurrentlyInCreationException` or `UnsatisfiedDependencyException` during application context initialization.. Constructor injection creates a strict dependency chain. When `ServiceA` requires `ServiceB` in its constructor, and `ServiceB` simultaneously requires `ServiceA`, Spring cannot resolve the creation order, leading to a circular dependency error during context initialization.

Q: What is the primary role of the `@Repository` annotation in a Spring Boot application?

A) To indicate that a class is a component in the data access layer and to enable automatic persistence exception translation.. `@Repository` marks a class as a DAO/repository component and specifically enables Spring's exception translation mechanism for persistence operations within that component.

Q: Consider the `User` DTO and controller method below. What error occurs if a client sends a POST request with `{"email": "test@example.com"}` and `Content-Type: application/json`?

A) org.springframework.web.bind.MethodArgumentNotValidException: Validation failed for argument [0]... Field error in object 'user' on field 'username': rejected value [null]. The `@Valid` annotation triggers validation on the `User` object. Since the `username` field is annotated with `@NotBlank` but is missing (or null) in the request body, validation fails, leading to a `MethodArgumentNotValidException`.

Q821 medium

Which of the following is NOT a common use case for `ResponseEntity` in a Spring Boot application?

Q822 medium code error

What error will occur when Spring Boot tries to initialize the following component?

java

java
@Component
public class ToggleSwitch {
    @Value("#{'true' + 'false'}")
    private boolean enabled;

    public boolean isEnabled() {
        return enabled;
    }
}

Q823 medium

In the `@RequestMapping("/products/{id}")` annotation, what does `{id}` represent?

Q824 medium code error

What will be the outcome when running this Spring Boot application?

java

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

public class DataStore {
    private String type;
    public DataStore(String type) { this.type = type; }
    public String getType() { return type; }
}

@Configuration
public class StoreConfig {
    @Bean("mysqlStore")
    public DataStore databaseStore() { // Bean named "mysqlStore"
        return new DataStore("MySQL");
    }
}

@Component
public class DataManager {
    @Autowired
    @Qualifier("databaseStore") // Tries to use the method name as qualifier, but bean has explicit name
    private DataStore store;

    public void printStoreType() {
        System.out.println(store.getType());
    }
}

Q825 medium code output

Given `application.properties` contains `app.name=WebApp` and the following Java code, what does it print?

java

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class AppInfoService {
    @Value("#{'Application: ' + '${app.name}'.toUpperCase()}")
    private String info;

    public String getInfo() {
        return info;
    }
}
// In a Spring Boot application, if this component is scanned:
// AppInfoService service = applicationContext.getBean(AppInfoService.class);
// System.out.println(service.getInfo());

Q826 medium code output

Consider the Spring Boot application above. If it's packaged as `myapp.jar` and executed from the command line as `java -jar myapp.jar --app.message='Hello JAR!'`, what will be the output from the `CommandLineRunner`?

java

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class MyApplication {

    @Value("${app.message:Default Message}")
    private String appMessage;

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }

    @Bean
    public CommandLineRunner runner() {
        return args -> {
            System.out.println("App Message: " + appMessage);
        };
    }
}

Q827 medium

What is the primary function of a `ViewResolver` in Spring MVC?

Q828 medium code error

What kind of error will occur when Spring Boot tries to start an application containing these two services?

java

import org.springframework.stereotype.Service;

@Service
public class ServiceA {
    private ServiceB serviceB;
    public ServiceA(ServiceB serviceB) { this.serviceB = serviceB; }
    public String getMessage() { return "From A"; }
}

@Service
public class ServiceB {
    private ServiceA serviceA;
    public ServiceB(ServiceA serviceA) { this.serviceA = serviceA; }
    public String getMessageFromB() { return "From B"; }
}

Q829 medium

What is the primary role of the `@Repository` annotation in a Spring Boot application?

Q830 medium code error

Consider the `User` DTO and controller method below. What error occurs if a client sends a POST request with `{"email": "test@example.com"}` and `Content-Type: application/json`?

java

package com.example.demo;
import jakarta.validation.constraints.NotBlank;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import jakarta.validation.Valid;

public class User {
    @NotBlank
    private String username;
    private String email;
    // Getters and Setters, default constructor
}

@RestController
public class UserController {
    @PostMapping("/users")
    public ResponseEntity<String> createUser(@Valid @RequestBody User user) {
        return ResponseEntity.ok("User created.");
    }
}

Q831 medium code error

A client sends a POST request to `/items` with `Content-Type: application/json` and a malformed JSON body `{"name": "Test", "value": }`. What error will the following controller method produce?

java

package com.example.demo;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;

@RestController
public class ItemController {
    @PostMapping("/items")
    public ResponseEntity<String> createItem(@RequestBody Item item) {
        return ResponseEntity.ok("Item created.");
    }
}
// Item class has default constructor, private String name; private int value;

Q832 medium code output

Given the `ValueDto` and controller below, what is the expected outcome if a POST request body is `{"num": "twenty"}` (string instead of integer)?

java

import org.springframework.web.bind.annotation.*;
import lombok.Data;

@Data
class ValueDto {
    private int num;
}

@RestController
@RequestMapping("/values")
public class ValueController {

    @PostMapping
    public String processValue(@RequestBody ValueDto valueDto) {
        return "Processed num: " + valueDto.getNum();
    }
}

Q833 medium

By default, when using `@RequestBody` in a Spring Boot controller method, is the HTTP request body considered optional or required?

Q834 medium code output

If a request is made to `/start`, what will be printed to the console when the `/next` endpoint is subsequently processed due to the redirect?

java

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.ui.Model;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

@Controller
public class FirstController {

    @GetMapping("/start")
    public String startProcess(Model model) {
        model.addAttribute("tempMessage", "This should not pass.");
        return "redirect:/next";
    }

    @GetMapping("/next")
    public String nextPage(Model model) {
        System.out.println("Model attributes in /next: " + model.asMap().keySet());
        return "nextView";
    }
}

Q835 medium code error

Consider the following Spring Boot controller method. What error will be thrown if a form submission to `/saveUser` includes validation errors?

java

import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.ModelAttribute;

@Controller
public class UserController {
    @PostMapping("/saveUser")
    public String saveUser(BindingResult result, @Validated @ModelAttribute UserForm userForm) {
        if (result.hasErrors()) {
            return "userForm";
        }
        return "success";
    }
}

Q836 medium code error

Given the `Item` class with `private int quantity;`, a client sends `Content-Type: application/json` and body `{"name": "Book", "quantity": "ten"}` to the `/items` endpoint. What error occurs?

java

package com.example.demo;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;

@RestController
public class ItemController {
    @PostMapping("/items")
    public ResponseEntity<String> createItem(@RequestBody Item item) {
        return ResponseEntity.ok("Item created: " + item.getName());
    }
}
// Item class has default constructor, private String name; private int quantity;

Q837 medium code error

What will be the outcome when running this Spring Boot application?

java

public interface Converter {
    String convert(String input);
}

public class MyConverter implements Converter { // No Spring annotation
    @Override
    public String convert(String input) {
        return "Converted: " + input.toUpperCase();
    }
}

@Component
public class DataImporter {
    @Autowired
    @Qualifier("myConverter") // Trying to inject non-Spring managed bean
    private Converter converter;

    public void importData(String data) {
        System.out.println(converter.convert(data));
    }
}

Q838 medium

By default, how does Spring resolve dependencies when using `@Autowired`?

Q839 medium code error

A client sends a POST request to `/api/data` with a valid JSON body. However, the `MyData` class lacks a default constructor. What error will occur during the deserialization of the request body?

java

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class DataController {
    @PostMapping("/data")
    public String processData(@RequestBody MyData data) {
        return "Processed: " + data.getValue();
    }
}

class MyData {
    private String value;
    public MyData(String value) { this.value = value; }
    public String getValue() { return value; }
    public void setValue(String value) { this.value = value; }
}

Q840 medium code error

If a client sends a PUT request to `/api/config/name` with a JSON body `{"value": "new_value"}`, what kind of error will occur during deserialization of `ConfigItem`?

java

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/config")
public class ConfigController {

    @PutMapping("/{key}")
    public ResponseEntity<ConfigItem> updateConfig(@PathVariable String key, @RequestBody ConfigItem configItem) {
        // Logic to update config item
        return ResponseEntity.ok(configItem);
    }
}

class ConfigItem {
    private final String value; // Problematic field
    public String getKey() { return "example"; }
    public String getValue() { return value; }
}

🌱 Spring Boot MCQ Questions – Page 42