Answer : B
Explanation: @Value injects externalized configuration into Spring beans: Basic usage: @Value(“${app.name}”) private String appName; — injects from application.properties: app.name=MyApplication. Default value: @Value(“${app.timeout:30}”) private int timeout; — uses 30 if property not found. Environment variables: @Value(“${JAVA_HOME}”) private String javaHome; — system environment variable. Spring Expression Language (SpEL): @Value(“#{systemProperties[‘user.name’]}”) private String username; — powerful dynamic expressions. @Value(“#{T(java.lang.Math).PI}”) private double pi; — static method call. Injecting lists: @Value(“${app.servers}”) private List<String> servers; — app.servers=server1,server2,server3. Type Conversion: @Value automatically converts String properties to int, boolean, List, etc. @ConfigurationProperties alternative: @ConfigurationProperties(prefix = “app”) class AppConfig { private String name; private int timeout; } — groups related properties, supports validation with @Validated, preferred for complex configuration objects. Spring Boot application.properties → application.yml: yaml format supports hierarchical structure natively. Profile-specific: application-dev.properties, application-prod.properties — activated by spring.profiles.active=dev. @Value with @ConfigurationProperties is the foundation of The Twelve-Factor App methodology’s “Store config in the environment” principle.

Answer : B
Explanation: @SpringBootApplication is the cornerstone annotation of every Spring Boot application. It is composed of: @Configuration: marks the class as a source of Spring bean definitions. Methods annotated with @Bean define beans. @EnableAutoConfiguration: enables Spring Boot’s auto-configuration mechanism. Tells Spring Boot to automatically configure beans based on classpath. @ComponentScan: enables component scanning from the package of the annotated class and all sub-packages. Picks up @Component, @Service, @Repository, @Controller annotated classes automatically. The main method: @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }. SpringApplication.run() starts the embedded server, creates the Spring ApplicationContext, triggers auto-configuration. Customizing @SpringBootApplication: @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class}) — exclude specific auto-configurations. @SpringBootApplication(scanBasePackages = “com.example”) — customize scan base. Common mistake: placing @SpringBootApplication in the wrong package causes components to not be discovered. The annotated class’s package becomes the root of component scanning — all application code should be in sub-packages of this root package.

Answer : B
Explanation: application.properties (or application.yml) is the central configuration hub in Spring Boot. Common properties: Server: server.port=8080, server.servlet.context-path=/api. Database (JDBC): spring.datasource.url=jdbc:mysql://localhost:3306/mydb, spring.datasource.username=root, spring.datasource.password=secret, spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver. JPA/Hibernate: spring.jpa.hibernate.ddl-auto=update (create, create-drop, validate, update, none), spring.jpa.show-sql=true, spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect. Logging: logging.level.org.springframework=INFO, logging.level.com.example=DEBUG, logging.file.name=app.log. Spring Boot specific: spring.application.name=my-service, spring.profiles.active=dev. Custom: app.jwt.secret=mySecret, app.jwt.expiration=86400. YAML alternative (application.yml): hierarchical format, same properties but with indentation. Profiles: application-dev.properties, application-prod.properties, application-test.properties — loaded based on active profile. Environment variable override: SPRING_DATASOURCE_URL=jdbc:mysql://prod-server/db — can override any property. The 12-Factor App: config should be in environment, not code — Spring Boot’s externalized configuration implements this principle.

Answer : B
Explanation: Microservices decompose a monolithic application into independently deployable services. Spring Cloud provides the microservices ecosystem: Service Discovery: Spring Cloud Netflix Eureka — services register themselves and discover others by name. Load Balancing: Spring Cloud LoadBalancer (replaced Ribbon) — distributes requests across service instances. API Gateway: Spring Cloud Gateway — single entry point, routing, rate limiting, authentication. Config Server: Spring Cloud Config — centralized configuration for all services. Circuit Breaker: Resilience4j — prevents cascade failures when a service is down. Distributed Tracing: Spring Cloud Sleuth + Zipkin — trace requests across services. Feign Client: declarative HTTP client for calling other microservices: @FeignClient(name=”user-service”) interface UserClient { @GetMapping(“/users/{id}”) User getUser(@PathVariable Long id); }. Communication: Synchronous: REST (HTTP) using RestTemplate or WebClient. Asynchronous: Message queues (Apache Kafka, RabbitMQ via Spring AMQP). Each microservice: independent database, independent deployment, independent scaling, can use different technology stack. Docker + Kubernetes: containerize each Spring Boot microservice, Kubernetes manages deployment and scaling. Challenges: network latency, distributed transactions, service discovery, monitoring complexity. Use microservices when the monolith becomes unmanageable — don’t start with microservices.

Answer : B
Explanation: HTTP method-specific mapping annotations (introduced Spring 4.3) are shorthand for @RequestMapping: @GetMapping(“/users”): retrieves resources. Safe, idempotent. Returns list of users or single user. No request body. @PostMapping(“/users”): creates a new resource. Not idempotent (calling twice creates two resources). Request body contains new resource data. Returns 201 Created + Location header. @PutMapping(“/users/{id}”): updates/replaces a resource completely. Idempotent (calling multiple times has same effect). Request body contains complete updated resource. @PatchMapping(“/users/{id}”): partial update of a resource. Only send changed fields in request body. @DeleteMapping(“/users/{id}”): deletes a resource. Idempotent. Returns 204 No Content. REST API conventions: GET /users — list all users. GET /users/1 — get user with id=1. POST /users — create new user. PUT /users/1 — update user 1. DELETE /users/1 — delete user 1. Additional options: consumes: @PostMapping(value=”/users”, consumes=”application/json”) — only accept JSON. produces: @GetMapping(value=”/users”, produces=”application/json”) — only return JSON. These annotations make REST controller code self-documenting and aligned with HTTP semantics.

Answer : B
Explanation: ResponseEntity<T> wraps the full HTTP response: return value, status code, and headers. Without ResponseEntity: return user; — Spring returns 200 OK with user as JSON (fine for simple cases). With ResponseEntity: return ResponseEntity.ok(user); — explicitly returns 200 OK with user. return ResponseEntity.created(location).body(savedUser); — 201 Created with Location header. return ResponseEntity.noContent().build(); — 204 No Content (successful delete). return ResponseEntity.notFound().build(); — 404 Not Found. return ResponseEntity.badRequest().body(errorDetails); — 400 with error body. return ResponseEntity.status(HttpStatus.CONFLICT).body(message); — any custom status. Custom headers: return ResponseEntity.ok().header(“X-Custom-Header”, “value”).body(data); Why use ResponseEntity: precise HTTP status codes (201 vs 200 for creation). Add response headers. Return different body types based on success/failure. Build RESTful APIs that follow HTTP conventions. Common patterns: @GetMapping(“/{id}”) public ResponseEntity<User> getUser(@PathVariable Long id) { return userService.findById(id).map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build()); }. @ControllerAdvice with @ExceptionHandler is the alternative for centralized exception-to-response mapping — keeps controllers clean.

Answer : B
Explanation: Apache Tomcat is the most widely used Java web server/servlet container. Key roles: Servlet Container: manages servlet lifecycle (init/service/destroy). Processes HTTP requests and dispatches to the correct servlet. Web Server: serves static content (HTML, CSS, JS, images). JSP Engine: compiles JSP files to servlets. HTTP Connector: listens on port 8080 (default), handles TCP connections. Tomcat components: Catalina — servlet container core. Coyote — HTTP connector (processes HTTP/1.1 and HTTP/2). Jasper — JSP engine. Deployment: Traditional: deploy WAR file to Tomcat’s webapps directory. Spring Boot: embeds Tomcat inside the JAR. No external Tomcat installation needed! java -jar myapp.jar — Tomcat starts automatically on port 8080. Changing embedded server port: server.port=9090 in application.properties. Switching embedded servers: replace spring-boot-starter-web (Tomcat) with spring-boot-starter-jetty or spring-boot-starter-undertow. Tomcat architecture: one JVM process handles all requests using thread pool. Each request runs in a separate thread (from the thread pool). Thread pool settings: server.tomcat.threads.max=200 (default). Compared to web servers: Tomcat handles Java web apps. Nginx/Apache used as reverse proxies in production, handling SSL termination, load balancing, serving static files, proxying requests to Tomcat.

Answer : B
Explanation: Lombok reduces Java’s notorious verbosity. Key Lombok annotations: @Getter / @Setter: generates getter/setter for all or specific fields. @ToString: generates toString() method including all/specified fields. @EqualsAndHashCode: generates equals() and hashCode() based on fields. @NoArgsConstructor: generates no-argument constructor. @AllArgsConstructor: generates constructor with all fields. @RequiredArgsConstructor: generates constructor for final fields and @NonNull fields. @Data: combines @Getter, @Setter, @ToString, @EqualsAndHashCode, @RequiredArgsConstructor. @Builder: generates builder pattern — User.builder().name(“John”).age(30).build(). @Slf4j: injects a Logger field — private static final Logger log = LoggerFactory.getLogger(this.getClass()). @Value: immutable class (all fields private final, no setters). @NonNull: generates null check in constructor/setter. Before Lombok: 50+ lines of boilerplate for a simple entity class. With @Data: 5 lines. Caution with JPA entities: @Data generates hashCode() based on all fields — problematic for JPA entities with collections or lazy-loaded fields. Use @Getter, @Setter, @ToString separately for JPA entities. Controversy: some teams avoid Lombok because generated code is invisible in IDE — can make debugging harder. Alternatives: Java 14+ Records for immutable data classes (no setters but clean syntax).

Answer : B
Explanation: Jackson (com.fasterxml.jackson) is the JSON processing library automatically included via spring-boot-starter-web. Two directions: Serialization: Java Object → JSON String. User object with name=”John”, age=30 → {“name”:”John”,”age”:30}. Deserialization: JSON String → Java Object. {“name”:”John”,”age”:30} → User object. Key Jackson annotations: @JsonProperty(“user_name”): map Java field to different JSON key. @JsonIgnore: exclude field from JSON. @JsonInclude(Include.NON_NULL): don’t include null fields. @JsonSerialize/@JsonDeserialize: custom serialization logic. @JsonFormat(pattern=”yyyy-MM-dd”): format dates. @JsonAlias: accept multiple input JSON key names. ObjectMapper: Spring Boot auto-configures a shared ObjectMapper bean. Customization: @Bean public ObjectMapper objectMapper() { return new ObjectMapper().configure(…); } or via spring.jackson.* properties. Date handling: spring.jackson.serialization.write-dates-as-timestamps=false — output dates as ISO strings. spring.jackson.date-format=yyyy-MM-dd. DTOs (Data Transfer Objects): best practice — expose DTOs (not entities) in APIs. Avoids exposing internal data model, enables API versioning, prevents lazy loading issues. Jackson with @RestController: Spring Boot automatically applies Jackson serialization to all @ResponseBody return values. Content negotiation: produces=”application/json” ensures JSON output.

Answer : B
Explanation: Two ways to register Spring beans: @Component (and @Service, @Repository, @Controller): you annotate YOUR class. Spring discovers it via classpath scanning (@ComponentScan). Works only when you own/can modify the class. Example: @Service public class EmailService { … }. @Bean inside @Configuration: you write a method that creates and returns thebean. Used for third-party library classes you cannot annotate (e.g., Jackson’s ObjectMapper, RestTemplate, DataSource). Also used when you need conditional logic during bean creation. Example: @Configuration public class AppConfig { @Bean public RestTemplate restTemplate() { return new RestTemplate(); } @Bean public ObjectMapper objectMapper() { return new ObjectMapper().configure(SerializationFeature.INDENT_OUTPUT, true); } }. When to use @Bean: configuring third-party libraries, applying conditional logic during instantiation, creating multiple instances of the same class with different configurations. Bean scope: @Scope(“singleton”) — default, one instance per context. @Scope(“prototype”) — new instance every time. @Scope(“request”) — one per HTTP request. @Scope(“session”) — one per HTTP session. Naming: @Component class name becomes bean name (camelCase). @Bean method name becomes bean name. Both are registered in the same ApplicationContext and can be @Autowired anywhere.