spring boot 国际化配置，国际化校验提示信息，校验提示信息国际化

• spring boot 国际化配置，支持提示信息国际化，通过head 传递参数locale 动态切换语言

package com.config;

import org.hibernate.validator.HibernateValidator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.validation.Validator;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;
import org.springframework.web.servlet.support.RequestContextUtils;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

/**
 * @ClassName ValidatorConfigurationil8n
 * @Description: 校验配置及校验信息国际化配置
 * @Author 
 * @Date 2020/4/9 10:38
 * @Version V1.0
 **/
@Configuration
@EnableWebMvc
//@ComponentScan
public class ValidatorConfigurationil8n implements WebMvcConfigurer {

    @Override
    public void configureDefaultServletHandling(final DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Override
    public Validator getValidator() {
        return validator();
    }

    @Override
    public void addInterceptors(final InterceptorRegistry registry) {
        registry.addInterceptor(new MyLocaleChangeInterceptor());
    }

    /***
    * 默认语言为 简写中文
    * @methodName  localeResolver
    * @return org.springframework.web.servlet.i18n.SessionLocaleResolver
    * @author 
    * @date 2020/4/9 14:59
    * @throws
    */
    @Bean
    public SessionLocaleResolver localeResolver() {
        SessionLocaleResolver localeResolver = new SessionLocaleResolver();
        localeResolver.setDefaultLocale(Locale.CHINA);
        return localeResolver;
    }

    /***
    * 加载提示信息国际化资源目录地址
    * @methodName  messageSource
    * @return org.springframework.context.support.ResourceBundleMessageSource
    * @author 
    * @date 2020/4/9 15:00
    * @throws
    */
    @Bean
    public ResourceBundleMessageSource messageSource() {
        ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
        messageSource.setDefaultEncoding("UTF-8");
        messageSource.setBasenames("i18n/ValidationMessages");
        return messageSource;
    }

    /***
    *  定义校验validation bean 模式为快速失败返回
    * @methodName  validator
    * @return org.springframework.validation.beanvalidation.LocalValidatorFactoryBean
    * @author 
    * @date 2020/4/9 15:01
    * @throws
    */
    @Bean
    public LocalValidatorFactoryBean validator() {
        LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
        validator.setProviderClass(HibernateValidator.class);
        validator.setValidationMessageSource(messageSource());
        // 设置validator模式为快速失败返回
        Map<String, String> validationPropertyMap = new HashMap(1);
        validationPropertyMap.put("hibernate.validator.fail_fast", "true");
        validator.setValidationPropertyMap(validationPropertyMap);
        return validator;
    }

    class MyLocaleChangeInterceptor extends LocaleChangeInterceptor {

        /***
        *  定义拦截国际化请求咨询，通过head 获取请求语言资源
        * @methodName  preHandle
        * @param request
         * @param response
         * @param handler
        * @return boolean
        * @author 
        * @date 2020/4/9 15:02
        * @throws
        */
        @Override
        public boolean preHandle(final HttpServletRequest request, final HttpServletResponse response, final Object handler)
                throws ServletException {

            String newLocale = request.getParameter(getParamName());
            if (newLocale != null) {
                return super.preHandle(request, response, handler);
            }

            else {
                // 前端通过head 请求切换语言资源
                newLocale = request.getHeader("locale");
                if (newLocale != null) {
                    LocaleResolver localeResolver = RequestContextUtils.getLocaleResolver(request);
                    if (localeResolver == null) {
                        throw new IllegalStateException("No LocaleResolver found: not in a DispatcherServlet request?");
                    }

                    try {
                        localeResolver.setLocale(request, response, parseLocaleValue(newLocale));
                    } catch (IllegalArgumentException ex) {
                        if (isIgnoreInvalidLocale()) {
                            this.logger.error("Ignoring invalid locale value [" + newLocale + "]: " + ex.getMessage());
                        } else {
                            throw ex;
                        }
                    }
                }
            }

            return true;
        }
    }

}

•  文件配置

  路径：classpath:/i18n
  英文配置文件：
  ValidationMessages_en_US.properties
  中文配置文件：
  ValidationMessages_zh_CN.properties

     文件中对应的配置信息

spring 中使用

• 语言切换

  head 中locale 参数切换语言
  zh_CN 中文，en_US 英文 ，缺省默认中文

• 

• 国际化全局异常处理 第三方copy 过来

 

import com.sue.demo.controller.ResponseResult;

import com.sue.demo.enums.ResultEnum;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.http.HttpStatus;

import org.springframework.http.converter.HttpMessageNotReadableException;

import org.springframework.util.StringUtils;

import org.springframework.validation.BindingResult;

import org.springframework.validation.FieldError;

import org.springframework.validation.ObjectError;

import org.springframework.web.bind.MethodArgumentNotValidException;

import org.springframework.web.bind.MissingServletRequestParameterException;

import org.springframework.web.bind.annotation.ExceptionHandler;

import org.springframework.web.bind.annotation.ResponseStatus;

import org.springframework.web.bind.annotation.RestControllerAdvice;

 

import java.util.List;

 

@RestControllerAdvice("com.sue.demo.controller")

public class GlobalExceptionHandler {

    private Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

 

    /**

     * 忽略参数异常处理器

     *

     * @param e 忽略参数异常

     * @return ResponseResult

     */

    @ResponseStatus(HttpStatus.BAD_REQUEST)

    @ExceptionHandler(MissingServletRequestParameterException.class)

    public ResponseResult parameterMissingExceptionHandler(MissingServletRequestParameterException e) {

        logger.error("", e);

        return new ResponseResult(ResultEnum.PARAMETER_ERROR.getCode(), "请求参数 " + e.getParameterName() + " 不能为空");

    }

 

    /**

     * 缺少请求体异常处理器

     *

     * @param e 缺少请求体异常

     * @return ResponseResult

     */

    @ResponseStatus(HttpStatus.BAD_REQUEST)

    @ExceptionHandler(HttpMessageNotReadableException.class)

    public ResponseResult parameterBodyMissingExceptionHandler(HttpMessageNotReadableException e) {

        logger.error("", e);

        return new ResponseResult(ResultEnum.PARAMETER_ERROR.getCode(), "参数体不能为空");

    }

 

    /**

     * 参数效验异常处理器

     *

     * @param e 参数验证异常

     * @return ResponseInfo

     */

    @ResponseStatus(HttpStatus.BAD_REQUEST)

    @ExceptionHandler(MethodArgumentNotValidException.class)

    public ResponseResult parameterExceptionHandler(MethodArgumentNotValidException e) {

        logger.error("", e);

        // 获取异常信息

        BindingResult exceptions = e.getBindingResult();

        // 判断异常中是否有错误信息，如果存在就使用异常中的消息，否则使用默认消息

        if (exceptions.hasErrors()) {

            List<ObjectError> errors = exceptions.getAllErrors();

            if (!errors.isEmpty()) {

                // 这里列出了全部错误参数，按正常逻辑，只需要第一条错误即可

                FieldError fieldError = (FieldError) errors.get(0);

                return new ResponseResult(ResultEnum.PARAMETER_ERROR.getCode(), fieldError.getDefaultMessage());

            }

        }

        return new ResponseResult(ResultEnum.PARAMETER_ERROR);

    }

 

    /**

     * 自定义参数错误异常处理器

     *

     * @param e 自定义参数

     * @return ResponseInfo

     */

    @ResponseStatus(HttpStatus.BAD_REQUEST)

    @ExceptionHandler({ParamaErrorException.class})

    public ResponseResult paramExceptionHandler(ParamaErrorException e) {

        logger.error("", e);

        // 判断异常中是否有错误信息，如果存在就使用异常中的消息，否则使用默认消息

        if (!StringUtils.isEmpty(e.getMessage())) {

            return new ResponseResult(ResultEnum.PARAMETER_ERROR.getCode(), e.getMessage());

        }

        return new ResponseResult(ResultEnum.PARAMETER_ERROR);

    }

 

    /**

     * 其他异常

     *

     * @param e

     * @return

     */

    @ResponseStatus(HttpStatus.BAD_REQUEST)

    @ExceptionHandler({Exception.class})

    public ResponseResult otherExceptionHandler(Exception e) {

        logger.error("其他异常", e);

        // 判断异常中是否有错误信息，如果存在就使用异常中的消息，否则使用默认消息

        if (!StringUtils.isEmpty(e.getMessage())) {

            return new ResponseResult(ResultEnum.UNKNOWN_ERROR.getCode(), e.getMessage());

        }

        return new ResponseResult(ResultEnum.UNKNOWN_ERROR);

    }

}