SpringBoot HTTP 请求 Body 下划线转驼峰

1 注解方式

Spring请求的时候将下划线转为和JavaBean的驼峰相对应(fast_name转为fastName)

1.1 AppWebMvcConfig

import org.springframework.context.annotation.Configuration;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class AppWebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(0, new RequestModelArgumentResolver());
    }
}

1.2 CustomHttpServletRequestWrapper

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

import cn.hutool.core.io.IoUtil;

public class CustomHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private final String BODY;

    public CustomHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        StringBuilder builder = new StringBuilder();
        BufferedReader reader = null;
        try {
            InputStream inputStream = request.getInputStream();
            if (inputStream != null) {
                reader = new BufferedReader(new InputStreamReader(inputStream));
                char[] chars = new char[128];
                int read;
                while ((read = reader.read(chars)) > 0) {
                    builder.append(chars, 0, read);
                }
            }
        } catch (Exception ex) {
            throw ex;
        } finally {
            IoUtil.close(reader);
        }
        BODY = builder.toString();
    }

    public String getBody() {
        return this.BODY;
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream bytes = new ByteArrayInputStream(BODY.getBytes());
        ServletInputStream stream = new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {
            }

            @Override
            public int read() throws IOException {
                return bytes.read();
            }
        };
        return stream;
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(this.getInputStream()));
    }

}

1.3 Handel

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Handel {

    boolean required() default true;

}

1.4 RequestModelArgumentResolver

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import org.springframework.core.MethodParameter;
import org.springframework.objenesis.instantiator.util.ClassUtils;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.reflect.FieldUtils;

import com.alibaba.fastjson.JSONObject;

public class RequestModelArgumentResolver implements HandlerMethodArgumentResolver {

    private final Pattern UNDER_LINE_PATTER = Pattern.compile("_(\\w)");

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(Handel.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer container, NativeWebRequest request,
                                  WebDataBinderFactory binderFactory) throws Exception {
        CustomHttpServletRequestWrapper wrapper = new CustomHttpServletRequestWrapper(request.getNativeRequest(HttpServletRequest.class));

        // 1 判断请求数据是否存在
        Class<?> type = parameter.getParameterType();
        String body = wrapper.getBody();
        if (StringUtils.isEmpty(body)) {
            return ClassUtils.newInstance(type);
        }

        // 2 获取请求字段
        Field[] fields = FieldUtils.getAllFields(type);
        Map<String, Field> map = Arrays.stream(fields).collect(Collectors.toMap(Field::getName, v -> v));

        Object clazz = ClassUtils.newInstance(type);
        JSONObject json = JSONObject.parseObject(body);
        for (Map.Entry<String, Object> entry : json.entrySet()) {

            // 1 获取键值
            String key = entry.getKey();
            Object value = entry.getValue();
            // 2 判断是否为空
            if (ObjectUtils.isEmpty(value)) {
                continue;
            }
            // 3 处理下划线转驼峰命名
            if (isExistUnderLine(key)) {
                key = this.underLineToCamel(key);
            }
            // 4 获取字段
            Field field = map.getOrDefault(key, null);
            if (ObjectUtils.isEmpty(field)) {
                continue;
            }
            // 5 为特别的值设置参数
            if (isPrimitive(field.getType())) {
                value = getArgument(field.getType(), value);
            }
            // 6 设置参数
            Method method = getSetterMethod(type, field, key);
            if (method != null) {
                method.invoke(clazz, value);
            }
        }
        return clazz;
    }

    private Object getArgument(Class<?> type, Object value) throws Exception {
        if (isPrimitive(type)) {
            String oldType = type.getSimpleName();
            if ("char".equals(oldType)) {
                return value;
            }
            String newType = toUpperCaseFirstOne(oldType);
            Class<?> clazz = "int".equals(oldType) ? Class.forName("java.lang.Integer") : Class.forName("java.lang." + newType);
            if (StringUtils.equals(value.getClass().getSimpleName(), clazz.getSimpleName())) {
                return value;
            }
            if (StringUtils.equalsAnyIgnoreCase("BigDecimal", value.getClass().getSimpleName())) {
                BigDecimal decimal = (BigDecimal) value;
                return decimal.doubleValue();
            }
            Method method = clazz.getMethod(Character.isUpperCase(oldType.charAt(0)) ? "valueOf" : "parse" + newType, String.class);
            return method.invoke(null, value);
        }
        return null;
    }

    private boolean isExistUnderLine(String value) {
        Matcher matcher = this.UNDER_LINE_PATTER.matcher(value);
        return matcher.find();
    }

    private String underLineToCamel(final String value) {
        final StringBuffer buffer = new StringBuffer();
        Matcher matcher = this.UNDER_LINE_PATTER.matcher(value);
        while (matcher.find()) {
            matcher.appendReplacement(buffer, matcher.group(1).toUpperCase());
        }
        matcher.appendTail(buffer);
        return buffer.toString();
    }

    private Method getSetterMethod(Class<?> clazz, Field field, String fileName) throws Exception {
        return clazz.getDeclaredMethod("set" + toUpperCaseFirstOne(fileName), field.getType());
    }

    private boolean isPrimitive(Class<?> clazz) {
        return Integer.class.equals(clazz) || Double.class.equals(clazz) || Float.class.equals(clazz) || Boolean.class.equals(clazz) || Long.class.equals(clazz) || Byte.class.equals(clazz) || Short.class.equals(clazz) || clazz.isPrimitive();
    }

    private String toUpperCaseFirstOne(String fieldName) {
        if (Character.isUpperCase(fieldName.charAt(0))) {
            return fieldName;
        } else {
            return Character.toUpperCase(fieldName.charAt(0)) + fieldName.substring(1);
        }
    }

}

1.5 测试

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.xu.spring.utils.Handel;

@Slf4j
@RestController
@RequestMapping("/hello")
public class HelloController {

    @Autowired
    private RedisTemplate redisTemplate;

    @RequestMapping("/test")
    public Object test(@Handel Student student) {
        return student;
    }
    
}