2V0-72.22 Exam Dumps - Professional Develop VMware Spring

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.

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

A. @EntityScan and spring.jpa.* properties can be used to customize Spring Data JPA.

This is true because the @EntityScan annotation can be used to specify the base packages to scan for JPA entities, instead of using the default package of the main application class. The spring.jpa.* properties can be used to configure various aspects of Spring Data JPA, such as the database platform, the DDL generation, the show-sql flag, etc.

B. Any kind of Hibernate property can be passed to Spring Data JPA like spring.jpa.properties.xxx.

This is true because Spring Data JPA supports passing any Hibernate-specific property by using the prefix spring.jpa.properties. For example, we can use spring.jpa.properties.hibernate.format_sql=true to format the SQL statements generated by Hibernate.

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

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.

https://www.baeldung.com/transaction-configuration-with-jpa-and-spring

@Transactional(propagation = Propagation.SUPPORTS, readOnly = true)

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Transactional.html