2V0-72.22 Professional Develop VMware Spring Questions and Answers

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

This is true because the @PropertySource annotation provides a convenient and declarative mechanism for adding a PropertySource to Spring’s Environment. A PropertySource is an abstraction for a source of name/value pairs that can be used by the Environment to resolve properties. The @PropertySource annotation can be used to load properties from an external file, such as a .properties or .yml file, and make them available to the application context.

https://docs.spring.io/spring-framework/reference/core/beans/environment.html#beans-using-propertysource

http://effcode.com/spring/returning-no-content-204-from-spring-controller/

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.

This is true because the id/name of a bean declared by the @Bean annotation is derived from the name of the method that returns the bean. In this case, the method name is clientService, so the bean name will be clientService as well. By default, Spring uses a lower-case first letter for bean names, unless explicitly specified otherwise by using the name attribute of the @Bean annotation. For example, we can use @Bean(name = “ClientService”) to change the bean name to ClientService (starting with uppercase “C”).

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.

A. @Configuration This annotation indicates that the class has @Bean definition methods and may be processed by the Spring container to generate bean definitions and service requests for those beans at runtime. B. @ComponentScan This annotation configures component scanning directives for use with @Configuration classes. Provides support parallel with Spring XML's context:component-scan element.

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.

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.

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.

@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/integration-spring/annotation-dirtiescontext.html

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

The JdbcTemplate class provides various methods to execute queries and manipulate the query results. Depending on the query and the expected result type, we can choose from the following three types of objects that can be returned from a JdbcTemplate query:

A. Generic Maps

This is true because the JdbcTemplate.queryForList method returns a List of Map objects, where each Map represents a row of the query result. The Map keys are the column names and the Map values are the column values1. For example:

List> results = jdbcTemplate.queryForList(“SELECT * FROM EMPLOYEE”); for (Map row : results) { System.out.println(row.get(“NAME”) + " " + row.get(“SALARY”)); }

B. Simple types (int, long, String, etc)

This is true because the JdbcTemplate.queryForObject method can return a single value of a simple type, such as int, long, String, etc. This method is useful for running queries that return a single row and a single column2. For example:

int count = jdbcTemplate.queryForObject(“SELECT COUNT(*) FROM EMPLOYEE”, Integer.class); System.out.println("Number of employees: " + count);

D. User defined types

This is true because the JdbcTemplate.query method can return a List of user defined types, such as custom classes or beans. This method takes a RowMapper as an argument, which is an interface that maps each row of the query result to an instance of the user defined type3. For example:

public class Employee { private String name; private int salary; // getters and setters }

public class EmployeeRowMapper implements RowMapper { @Override public Employee mapRow(ResultSet rs, int rowNum) throws SQLException { Employee employee = new Employee(); employee.setName(rs.getString(“NAME”)); employee.setSalary(rs.getInt(“SALARY”)); return employee; } }

List employees = jdbcTemplate.query(“SELECT * FROM EMPLOYEE”, new EmployeeRowMapper()); for (Employee employee : employees) { System.out.println(employee.getName() + " " + employee.getSalary()); }

Spring Security uses a filter-based architecture to provide security services for web applications. A filter is an object that intercepts HTTP requests and responses and performs some logic before or after the request is processed by the servlet. Spring Security provides a number of filters for different purposes, such as:

Authentication: Filters that handle the authentication process, such as UsernamePasswordAuthenticationFilter, BasicAuthenticationFilter, RememberMeAuthenticationFilter, etc.

User management: Filters that manage the user details and roles, such as SecurityContextPersistenceFilter, AnonymousAuthenticationFilter, ConcurrentSessionFilter, etc.

Logout: Filters that handle the logout process, such as LogoutFilter and SecurityContextLogoutHandler.

Authorization: Filters that enforce access control rules based on the user’s authentication and roles, such as FilterSecurityInterceptor, ExceptionTranslationFilter, etc.