2V0-72.22 Practice Exam Questions with Answers Professional Develop VMware Spring Certification

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.

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.

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’)”)

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/aop/AfterReturningAdvice.html

A bean definition profile is a named logical grouping of bean definitions that can be activated or deactivated in different environments. For example, we can define different profiles for development, testing, and production environments. Spring provides the @Profile annotation to mark a bean definition or a configuration class as belonging to a specific profile. To activate a profile, we can use the spring.profiles.active property or the ConfigurableEnvironment.setActiveProfiles() method.

The @ActiveProfiles annotation is a class-level annotation that is used in conjunction with the Spring TestContext Framework to declare which profiles should be active when loading an ApplicationContext for an integration test. This annotation can be applied to any class annotated with @ContextConfiguration or a meta-annotation that is composed of @ContextConfiguration.

B. If an embedded database is on the classpath, it will be used to configure a DataSource by default.

This is true because the @DataJpaTest annotation enables auto-configuration of an embedded database if one is available on the classpath, such as H2, HSQLDB, or Derby. This allows the test to run with a temporary and isolated database that can be configured with test data.

D. It auto-configures a TestEntityManager bean.

This is true because the @DataJpaTest annotation provides a TestEntityManager bean that can be used to perform common JPA operations in the test. The TestEntityManager is an alternative to the standard EntityManager that provides some convenience methods and exception translation.

https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#features.external-config.typesafe-configuration-properties.vs-value-annotation

A Spring Boot starter dependency is a special type of dependency that provides a convenient way to add multiple, coordinated dependencies related to a specific technology or feature, such as web, JDBC, security, etc. A starter dependency usually has a name that starts with spring-boot-starter- followed by the name of the technology or feature. For example, spring-boot-starter-web is a starter dependency that includes all the dependencies needed for creating web applications with Spring MVC and RESTful services.

https://www.baeldung.com/spring-getbean#3-retrieving-bean-by-type

https://www.diffblue.com/blog/java/software%20development/testing/spring-boot-test-slices-overview-and-usage/

Spring Boot provides a convenient way to create Spring MVC applications with minimal configuration. By default, it uses Tomcat as the embedded servlet container, but it also supports other containers such as Jetty and Undertow. To use a different container, we just need to exclude the spring-boot-starter-tomcat dependency and include the corresponding starter for the desired container. For example, to use Undertow, we can add the following dependencies in our pom.xml:

org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter-tomcat org.springframework.boot spring-boot-starter-undertow

Spring and Spring Boot provide various annotations and utilities to support testing of different layers of the application. To create an ApplicationContext for integration tests, we can use either @SpringBootTest or @SpringJUnitConfig annotations. The former is a specialized annotation that also provides additional features such as auto-configuration, web environment emulation, and test properties management. The latter is a general-purpose annotation that combines @ContextConfiguration and @ExtendWith(SpringExtension.class) annotations.

To perform slice testing, which focuses on testing a specific layer or feature of the application in isolation, we can use annotations such as @WebMvcTest, @DataJpaTest, @RestClientTest, etc. These annotations will only load the relevant beans for the tested slice and mock or stub the other dependencies.

A. It causes Spring Boot to enable auto-configuration by default.

This is true because the @SpringBootApplication annotation includes the @EnableAutoConfiguration annotation, which enables Spring Boot’s auto-configuration mechanism1. Auto-configuration attempts to automatically configure your Spring application based on the jar dependencies that you have added2.

B. Component scanning will start from the package of the class.

This is true because the @SpringBootApplication annotation includes the @ComponentScan annotation, which enables component scanning on the package where the application is located1. Component scanning allows Spring to automatically detect and register beans annotated with @Component, @Controller, @Service, @Repository, etc3.