Question 1

Which two statements describe Spring JdbcTemplate? (Choose two.)

Accepted Answer

BD

Explanation: This is true because Spring's JdbcTemplate class offers a variety of methods to execute SQL queries against a relational database. These include methods for executing SQL queries (query, queryForObject, queryForList, etc.), updates (update), and batch operations (batchUpdate).

Question 2

Which two options will inject the value of the daily.limit system property? (Choose two.)

Accepted Answer

CD

Explanation: The @Value annotation can be used to inject values from external sources into fields, constructor parameters, or method parameters. To inject a system property, the annotation can use either the ${…} placeholder syntax or the #{…} SpEL expression syntax. The former is simpler and more concise, while the latter is more powerful and flexible. Both syntaxes can access the systemProperties map, which contains all the system properties as key-value pairs. Reference: : https://docs.spring.io/springframework/docs/current/reference/html/core.html#beans-value-annotations : https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#expressions : https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#expressionsbeandef-xml-based

Question 3

Which two statements are true regarding Spring and Spring Boot Testing? (Choose two.)

Accepted Answer

BE

Explanation: 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. Reference: https://docs.spring.io/spring-boot/docs/2.1.5.RELEASE/reference/html/boot-featurestesting.html

Question 4

Which two statements are correct regarding Spring Boot auto-configuration customization? (Choose two.)

Accepted Answer

AB

Explanation: Reference: https://docs.spring.io/spring-boot/docs/1.4.3.RELEASE/reference/html/using-boot-autoconfiguration.html

Question 5

Which two statements are true about @Controller annotated classes? (Choose two.)

Accepted Answer

BE

Explanation: 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. Reference: https://www.baeldung.com/spring-mvc-handler-adapters https://www.dineshonjava.com/stereotype-annotations-in-spring/

Question 6

Which statement is true? (Choose the best

Accepted Answer

ANSWER: D

Explanation: 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. Reference: https://docs.spring.io/spring-framework/docs/4.2.x/spring-frameworkreference/html/integration- testing.html

Question 7

Refer to the exhibit. https://kxbjsyuhceggsyvxdkof.supabase.co/storage/v1/object/public/file-images/VMware_2V0-72.22/page_10_img_1.jpg The above code shows a conditional @Bean method for the creation of a JdbcTemplate bean. Which two statements correctly describe the code behavior? (Choose two.)

Accepted Answer

AE

Explanation: The @Bean annotation is used to declare a method that returns an object that should be registered as a bean in the application context. The @ConditionalOnBean annotation is used to specify a condition for the bean creation based on the presence or absence of other beans in the application context. The name attribute of this annotation can be used to specify the bean name or names that must be present or absent for the condition to match. However, this approach is less flexible than using the value or type attribute, which can specify the bean class or classes that must be present or absent for the condition to match. Therefore, it is recommended to use @ConditionalOnBean(DataSource.class) instead of @ConditionalOnBean(name= “dataSource”) for greater flexibility. The JdbcTemplate class is a Spring class that simplifies the use of JDBC and helps to avoid common errors. It executes core JDBC workflow, leaving application code to provide SQL and extract results. To create a JdbcTemplate object, we need to pass a DataSource object as a constructor argument. The DataSource interface is a Java interface that represents a factory of connection objects. In this code, the jdbcTemplate() method takes a DataSource object as a parameter and returns a new JdbcTemplate object. This method is annotated with @Bean and @ConditionalOnBean(name= “dataSource”), which means that it will only create a JdbcTemplate bean when there is already a bean named dataSource in the application context.

Question 8

Which two statements are correct regarding the Health Indicator status? (Choose two.)

Accepted Answer

CD

Explanation: Reference: https://docs.spring.io/spring-boot/docs/1.5.x/reference/html/production-readyendpoints.html

Question 9

Refer to the exhibit. It is a Java code fragment from a Spring application. Which statement is true with regard to the above example? (Choose the best

Accepted Answer

D

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

Question 10

Refer to the exhibit. https://kxbjsyuhceggsyvxdkof.supabase.co/storage/v1/object/public/file-images/VMware_2V0-72.22/page_25_img_2.jpg Which statement is true? (Choose the best

Accepted Answer

C

Explanation: :

Question 11

Which two statements about the @Autowired annotation are true? (Choose two.)

Accepted Answer

BC

Explanation: https://docs.spring.io/spring-framework/docs/current/javadocapi/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

Question 12

Which statement about @TestPropertySource annotation is true? (Choose the best

Accepted Answer

D

Explanation: Reference: https://www.concretepage.com/spring-5/testpropertysource-example-spring-test

Question 13

Refer to the exhibit. https://kxbjsyuhceggsyvxdkof.supabase.co/storage/v1/object/public/file-images/VMware_2V0-72.22/page_34_img_1.jpg What statement is true about @DirtiesContext?

Accepted Answer

B

Explanation: @DirtiesContext @Test void testProcessWhichDirtiesAppCtx() { // some logic that results in the Spring container being dirtied } Dirty the context after the current test method. https://docs.spring.io/spring-framework/reference/testing/annotations/integrationspring/annotation-dirtiescontext.html

Question 14

Which statement describes the @AfterReturning advice type? (Choose the best

Accepted Answer

A

Explanation: https://docs.spring.io/spring-framework/docs/current/javadocapi/org/springframework/aop/AfterReturningAdvice.html Reference: https://www.amitph.com/spring-aop-afterreturning-advice

Question 15

What are the two reasons Spring be used to build a Java application? (Choose two.)

Accepted Answer

BE

Explanation: 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.

Free VMware 2V0-72.22 Actual Exam Questions