2V0-72.22 Sample Questions Answers

Spring Data MongoDB https://spring.io/projects/spring-data-mongodb . Spring Data Neo4j https://spring.io/projects/spring-data-neo4j Spring Data Redis https://spring.io/projects/spring-data-redis

For example: Spring Data Envers

Optional findById(ID primaryKey);

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.

When using Spring transaction management with annotation-driven mode, the @Transactional annotation will be processed by a TransactionInterceptor that implements the AOP advice interface. This interceptor will be applied to the target bean through a proxy that implements the same interface as the target bean. Therefore, when a method of the target bean is called from outside, it will actually invoke the proxy method, which will delegate to the interceptor and then to the actual target method.

However, when a method of the target bean is called from within the same bean, it will not go through the proxy and thus bypass the interceptor logic. In this case, when update1() calls update2(), it will not start a new transaction as specified by REQUIRES_NEW propagation level, but rather join the existing transaction initiated by update1() itself.

This is true because the default scope of a bean in Spring is singleton, which means that only one instance of the bean will be created and shared by the entire application context. The @Bean annotation on the accountRepository() method indicates that this method will return a bean that will be managed by Spring. However, this method will not be called every time the bean is needed, but only once when the bean is first created. Therefore, only one AccountRepository bean will be instantiated and injected into the TransferService and AccountService beans.

Spring Security provides a fluent API for configuring web security based on URL patterns and request matchers. The authorizeRequests() method returns an expression that allows specifying access rules for different URLs using methods such as antMatchers(), regexMatchers(), mvcMatchers(), etc. The order of these rules matters, as they are evaluated from top to bottom. Therefore, it is recommended to put the most specific rules first and the least specific ones last.

A web slice test is a type of test in Spring Boot that focuses on testing only the web layer of an application, without starting a full server or requiring a real database. To isolate the web layer from other dependencies, such as services or repositories, mocks can be used to simulate their behavior and return predefined responses. To create and inject a mock for an existing bean in the application context, the @MockBean annotation can be used on a field or a parameter in the test class. This annotation will replace any existing bean of the same type with a mock created by Mockito.

Constructor injection is one of the ways to inject dependencies into a bean using its constructor parameters. Since Spring 4.3, if a bean has only one constructor, the @Autowired annotation can be omitted and Spring will use that constructor by default.

Constructor injection is generally recommended over field injection because it makes the dependencies of a bean explicit and immutable. It also facilitates unit testing because it allows us to easily provide mock dependencies through constructor arguments.

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.

Transactions are units of work that ensure data consistency and integrity by enforcing atomicity, consistency, isolation, and durability (ACID) properties. Spring provides an abstraction layer for transaction management that supports various transaction APIs such as JDBC, JPA, Hibernate, etc. To use transactions in Spring, we need to do two things:

Enable transaction management by adding @EnableTransactionManagement annotation to a Java configuration class or tx:annotation-driven/ element to an XML configuration file.

Declare transactional boundaries by annotating a class, an interface, or individual methods with the @Transactional annotation. This annotation indicates that the execution of the annotated element should be wrapped in a transaction.

B. Custom BeanPostProcessors can be implemented for Spring applications.

This is true because the BeanPostProcessor interface defines callback methods that you can implement to provide your own (or override the container’s default) instantiation logic, dependency resolution logic, and so forth1. You can configure multiple BeanPostProcessor instances, and you can control the order in which these BeanPostProcessor instances run by setting the order property1. For example, in this tutorial, a custom BeanPostProcessor is implemented to integrate Guava’s EventBus with Spring beans.

D. BeanPostProcessors are called during the initialization phase of a bean life cycle.

This is true because the BeanPostProcessor interface consists of exactly two callback methods: postProcessBeforeInitialization and postProcessAfterInitialization. When such a class is registered as a post-processor with the container, for each bean instance that is created by the container, the post-processor gets a callback from the container both before container initialization methods (such as InitializingBean.afterPropertiesSet() or any declared init method) are called, and after any bean initialization callbacks1.

Spring Security is a framework that provides comprehensive security services for Java applications, such as authentication, authorization, encryption, session management, and more. One of its features is method security, which allows applying access control rules at the method level using annotations or XML configuration. Another feature is authentication, which is the process of verifying the identity of a user or a system. Spring Security supports various authentication mechanisms, such as username and password, tokens, certificates, etc., and can access authentication data from different sources, such as databases, LDAP directories, in-memory stores, etc.

The @Autowired annotation can be used to inject a dependency into a field, a constructor, or a setter method. However, if there are multiple beans of the same type in the application context, Spring will not be able to determine which one to inject by default. To resolve this ambiguity, we can use the @Qualifier annotation to specify the bean id of the desired dependency. Alternatively, we can use the bean id as the name of the field or the parameter of the setter method, and Spring will match it with the corresponding bean.

A. Allow access to a method based on user identity.

This is true because the @PreAuthorize annotation can use the principal object to access the user identity and check if it matches a certain condition. For example, we can use the following expression to allow access only to the user with the username “admin”:

@PreAuthorize(“principal.username == ‘admin’”)

E. Allow access to a method based on roles.

This is true because the @PreAuthorize annotation can use the hasRole, hasAnyRole, or hasAuthority methods to check if the user has a certain role or authority. For example, we can use the following expression to allow access only to users who have the role “ADMIN” or “USER”:

@PreAuthorize(“hasAnyRole(‘ADMIN’, ‘USER’)”)