Free 2V0-72-22 sample questions

Correct answer: Propagation.REQUIRES_NEW

`REQUIRES_NEW` starts a new, independent transaction for the `logAudit()` method. The existing transaction (from `transferFunds()`) is suspended. This allows the inner transaction to commit on its own, ensuring the audit log is saved even if the outer transaction fails and rolls back.

Correct answers: .antMatchers("/api/public/**").permitAll().antMatchers("/api/**").authenticated(); .authorizeRequests().antMatchers("/api/public/**").permitAll().anyRequest().authenticated()

This configuration correctly uses the principle of ordering matchers from most specific to most general. It first permits all access to `/api/public/**` and then requires authentication for all other `/api/**` paths.

This is also a correct and common pattern. It permits access to the public endpoints and then uses `anyRequest().authenticated()` as a catch-all to secure everything else. Since `/api/public/**` is matched first, it works as required.

Correct answer: True

The `@DataJpaTest` annotation is meta-annotated with `@Transactional`. In a test context, `@Transactional` ensures that each test method runs in a transaction that is rolled back by default upon completion. This keeps tests isolated and prevents them from polluting the database state for subsequent tests.

Correct answer: sa

The syntax `${PROPERTY:defaultValue}` is used for property placeholders. If the `PROPERTY` (in this case, the `DB_USER` environment variable) is not found, the `defaultValue` (`sa`) will be used instead.

Correct answer: Using `@JsonView` on the controller methods and entity fields.

Jackson's `@JsonView` annotation, which is well-integrated with Spring MVC, is designed for this exact purpose. It allows you to define multiple 'views' (e.g., public, internal) on a single model object and then specify which view to use for serialization at the controller method level, enabling different JSON outputs from the same object.

Correct answer: A singleton-scoped bean with dependencies injected via the constructor, performing the calculation in a method annotated with `@PostConstruct`.

This is the ideal approach. A singleton bean is created only once. Injecting dependencies via the constructor ensures they are available when the bean is initialized. The `@PostConstruct` annotation guarantees the calculation method runs after dependency injection is complete but before the bean is made available to other components. The result can be stored in a field for subsequent use.

Correct answer: Use a parameterized query with `?` placeholders and pass arguments to the `query` method.

The correct and standard way to prevent SQL injection is to use parameterized queries (prepared statements). The `JdbcTemplate` supports this by using `?` as a placeholder in the SQL string and passing the actual values as separate arguments to the query method. This ensures user input is treated as data, not executable code. The refactored code would be: `String sql = "SELECT * FROM users WHERE status = ?"; jdbcTemplate.query(sql, new Object[]{status}, userRowMapper);`

Correct answer: Add `spring-boot-starter-actuator`, `micrometer-registry-prometheus`, and `spring-boot-starter-security`. Configure properties: `management.server.port=9090`, `management.endpoints.web.exposure.include=*`, and use `HttpSecurity` to secure `/actuator/**` with `hasRole('ADMIN')`.

This solution correctly addresses all requirements. `spring-boot-starter-actuator` provides the health and metrics endpoints. `micrometer-registry-prometheus` ensures metrics are in the Prometheus format. `management.server.port=9090` isolates the management endpoints. `management.endpoints.web.exposure.include=*` exposes all endpoints, including the required health and prometheus ones. Finally, adding `spring-boot-starter-security` and configuring `HttpSecurity` allows for role-based access control to the actuator path, fulfilling the security requirement.

Correct answer: @ConditionalOnExpression("#{environment.acceptsProfiles('production') and systemProperties['email.enabled'] == 'true'}")

This SpEL expression is correct. `environment.acceptsProfiles('production')` is the proper way to check the active profile within a SpEL context. `systemProperties['email.enabled'] == 'true'` correctly accesses the system property and performs a string comparison. The `and` operator combines the two conditions as required.

Correct answer: @PreAuthorize("hasRole('ADMIN') or authentication.name == #username")

This SpEL expression correctly implements the logic. `hasRole('ADMIN')` checks for the required role. The `or` operator provides the alternative condition. `authentication.name` accesses the username of the currently authenticated principal, and `#username` refers to the `username` argument passed to the method, allowing for the ownership check.