Most Recent VMware 2V0-72.22 Exam Questions & Answers

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:

<dependency> <groupId>org.springframework.boot</groupId> spring-boot-starter-web <exclusions> <exclusion> <groupId>org.springframework.boot</groupId> spring-boot-starter-tomcat </exclusion> </exclusions> </dependency> <dependency> <groupId>org.springframework.boot</groupId> spring-boot-starter-undertow </dependency>

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<Map<String, Object>> results = jdbcTemplate.queryForList(''SELECT * FROM EMPLOYEE''); for (Map<String, Object> 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<Employee> { @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<Employee> employees = jdbcTemplate.query(''SELECT * FROM EMPLOYEE'', new EmployeeRowMapper()); for (Employee employee : employees) { System.out.println(employee.getName() + ' ' + employee.getSalary()); }

The @Autowired annotation can be used to inject a dependency into a field, a constructor, or a setter method. However, if there are multiple beans of the same type in the application context, Spring will not be able to determine which one to inject by default. To resolve this ambiguity, we can use the @Qualifier annotation to specify the bean id of the desired dependency. Alternatively, we can use the bean id as the name of the field or the parameter of the setter method, and Spring will match it with the corresponding bean.