2V0-72.22 Questions and Answers

https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/crypto/password/DelegatingPasswordEncoder.html

C. Dependencies between application components can be managed external to the components.

This is true because dependency injection allows the application components to declare their dependencies without creating or obtaining them directly. Instead, the dependencies are provided by an external entity, such as the Spring container, which can read the configuration from XML files, annotations, or Java code1.

D. Configuration can be externalized and centralized in a small set of files.

This is true because dependency injection enables the separation of concerns between the application logic and the configuration. The configuration can be stored in a small number of files that can be easily changed without affecting the source code2.

F. Dependency injection facilitates loose coupling between components.

This is true because dependency injection reduces the direct dependencies between components, making them more reusable and testable. It also allows for easier substitution of different implementations of the same interface3.

http://effcode.com/spring/returning-no-content-204-from-spring-controller/

Custom metrics can be measured using Meter primitives such as Counter, Gauge, Timer, and DistributionSummary: Spring Boot Actuator Metrics allows you to define and measure custom metrics using various Meter primitives. These primitives include Counter (counting occurrences), Gauge (providing a current value), Timer (measuring the time taken for a task), and DistributionSummary (collecting and summarizing distribution statistics).

B. The classes are eligible for handling requests in Spring MVC.

This is true because the @Controller annotation marks a class as a web request handler, and it is typically used with the @RequestMapping annotation to map specific URLs to methods1. The @Controller annotation also allows the class to be recognized as a Spring-managed component through the classpath scanning2.

E. The @Controller annotation is a stereotype annotation like @Component.

This is true because the @Controller annotation is a specialization of the generic stereotype @Component annotation, which allows a class to be recognized as a Spring-managed component3. The @Controller annotation extends the use-case of @Component and marks the annotated class as a business or presentation layer4.

This is true because the id/name of a bean declared by the @Bean annotation is derived from the name of the method that returns the bean. In this case, the method name is clientService, so the bean name will be clientService as well. By default, Spring uses a lower-case first letter for bean names, unless explicitly specified otherwise by using the name attribute of the @Bean annotation. For example, we can use @Bean(name = “ClientService”) to change the bean name to ClientService (starting with uppercase “C”).

B. A HelloService bean will be created from the helloService() method only when there is no other HelloService bean in the ApplicationContext.

This is true because the @ConditionalOnMissingBean annotation on the helloService() method indicates that this method will only be invoked to create a HelloService bean if there is no existing HelloService bean in the application context. This is a common way to provide a default bean that can be overridden by the user’s own bean definition.

D. This auto-configuration class is used only when the HelloService.class is on the classpath.

This is true because the @ConditionalOnClass annotation on the HelloAutoConfig class indicates that this class will only be loaded and processed by Spring Boot if the HelloService.class is present on the classpath. This is a common way to enable auto-configuration for a specific library or feature only when it is available.

A. Locale

This is true because the Locale argument can be used to resolve the current locale that the client is using, based on the Accept-Language header or a cookie1.

B. Principal

This is true because the Principal argument can be used to access the currently authenticated user, if any1.

F. HttpSession

This is true because the HttpSession argument can be used to access the current session, if any1. Note that this argument is not required and will be null if a session does not exist.

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/annotation/Autowired.html

B. Multiple arguments can be injected into a single method using @Autowired.

This is true because the @Autowired annotation can be applied to methods with arbitrary names and multiple arguments, as shown in the example in Using @Autowired.

C. By default, if a dependency cannot be satisfied with @Autowired, Spring throws a RuntimeException.

This is true because the @Autowired annotation has a required attribute that is true by default, meaning that the dependency is mandatory. If Spring cannot find a matching bean to inject, it will throw a BeanCreationException, which is a subclass of RuntimeException. To avoid this exception, we can set the required attribute to false, which will allow Spring to skip the injection if no matching bean is found

Spring Security uses a filter-based architecture to provide security services for web applications. A filter is an object that intercepts HTTP requests and responses and performs some logic before or after the request is processed by the servlet. Spring Security provides a number of filters for different purposes, such as:

Authentication: Filters that handle the authentication process, such as UsernamePasswordAuthenticationFilter, BasicAuthenticationFilter, RememberMeAuthenticationFilter, etc.

User management: Filters that manage the user details and roles, such as SecurityContextPersistenceFilter, AnonymousAuthenticationFilter, ConcurrentSessionFilter, etc.

Logout: Filters that handle the logout process, such as LogoutFilter and SecurityContextLogoutHandler.

Authorization: Filters that enforce access control rules based on the user’s authentication and roles, such as FilterSecurityInterceptor, ExceptionTranslationFilter, etc.

B. Spring provides a Dependency Injection container. True. One of the core features of Spring is its powerful Dependency Injection (DI) container, which helps manage the lifecycle and dependencies of the application’s components. E. Spring provides abstractions over infrastructure such as persistence and messaging. True. Spring provides a range of abstractions over various infrastructure concerns, such as persistence (with Spring Data and JPA), messaging (with Spring JMS and Spring AMQP), transaction management, and more. These abstractions simplify and unify the way developers interact with these systems.

(1) BeanFactoryPostProcessor (Spring Framework 6.1.3 API). https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/config/BeanFactoryPostProcessor.html. (2) Spring BeanPostProcessor | Baeldung. https://www.baeldung.com/spring-beanpostprocessor. (3) BeanFactoryPostProcessor - Spring | Home. https://docs.spring.io/spring-framework/docs/3.0.x/javadoc-api/org/springframework/beans/factory/config/BeanFactoryPostProcessor.html. (4) BeanFactoryPostProcessor (Spring Framework API 2.5). https://docs.spring.io/spring-framework/docs/2.5.x/javadoc-api/org/springframework/beans/factory/config/BeanFactoryPostProcessor.html. (5) Spring BeanPostProcessor Example - HowToDoInJava. https://howtodoinjava.com/spring-core/spring-bean-post-processors/

A. @Configuration This annotation indicates that the class has @Bean definition methods and may be processed by the Spring container to generate bean definitions and service requests for those beans at runtime. B. @ComponentScan This annotation configures component scanning directives for use with @Configuration classes. Provides support parallel with Spring XML's context:component-scan element.