spring-mvc 的一些使用技巧（转）

Posted 2020-10-13

 

 

APP 服务端的 Token 验证

通过拦截器对使用了@Authorization注解的方法进行请求拦截，从 http header 中取出 token 信息，验证其是否合法。非法直接返回 401 错误，合法将 token 对应的 user key 存入 request 中后继续执行。具体实现代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

public boolean preHandle (HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 如果不是映射到方法直接通过 if (!(handler instanceof HandlerMethod)) { return true; } HandlerMethod handlerMethod = (HandlerMethod) handler; Method method = handlerMethod.getMethod (); // 从 header 中得到 token String token = request.getHeader (httpHeaderName); if (token != null && token.startsWith (httpHeaderPrefix) && token.length () > 0) { token = token.substring (httpHeaderPrefix.length ()); // 验证 token String key = manager.getKey (token); if (key != null) { // 如果 token 验证成功，将 token 对应的用户 id 存在 request 中，便于之后注入 request.setAttribute (REQUEST_CURRENT_KEY, key); return true; } } // 如果验证 token 失败，并且方法注明了 Authorization，返回 401 错误 if (method.getAnnotation (Authorization.class) != null) { response.setStatus (HttpServletResponse.SC_UNAUTHORIZED); response.setCharacterEncoding ("gbk"); response.getWriter ().write (unauthorizedErrorMessage); response.getWriter ().close (); return false; } // 为了防止以某种直接在 REQUEST_CURRENT_KEY 写入 key，将其设为 null request.setAttribute (REQUEST_CURRENT_KEY, null); return true; }

通过拦截器后，使用解析器对修饰了@CurrentUser的参数进行注入。从 request 中取出之前存入的 user key，得到对应的 user 对象并注入到参数中。具体实现代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

@Override public boolean supportsParameter (MethodParameter parameter) { Class clazz; try { clazz = Class.forName (userModelClass); } catch (ClassNotFoundException e) { return false; } // 如果参数类型是 User 并且有 CurrentUser 注解则支持 if (parameter.getParameterType ().isAssignableFrom (clazz) && parameter.hasParameterAnnotation (CurrentUser.class)) { return true; } return false; }   @Override public Object resolveArgument (MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception { // 取出鉴权时存入的登录用户 Id Object object = webRequest.getAttribute (AuthorizationInterceptor.REQUEST_CURRENT_KEY, RequestAttributes.SCOPE_REQUEST); if (object != null) { String key = String.valueOf (object); // 从数据库中查询并返回 Object userModel = userModelRepository.getCurrentUser (key); if (userModel != null) { return userModel; } // 有 key 但是得不到用户，抛出异常 throw new MissingServletRequestPartException (AuthorizationInterceptor.REQUEST_CURRENT_KEY); } // 没有 key 就直接返回 null return null; }

详细分析：RESTful 登录设计（基于 Spring 及 Redis 的 Token 鉴权）

源码见：ScienJus/spring-restful-authorization

封装好的工具类：ScienJus/spring-authorization-manager

使用别名接受对象的参数

请求中的参数名和代码中定义的参数名不同是很常见的情况，对于这种情况 Spring 提供了几种原生的方法：

对于@RequestParam可以直接指定 value 值为别名（@RequestHeader也是一样），例如：

1 2 3

public String home (@RequestParam ("user_id") long userId) { return "hello " + userId; }

对于@RequestBody，由于其使使用 Jackson 将 Json 转换为对象，所以可以使用@JsonProperty的 value 指定别名，例如：

1 2 3 4 5 6 7 8

public String home (@RequestBody User user) { return "hello " + user.getUserId (); }   class User { @JsonProperty ("user_id") private long userId; }

但是使用对象的属性接受参数时，就无法直接通过上面的办法指定别名了，例如：

1 2 3

public String home (User user) { return "hello " + user.getUserId (); }

这时候需要使用 DataBinder 手动绑定属性和别名，我在 Stack Overflow 上找到的 这篇文章 是个不错的办法，这里就不重复造轮子了。

关闭默认通过请求的后缀名判断 Content-Type

之前接手的项目的开发习惯是使用.html 作为请求的后缀名，这在 Struts2 上是没有问题的（因为本身 Struts2 处理 Json 的几种方法就都很烂）。但是我接手换成 Spring MVC 后，使用@ResponseBody返回对象时就会报找不到转换器错误。

这是因为 Spring MVC 默认会将后缀名为.html 的请求的 Content-Type 认为是text/html，而@ResponseBody返回的 Content-Type 是application/json，没有任何一种转换器支持这样的转换。所以需要手动将通过后缀名判断 Content-Type 的设置关掉，并将默认的 Content-Type 设置为application/json：

1 2 3 4 5 6 7 8 9

@Configuration public class WebMvcConfig extends WebMvcConfigurerAdapter {   @Override public void configureContentNegotiation (ContentNegotiationConfigurer configurer) { configurer.favorPathExtension (false). defaultContentType (MediaType.APPLICATION_JSON); } }

更改默认的 Json 序列化方案

项目中有时候会有自己独特的 Json 序列化方案，例如比较常用的使用0/1替代false/true，或是通过""代替null，由于@ResponseBody默认使用的是MappingJackson2HttpMessageConverter，只需要将自己实现的ObjectMapper传入这个转换器：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public class CustomObjectMapper extends ObjectMapper {   public CustomObjectMapper () { super (); this.getSerializerProvider ().setNullValueSerializer (new JsonSerializer<Object>() { @Override public void serialize (Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeString (""); } }); SimpleModule module = new SimpleModule (); module.addSerializer (boolean.class, new JsonSerializer<Boolean>() { @Override public void serialize (Boolean value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeNumber (value ? 1 : 0); } }); this.registerModule (module); } }

自动加密 / 解密请求中的 Json

涉及到@RequestBody和@ResponseBody的类型转换问题一般都在MappingJackson2HttpMessageConverter中解决，想要自动加密 / 解密只需要继承这个类并重写readInternal/writeInternal方法即可：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

@Override protected Object readInternal (Class<?> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException { // 解密 String json = AESUtil.decrypt (inputMessage.getBody ()); JavaType javaType = getJavaType (clazz, null); // 转换 return this.objectMapper.readValue (json, javaType); }   @Override protected void writeInternal (Object object, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { // 使用 Jackson 的 ObjectMapper 将 Java 对象转换成 Json String ObjectMapper mapper = new ObjectMapper (); String json = mapper.writeValueAsString (object); // 加密 String result = AESUtil.encrypt (json); // 输出 outputMessage.getBody ().write (result.getBytes ()); }

基于注解的敏感词过滤功能

项目需要对用户发布的内容进行过滤，将其中的敏感词替换为*等特殊字符。大部分 Web 项目在处理这方面需求时都会选择过滤器（Filter），在过滤器中将Request包上一层Wrapper，并重写其getParameter等方法，例如：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

public class SafeTextRequestWrapper extends HttpServletRequestWrapper { public SafeTextRequestWrapper (HttpServletRequest req) { super (req); }   @Override public Map<String, String []> getParameterMap () { Map<String, String []> paramMap = super.getParameterMap (); for (String [] values : paramMap.values ()) { for (int i = 0; i < values.length; i++) { values [i] = SensitiveUtil.filter (values [i]); } } return paramMap ; }   @Override public String getParameter (String name) { return SensitiveUtil.filter (super.getParameter (name)); } }   public class SafeTextFilter implements Filter { @Override public void init (FilterConfig filterConfig) throws ServletException {   }   @Override public void doFilter (ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { SafeTextRequestWrapper safeTextRequestWrapper = new SafeTextRequestWrapper ((HttpServletRequest) request); chain.doFilter (safeTextRequestWrapper, response); }   @Override public void destroy () {   } }

但是这样做会有一些明显的问题，比如无法控制具体对哪些信息进行过滤。如果用户注册的邮箱或是密码中也带有fuck之类的敏感词，那就属于误伤了。

所以改用 Spring MVC 的 Formatter 进行拓展，只需要在@RequestParam的参数上使用@SensitiveFormat注解，Spring MVC 就会在注入该属性时自动进行敏感词过滤。既方便又不会误伤，实现方法如下：

声明@SensitiveFormat注解：

1 2 3 4 5

@Target ({ElementType.FIELD, ElementType.PARAMETER}) @Retention (RetentionPolicy.RUNTIME) @Documented public @interface SensitiveFormat { }

创建SensitiveFormatter类。实现Formatter接口，重写parse方法（将接收到的内容转换成对象的方法），在该方法中对接收内容进行过滤：

1 2 3 4 5 6 7 8 9 10 11

public class SensitiveFormatter implements Formatter<String> { @Override public String parse (String text, Locale locale) throws ParseException { return SensitiveUtil.filter (text); }   @Override public String print (String object, Locale locale) { return object; } }

创建SensitiveFormatAnnotationFormatterFactory类，实现AnnotationFormatterFactory接口，将@SensitiveFormat与SensitiveFormatter绑定：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public class SensitiveFormatAnnotationFormatterFactory implements AnnotationFormatterFactory<SensitiveFormat> {   @Override public Set<Class<?>> getFieldTypes () { Set<Class<?>> fieldTypes = new HashSet<>(); fieldTypes.add (String.class); return fieldTypes; }   @Override public Printer<?> getPrinter (SensitiveFormat annotation, Class<?> fieldType) { return new SensitiveFormatter (); }   @Override public Parser<?> getParser (SensitiveFormat annotation, Class<?> fieldType) { return new SensitiveFormatter (); } }

最后将SensitiveFormatAnnotationFormatterFactory注册到 Spring MVC 中：

1 2 3 4 5 6 7 8 9

@Configuration public class WebMvcConfig extends WebMvcConfigurerAdapter {   @Override public void addFormatters (FormatterRegistry registry) { registry.addFormatterForFieldAnnotation (new SensitiveFormatAnnotationFormatterFactory ()); super.addFormatters (registry); } }

记录请求的返回内容

这里提供一种比较通用的方法，基于过滤器实现，所以在非 Spring MVC 的项目也可以使用。

首先导入commons-io：

1 2 3 4 5

<dependency> <groupId>commons-io</groupId> <artifactId>commons-io</artifactId> <version>2.4</version> </dependency>

需要用到这个库中的TeeOutputStream，这个类可以将一个将内容同时输出到两个分支的输出流，将其封装为ServletOutputStream：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

public class TeeServletOutputStream extends ServletOutputStream {   private final TeeOutputStream teeOutputStream;   public TeeServletOutputStream (OutputStream one, OutputStream two) { this.teeOutputStream = new TeeOutputStream (one, two); }   @Override public boolean isReady () { return false; }   @Override public void setWriteListener (WriteListener listener) {   }   @Override public void write (int b) throws IOException { this.teeOutputStream.write (b); }   @Override public void flush () throws IOException { super.flush (); this.teeOutputStream.flush (); }   @Override public void close () throws IOException { super.close (); this.teeOutputStream.close (); } }

然后创建一个过滤器，将原有的response的getOutputStream方法重写：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

public class LoggingFilter implements Filter {   private static final Logger LOGGER = LoggerFactory.getLogger (LoggingFilter.class);   @Override public void init (FilterConfig filterConfig) throws ServletException {   }   public void doFilter (ServletRequest request, final ServletResponse response, FilterChain chain) throws IOException, ServletException { final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream ();   HttpServletResponseWrapper responseWrapper = new HttpServletResponseWrapper ((HttpServletResponse) response) {   private TeeServletOutputStream teeServletOutputStream;   @Override public ServletOutputStream getOutputStream () throws IOException { return new TeeServletOutputStream (super.getOutputStream (), byteArrayOutputStream); } }; chain.doFilter (request, responseWrapper); String responseLog = byteArrayOutputStream.toString (); if (LOGGER.isInfoEnabled () && !StringUtil.isEmpty (responseLog)) { LOGGER.info (responseLog); } }   @Override public void destroy () {   } }

将super.getOutputStream ()和ByteArrayOutputStream分别作为两个分支流，前者会将内容返回给客户端，后者使用toString方法即可获得输出内容。

其他的等想到再补充…

原文转自 
ScienJus‘s Blog