2V0-72.22 Exam Questions & Answers

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()); }

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'').

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')'')

Spring Security is a framework that provides comprehensive security services for Java applications, such as authentication, authorization, encryption, session management, and more. One of its features is method security, which allows applying access control rules at the method level using annotations or XML configuration. Another feature is authentication, which is the process of verifying the identity of a user or a system. Spring Security supports various authentication mechanisms, such as username and password, tokens, certificates, etc., and can access authentication data from different sources, such as databases, LDAP directories, in-memory stores, etc.