cif/cif-service/src/main/java/com/txz/cif/configurer/MyWebMvcConfigurer.java

package com.txz.cif.configurer;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.serializer.ToStringSerializer;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import com.txz.cif.configurer.interceptor.CorsInterceptor;
import com.txz.cif.core.Result;
import com.txz.cif.core.ResultCode;
import com.txz.cif.core.ServiceException;
import com.txz.cif.core.cache.CacheKey;
import com.txz.cif.core.cache.CacheType;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.NoHandlerFoundException;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;

import javax.annotation.Resource;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.math.BigInteger;
import java.util.*;

/**
 * Spring MVC 配置
 *
 * @author lxk
 */
@Configuration
public class MyWebMvcConfigurer implements WebMvcConfigurer {

    private final Logger logger = LoggerFactory.getLogger(MyWebMvcConfigurer.class);
    //    @Value("${spring.profiles.active}")
//    private String        env;                                                      // 当前激活的配置文件
//
//    @Value("${signature}")
//    private String        signature;                                                // 是否启用签名
//
//    @Value("${login.check}")
//    private String        loginCheck;                                              // 是否启用登录验证
    @Resource
    private RedisTemplate   redisTemplate;
    //    @Value("${spring.application.name}")
//    private String        application;
    @Resource
    private Parameters      parameters;
    @Autowired
    private CorsInterceptor corsInterceptor;


    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("swagger-ui.html")
                .addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("docs.html")
                .addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("doc.html")
                .addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**")
                .addResourceLocations("classpath:/META-INF/resources/webjars/");
    }

    // 使用阿里 FastJson 作为JSON MessageConverter
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        for (int i = converters.size() - 1; i >= 0; i--) {
            if (converters.get(i) instanceof MappingJackson2HttpMessageConverter) {
                converters.remove(i);
            }
        }
        FastJsonHttpMessageConverter fastJsonHttpMessageConverter = new FastJsonHttpMessageConverter();
        //自定义fastjson配置
        FastJsonConfig config = new FastJsonConfig();
        config.setDateFormat("yyyy-MM-dd HH:mm:ss");
        config.setSerializerFeatures(
                SerializerFeature.WriteMapNullValue,        // 是否输出值为null的字段,默认为false,我们将它打开
                SerializerFeature.WriteNullListAsEmpty,     // 将Collection类型字段的字段空值输出为[]
                SerializerFeature.WriteNullStringAsEmpty,   // 将字符串类型字段的空值输出为空字符串
                SerializerFeature.WriteNullNumberAsZero,    // 将数值类型字段的空值输出为0
                SerializerFeature.WriteDateUseDateFormat,
                SerializerFeature.DisableCircularReferenceDetect    // 禁用循环引用
        );
        SerializeConfig serializeConfig = SerializeConfig.globalInstance;
        serializeConfig.put(BigInteger.class, ToStringSerializer.instance);
//        serializeConfig.put(Long.class, ToStringSerializer.instance);
//        serializeConfig.put(Long.TYPE, ToStringSerializer.instance);
        config.setSerializeConfig(serializeConfig);
        fastJsonHttpMessageConverter.setFastJsonConfig(config);
        // 添加支持的MediaTypes;不添加时默认为*/*,也就是默认支持全部
        // 但是MappingJackson2HttpMessageConverter里面支持的MediaTypes为application/json
        // 参考它的做法, fastjson也只添加application/json的MediaType
        List<MediaType> fastMediaTypes = new ArrayList<>();
        fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
        fastJsonHttpMessageConverter.setSupportedMediaTypes(fastMediaTypes);
        converters.add(fastJsonHttpMessageConverter);
        // 设置项目名称
        ProjectConstant.application = parameters.getApplication();
    }

    // 统一异常处理
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
        exceptionResolvers.add(new HandlerExceptionResolver() {
            @Override
            public ModelAndView resolveException(HttpServletRequest request,
                                                 HttpServletResponse response, Object handler,
                                                 Exception e) {
                Result result = new Result();
                if (e instanceof ServiceException) {// 业务失败的异常，如“账号或密码错误”
                    result.setCode(ResultCode.FAIL.getCode()).setMessage(e.getMessage());
                    logger.info(e.getMessage());
                } else if (e instanceof NoHandlerFoundException) {
                    result.setCode(ResultCode.NOT_FOUND.getCode()).setMessage(
                            "接口 [" + request.getRequestURI() + "] 不存在");
                } else if (e instanceof ServletException) {
                    result.setCode(ResultCode.FAIL.getCode()).setMessage(e.getMessage());
                } else {
                    result.setCode(ResultCode.INTERNAL_SERVER_ERROR.getCode()).setMessage(
                            "接口 [" + request.getRequestURI() + "] 内部错误，请联系管理员");
                    String args = "";
                    String requestAccept = request.getHeader("Content-Type");
                    String contentType = "text/html";
                    //判断请求类型
                    if (StringUtils.isNotEmpty(requestAccept)) {
                        if (StringUtils.contains(requestAccept, "application/json") || StringUtils.contains(requestAccept, "text/javascript")
                                || StringUtils.contains(requestAccept, "text/json")) {
                            contentType = "application/json";
                        }
                    }
                    StringBuilder sb = new StringBuilder();
                    for (Map.Entry<String, String[]> stringEntry : request.getParameterMap().entrySet()) {
                        sb.append(stringEntry.getKey()).append(Arrays.toString(stringEntry.getValue()));
                    }
                    args = sb.toString();
                    StackTraceElement stackTraceElement = e.getStackTrace()[0];
                    String fileName = stackTraceElement.getFileName();
                    int lineNumber = stackTraceElement.getLineNumber();

                    logger.error("接口异常 URL: {}  HTTP_METHOD : {} VERSION: {} ARGS : {} token : {}  file: {} lineNum: {} ERROR_MSG {} ERROR {}",
                            request.getRequestURL().toString(), request.getMethod(), request.getHeader("version"), args, request.getHeader("token"), fileName, lineNumber, e.getMessage(), e);
                }
                String msg = LocalUtil.get(ResultCode.getEnumByStatusCode(result.getCode()).name());
                if (StrUtil.isNotBlank(msg) ){
                    result.setMessage(msg);
                }
                responseResult(response, result);
                return new ModelAndView();
            }

        });
    }

    // 解决跨域问题
    // @Override
    // public void addCorsMappings(CorsRegistry registry) {
    //     registry.addMapping("/**");
    // }

//    // 添加拦截器
//    @Override
//    public void addInterceptors(InterceptorRegistry registry) {
//        // 跨域
////        registry.addInterceptor(corsInterceptor);
//        // wxJava框架 ThreadLocal的remove问题
//
//        // 接口签名认证拦截器，该签名认证比较简单，实际项目中可以使用Json Web Token或其他更好的方式替代。
//        if ("true".equals(parameters.getSignature())) { // 开发环境忽略签名认证
//            registry.addInterceptor(new HandlerInterceptorAdapter() {
//                @Override
//                public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
//                                         Object handler) throws Exception {
//                    // 验证签名
//                    boolean pass = validateSign(request);
//                    if (pass) {
//                        return true;
//                    } else {
//                        logger.warn("签名认证失败，请求接口：{}，请求IP：{}，请求参数：{}", request.getRequestURI(),
//                                getIpAddress(request), JSON.toJSONString(request.getParameterMap()));
//
//                        Result result = new Result();
//                        result.setCode(ResultCode.UNAUTHORIZED.getCode()).setMessage("签名认证失败");
//                        responseResult(response, result);
//                        return false;
//                    }
//                }
//            });
//        }
//    }

    @Bean
    public LocaleResolver localeResolver() {
        // 使用SessionLocaleResolver或CookieLocaleResolver持久化Locale
        SessionLocaleResolver resolver = new SessionLocaleResolver();
        resolver.setDefaultLocale(Locale.ENGLISH); // 设置默认Locale
        return resolver;
    }

    @Bean
    public LocaleChangeInterceptor localeChangeInterceptor() {
        LocaleChangeInterceptor interceptor = new LocaleChangeInterceptor();
        interceptor.setParamName("lang"); // 支持通过?lang=zh_CN参数切换Locale
        return interceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(localeChangeInterceptor()); // 注册拦截器
    }

    private void responseResult(HttpServletResponse response, Result result) {
        response.setCharacterEncoding("UTF-8");
        response.setHeader("Content-type", "application/json;charset=UTF-8");
        response.setStatus(200);
        try {
            response.getWriter().write(JSON.toJSONString(result));
        } catch (IOException ex) {
            logger.error(ex.getMessage());
        }
    }

    /**
     * 一个简单的登录认证
     */
    private boolean validateLogin(HttpServletRequest request) {
        String userId = request.getParameter("userId");
        if (StringUtils.isBlank(userId)) {
            return false;
        }
        CacheKey key = CacheKey.generateKey(CacheType.AppSecretKey, userId);
        boolean exists = redisTemplate.hasKey(key.toString());
        if (exists) {
            return true;
        } else {
            return false;
        }

    }

    /**
     * 一个简单的签名认证，规则： 1. 将请求参数按ascii码排序 2. 拼接为a=value&b=value...这样的字符串（不包含sign）
     * 3. 混合密钥（secret）进行md5获得签名，与请求的签名进行比较
     */
    private boolean validateSign(HttpServletRequest request) {
        String requestSign = request.getParameter("sign");// 获得请求签名，如sign=19e907700db7ad91318424a97c54ed57
        if (StringUtils.isEmpty(requestSign)) {
            return false;
        }
        List<String> keys = new ArrayList<String>(request.getParameterMap().keySet());
        keys.remove("sign");// 排除sign参数
        Collections.sort(keys);// 排序

        StringBuilder sb = new StringBuilder();
        for (String key : keys) {
            sb.append(key).append("=").append(request.getParameter(key)).append("&");// 拼接字符串
        }
        String linkString = sb.toString();
        linkString = StringUtils.substring(linkString, 0, linkString.length() - 1);// 去除最后一个'&'

        String secret = "Potato";// 密钥，自己修改
        String sign = DigestUtils.md5Hex(linkString + secret);// 混合密钥md5

        return StringUtils.equals(sign, requestSign);// 比较
    }

    private String getIpAddress(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        // 如果是多级代理，那么取第一个ip为客户端ip
        if (ip != null && ip.indexOf(",") != -1) {
            ip = ip.substring(0, ip.indexOf(",")).trim();
        }

        return ip;
    }

}