SpringMVC框架面试专题（初级-中级）-第六节

最新推荐文章于 2025-05-27 15:09:53 发布

奇怪的元素

最新推荐文章于 2025-05-27 15:09:53 发布

阅读量718

点赞数 4

分类专栏： # Spring Mvc框架面试专题（初级-中级）文章标签：面试 spring java mvc 职场和发展

本文链接：https://blog.youkuaiyun.com/weixin_46737313/article/details/130894849

版权

Spring Mvc框架面试专题（初级-中级）专栏收录该内容

10 篇文章

订阅专栏

本文介绍了SpringMVC框架的关键组件：ServletAPI支持，用于访问HTTP请求和响应；SpringSecurity，提供安全控制如身份验证和授权；RestTemplate，用于访问RESTful服务；全局异常处理，自定义错误响应；以及视图解析器，解析逻辑视图到实际视图。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

欢迎大家一起探讨～如果可以帮到大家请为我点赞关注哦～后续会持续更新

问题：

1.Spring MVC框架中的Servlet API支持是什么？请举例说明如何使用Servlet API支持。

解析：

Spring MVC框架中的Servlet API支持是一种机制，用于在Spring MVC应用程序中使用Servlet API。通过使用Servlet API支持，我们可以轻松地访问HTTP请求和响应、会话、Cookie等Servlet API功能，并与Spring MVC框架无缝集成。

以下是一个使用Spring MVC框架中的Servlet API支持的示例：

@Controller
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public String getUser(@PathVariable("id") Long id, HttpServletRequest request) {
        HttpSession session = request.getSession();
        session.setAttribute("userId", id);
        Cookie cookie = new Cookie("userId", id.toString());
        cookie.setMaxAge(3600);
        response.addCookie(cookie);
        return "user";
    }

    @PostMapping
    public String createUser(@ModelAttribute User user, HttpServletRequest request) {
        HttpSession session = request.getSession();
        Long userId = (Long) session.getAttribute("userId");
        user.setCreatedBy(userId);
        userService.createUser(user);
        return "redirect:/api/users/" + user.getId();
    }

}

在上面的代码中，我们在getUser()方法中使用了HttpServletRequest对象来访问HTTP请求和响应、会话和Cookie等Servlet API功能。具体来说，我们在getUser()方法中使用了HttpServletRequest对象来获取当前会话，并在会话中设置了userId属性。然后，我们创建了一个Cookie对象，并将其添加到响应中以设置userId属性。最后，我们返回一个视图名user，用于渲染用户信息。

在createUser()方法中，我们还使用了@ModelAttribute注解来绑定表单数据到User对象，并使用HttpServletRequest对象来获取当前会话。然后，我们从会话中获取userId属性，并将其设置为User对象的createdBy属性。最后，我们调用userService.createUser()方法来创建用户，并使用redirect关键字将请求重定向到新创建的用户的URL。

除了使用HttpServletRequest对象外，我们还可以在控制器类中注入HttpServletResponse对象，以访问HTTP响应。例如：

@Controller
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public String getUser(@PathVariable("id") Long id, HttpServletResponse response) {
        User user = userService.getUserById(id);
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");
        response.getWriter().write(new Gson().toJson(user));
        return null;
    }

    @PostMapping
    public String createUser(@ModelAttribute User user, HttpServletResponse response) throws IOException {
        userService.createUser(user);
        response.sendRedirect("/api/users/" + user.getId());
        return null;
    }

}

在上面的代码中，我们在getUser()方法中注入了HttpServletResponse对象，并使用它来设置HTTP响应的内容类型、字符编码和响应正文。然后，我们将用户对象转换为JSON字符串，并将其写入响应正文中。最后，我们返回null以表示我们没有使用任何视图来渲染响应。

在createUser()方法中，我们也注入了HttpServletResponse对象，并使用它来重定向到新创建的用户的URL。具体来说，我们调用了response.sendRedirect()方法，并将URL作为参数传递。

总之，Spring MVC框架中的Servlet API支持是一种非常有用的机制，可以帮助我们在Spring MVC应用程序中使用Servlet API。通过在控制器类中注入HttpServletRequest和HttpServletResponse对象，我们可以轻松地访问HTTP请求和响应、会话、Cookie等Servlet API功能，并与Spring MVC框架无缝集成。

问题：

2.Spring MVC框架中的Spring Security是什么？请举例说明如何使用Spring Security。

解析：

Spring MVC框架中的Spring Security是一个功能强大、灵活和可扩展的安全框架，用于保护Web应用程序和RESTful API。Spring Security提供了一系列安全功能，包括身份验证、授权、会话管理、密码加密、角色管理等，可以帮助我们构建安全的Web应用程序。

以下是一个使用Spring Security的示例：

首先，我们需要在Maven中添加以下依赖项：

<!-- Spring Security依赖 -->
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-web</artifactId>
    <version>5.5.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-config</artifactId>
    <version>5.5.0</version>
</dependency>

然后，我们需要创建一个SecurityConfig类，用于配置Spring Security：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/api/users/**").hasRole("USER")
                .and()
                .formLogin()
                .and()
                .logout()
                .logoutUrl("/logout")
                .logoutSuccessUrl("/login")
                .and()
                .csrf().disable();
    }

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

}

在上面的代码中，我们创建了一个SecurityConfig类，并使用@EnableWebSecurity注解启用Spring Security支持。然后，我们重写了configure(HttpSecurity http)方法，使用HttpSecurity对象来配置安全规则。在上面的代码中，我们指定了对/api/users/**路径的访问需要具有USER角色。然后，我们启用了表单登录和注销功能，并使用/logout路径和/login路径分别作为注销和注销成功后的重定向URL。最后，我们禁用了CSRF保护。

在configureGlobal(AuthenticationManagerBuilder auth)方法中，我们使用AuthenticationManagerBuilder对象来配置身份验证。具体来说，我们使用userDetailsService()方法来指定使用UserDetailsService接口来加载用户数据，使用passwordEncoder()方法来指定密码加密算法。

接下来，我们需要创建一个UserDetailsService实现类，用于加载用户数据：

@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserService userService;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userService.getUserByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found with username: " + username);
        }
        return new org.springframework.security.core.userdetails.User(user.getUsername(),
                user.getPassword(), getAuthorities(user));
    }

    private Set<GrantedAuthority> getAuthorities(User user) {
        Set<GrantedAuthority> authorities = new HashSet<>();
        for (Role role : user.getRoles()) {
            authorities.add(new SimpleGrantedAuthority(role.getName()));
        }
        return authorities;
    }

}

在上面的代码中，我们创建了一个UserDetailsServiceImpl类，并实现了UserDetailsService接口。在loadUserByUsername(String username)方法中，我们使用userService对象来加载用户数据，并将其转换为UserDetails对象返回。具体来说，我们使用getAuthorities(User user)方法来获取用户的角色信息，并将其封装为GrantedAuthority对象的集合。

最后，我们还需要在控制器类中添加一些安全注解，以保护Web资源。例如：

@RestController
@RequestMapping("/api/users")
@Secured("ROLE_USER")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUser(@PathVariable("id") Long id) {
        return userService.getUserById(id);
    }

    @PostMapping
    @Secured("ROLE_ADMIN")
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

}

在上面的代码中，我们在控制器类上使用了@Secured("ROLE_USER")注解来保护/api/users路径，要求访问该路径的用户必须具有ROLE_USER角色。在createUser()方法上，我们还使用了@Secured("ROLE_ADMIN")注解来保护该方法，要求访问该方法的用户必须具有ROLE_ADMIN角色。

总之，Spring MVC框架中的Spring Security是一个功能强大、灵活和可扩展的安全框架，可以帮助我们构建安全的Web应用程序。通过创建一个SecurityConfig类，并在控制器类中添加安全注解，我们可以轻松地保护Web资源，并使用身份验证、授权、会话管理、密码加密、角色管理等安全功能。

问题：

3.Spring MVC框架中的RestTemplate是什么？请举例说明如何使用RestTemplate。

解析：

Spring MVC框架中的RestTemplate是一个用于访问RESTful API的HTTP客户端工具。使用RestTemplate，我们可以轻松地向远程服务器发送HTTP请求，并获取响应数据。RestTemplate提供了一系列方法，包括GET、POST、PUT、DELETE等，可以帮助我们实现对RESTful API的访问。RestTemplate还支持基本身份验证、OAuth2身份验证、HTTP代理等功能。

以下是一个使用RestTemplate的示例：

首先，我们需要在Maven中添加以下依赖项：

<!-- Spring Web依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.3.8</version>
</dependency>

然后，我们可以在Spring MVC应用程序中使用RestTemplate。例如，我们可以创建一个UserService类，并使用RestTemplate来访问RESTful API：

@Service
public class UserService {

    private static final String API_URL = "https://api.example.com/users";

    private RestTemplate restTemplate = new RestTemplate();

    public User getUserById(Long id) {
        String url = API_URL + "/" + id;
        return restTemplate.getForObject(url, User.class);
    }

   public void createUser(User user) {
        restTemplate.postForObject(API_URL, user, User.class);
    }

    public void updateUser(User user) {
        String url = API_URL + "/" + user.getId();
        restTemplate.put(url, user);
    }

    public void deleteUser(Long id) {
        String url = API_URL + "/" + id;
        restTemplate.delete(url);
    }

}

在上面的代码中，我们创建了一个UserService类，并在其中使用RestTemplate来访问RESTful API。具体来说，我们使用restTemplate.getForObject()方法来发送HTTP GET请求，并将响应数据转换为User对象。我们还使用restTemplate.postForObject()方法来发送HTTP POST请求，并将User对象作为请求正文。类似地，我们使用restTemplate.put()方法来发送HTTP PUT请求，并使用restTemplate.delete()方法来发送HTTP DELETE请求。

RestTemplate还支持基本身份验证、OAuth2身份验证等功能。例如，我们可以使用Basic认证来保护RESTful API：

private RestTemplate restTemplate = new RestTemplate(new HttpComponentsClientHttpRequestFactory());

public void setCredentials(String username, String password) {
    restTemplate.getInterceptors().add(new BasicAuthenticationInterceptor(username, password));
}

在上面的代码中，我们创建了一个带有HttpComponentsClientHttpRequestFactory的RestTemplate，并使用setCredentials()方法来设置基本身份验证用户名和密码。这样，我们就可以在发送HTTP请求时自动添加基本身份验证头信息。

除了基本身份验证外，RestTemplate还支持OAuth2身份验证，可以使用OAuth2RestTemplate类来实现。例如，我们可以使用OAuth2身份验证来访问Google API：

@Bean
public OAuth2RestTemplate oauth2RestTemplate(OAuth2ClientContext oauth2ClientContext) {
    OAuth2ProtectedResourceDetails resource = new GoogleOAuth2ClientCredentials();
    AuthorizationCodeResourceDetails details = new AuthorizationCodeResourceDetails();
    details.setAccessTokenUri(resource.getAccessTokenUri());
    details.setClientId(resource.getClientId());
    details.setClientSecret(resource.getClientSecret());
    details.setScope(resource.getScope());
    details.setUserAuthorizationUri(resource.getUserAuthorizationUri());
    return new OAuth2RestTemplate(details, oauth2ClientContext);
}

在上面的代码中，我们创建了一个OAuth2RestTemplate类，并使用GoogleOAuth2ClientCredentials类来配置OAuth2身份验证。具体来说，我们使用OAuth2ProtectedResourceDetails接口来设置Google API的访问令牌URI、客户端ID、客户端密钥、范围和用户授权URI。然后，我们使用AuthorizationCodeResourceDetails类来设置OAuth2身份验证的详细信息，并使用OAuth2RestTemplate类来创建OAuth2 RestTemplate。

总之，Spring MVC框架中的RestTemplate是一个用于访问RESTful API的HTTP客户端工具，可以帮助我们轻松地向远程服务器发送HTTP请求，并获取响应数据。通过使用RestTemplate，我们可以实现对RESTful API的访问，并支持基本身份验证、OAuth2身份验证、HTTP代理等功能。

问题：

4.Spring MVC框架中的全局异常处理是什么？请举例说明如何配置全局异常处理。

解析：

Spring MVC框架中的全局异常处理是一种机制，用于捕获和处理应用程序中的异常。通过配置全局异常处理器，我们可以自定义异常处理逻辑，例如记录日志、返回错误消息等。全局异常处理器可以处理所有请求中抛出的异常，包括控制器方法中的异常、过滤器中的异常、拦截器中的异常等。

以下是一个配置全局异常处理器的示例：

首先，我们需要创建一个自定义异常类，例如MyException：

public class MyException extends RuntimeException {

    public MyException(String message) {
        super(message);
    }

}

然后，我们可以创建一个全局异常处理器类，例如GlobalExceptionHandler：

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(MyException.class)
    public ResponseEntity<ErrorResponse> handleMyException(MyException ex) {
        ErrorResponse error = new ErrorResponse(HttpStatus.BAD_REQUEST.value(), ex.getMessage());
        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception ex) {
        ErrorResponse error = new ErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR.value(), "Internal server error");
        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
    }

}

在上面的代码中，我们使用@ControllerAdvice注解标注了GlobalExceptionHandler类，表示该类是一个全局异常处理器。然后，我们使用@ExceptionHandler注解来指定处理不同类型的异常。在上面的代码中，我们定义了两个异常处理方法，分别是处理MyException和Exception类型的异常。当捕获到MyException异常时，handleMyException()方法将创建一个ErrorResponse对象，并将其封装为一个ResponseEntity对象返回。类似地，当捕获到其他异常时，handleException()方法将返回一个默认的错误响应。

ErrorResponse类是一个自定义错误响应类，例如：

public class ErrorResponse {

    private int status;
    private String message;

    public ErrorResponse(int status, String message) {
        this.status = status;
        this.message = message;
    }

    // getters and setters

}

最后，我们需要在Spring MVC配置文件中启用全局异常处理器，例如：

@Configuration
@EnableWebMvc
public class AppConfig implements WebMvcConfigurer {

    @Autowired
    private GlobalExceptionHandler globalExceptionHandler;

    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        resolvers.add(globalExceptionHandler);
    }

}

在上面的代码中，我们创建了一个AppConfig类，并使用@EnableWebMvc注解启用Spring MVC支持。然后，我们重写了configureHandlerExceptionResolvers()方法，将globalExceptionHandler对象添加到异常处理解析器列表中，这样就可以使用全局异常处理器来处理所有请求中的异常了。

总之，Spring MVC框架中的全局异常处理是一种机制，用于捕获和处理应用程序中的异常。通过配置全局异常处理器，我们可以自定义异常处理逻辑，并处理所有请求中抛出的异常。我们可以创建自定义异常类、自定义错误响应类，然后在全局异常处理器中编写异常处理逻辑。最后，我们需要在Spring MVC配置文件中启用全局异常处理器，使其生效。

问题：

5.Spring MVC框架中的视图解析器是什么？请举例说明如何自定义一个视图解析器。

解析：

Spring MVC框架中的视图解析器是一种机制，用于将逻辑视图名称解析为实际的视图实现。视图解析器可以根据逻辑视图名称查找对应的视图实现，并将模型数据渲染到视图中。Spring MVC框架提供了多种视图解析器，例如InternalResourceViewResolver、FreeMarkerViewResolver、VelocityViewResolver等。

以下是一个自定义视图解析器的示例：

首先，我们需要创建一个自定义视图类，例如MyView：

public class MyView implements View {

    @Override
    public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
        response.getWriter().write("Hello, world!");
    }

}

在上面的代码中，我们创建了一个MyView类，并实现了View接口。在render()方法中，我们向响应输出了一个简单的文本消息。

然后，我们可以创建一个自定义视图解析器类，例如MyViewResolver：

public class MyViewResolver implements ViewResolver {

    @Override
    public View resolveViewName(String viewName, Locale locale) throws Exception {
        if (viewName.equals("myView")) {
            return new MyView();
        }
        return null;
    }

}

在上面的代码中，我们创建了一个MyViewResolver类，并实现了ViewResolver接口。在resolveViewName()方法中，我们根据逻辑视图名称判断是否需要返回自定义视图。如果逻辑视图名称为myView，则返回一个新的MyView对象，否则返回null。

最后，我们需要在Spring MVC配置文件中注册自定义视图解析器，例如：

@Configuration
@EnableWebMvc
public class AppConfig implements WebMvcConfigurer {

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.viewResolver(new MyViewResolver());
    }

}

在上面的代码中，我们创建了一个AppConfig类，并使用@EnableWebMvc注解启用Spring MVC支持。然后，我们重写了configureViewResolvers()方法，将自定义视图解析器添加到视图解析器列表中，这样就可以使用自定义视图解析器来解析逻辑视图了。

总之，Spring MVC框架中的视图解析器是一种机制，用于将逻辑视图名称解析为实际的视图实现。我们可以创建自定义视图类、自定义视图解析器类，并在Spring MVC配置文件中注册自定义视图解析器，使其生效。自定义视图解析器可以根据逻辑视图名称查找对应的视图实现，并将模型数据渲染到视图中。通过自定义视图解析器，我们可以实现更加灵活的视图解析逻辑，例如返回非常规的视图实现、根据请求路径动态选择视图等。