want to change value of request before reaching controller in SpringBoot

i have a requirement in my project. i want to change the value of sended data through postman, like as if there is three parameter like as id, name, salary.now i am sending the data through postman } "id":1, "name":"dhiraj",
"salary":787878 } now when send the data,it should be save as actual data in database .but if i am sending like as that } "id":2, "name":"", "salary":787878 } then name column should be null instead of empty in database.i am using following code for that, but not getting exact output,please help me .

'package com.httpmodify.test.HttpModify.filter;

import java.io.BufferedReader;
import java.io.IOException;
import java.util.Locale;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.LocaleResolver;

import com.httpmodify.test.HttpModify.model.Student;

@Component
public class RequestModify implements Filter{
    private static Logger log=LoggerFactory.getLogger(Student.class);


    

    private static final String ACCEPT_LANGUAGE = "Accept-Language";

    @Autowired
    LocaleResolver localeResolver;

    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // Need to add code if something is required to be initialized.
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain)
            throws IOException, ServletException {

        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        StringBuilder requestJson = new StringBuilder();
        String responseJson = "";
        BufferedReader bufferedReader = request.getReader();
        String line = null;
        if (bufferedReader != null) {
            while (null != (line = bufferedReader.readLine())) {
                requestJson.append(line);
            }
        }

        if (request.getMethod().equals("POST")) {
            RestAPIRequestWrapper requestWrapper = new RestAPIRequestWrapper(request,
                    requestJson.toString().getBytes());
            

            RestAPIResponseWrapper responseWrapper = new RestAPIResponseWrapper(response);
            chain.doFilter(requestWrapper, responseWrapper);
            response.setContentType("text/plain");
            responseJson = responseWrapper.getCaptureAsString();
            response.getWriter().write(responseWrapper.getCaptureAsString());
        } else {
            chain.doFilter(request, response);
        }
        
    }

    @Override
    public void destroy() {
        // Need to write some code if some resource needs to be destroyed.
    }

    /**
     * @param locale
     * @return String
     */
    private String getAcceptLanguage(String locale) {
        return locale != null ? locale : "en";
    }


}
'
package com.httpmodify.test.HttpModify.filter;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

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

/**
 * @author Ashwini Upadhyay
 * @Version 1.0
 * @date 2019-Apr-02 12:57:38 PM 
 */
public class RestAPIRequestWrapper extends HttpServletRequestWrapper {

    private final ByteArrayInputStream decryptedDataBAIS;

    private HttpServletRequest wrapped;

    private Map<String, String[]> parameterMap;

    private Map<String, String> headerMap = new HashMap<>();

    public RestAPIRequestWrapper(HttpServletRequest wrapped, byte[] decryptedData) {
        super(wrapped);
        this.wrapped = wrapped;
        decryptedDataBAIS = new ByteArrayInputStream(decryptedData);
    }

    public RestAPIRequestWrapper(HttpServletRequest wrapped, byte[] decryptedData, Map<String, String> headerMap) {
        super(wrapped);
        this.wrapped = wrapped;
        decryptedDataBAIS = new ByteArrayInputStream(decryptedData);
        this.headerMap = headerMap;
    }

    public RestAPIRequestWrapper(HttpServletRequest wrapped) {
        super(wrapped);
        this.wrapped = wrapped;
        decryptedDataBAIS = new ByteArrayInputStream("".getBytes());
    }

    public RestAPIRequestWrapper(HttpServletRequest wrapped, String paramstr) {
        super(wrapped);
        this.wrapped = wrapped;
        decryptedDataBAIS = null;
        String[] paramsArr = paramstr.split("&");
        for (int i = 0; i < paramsArr.length; i++) {
            String[] paramArr = paramsArr[i].split("=");
            addParameter(paramArr[0], paramArr[1]);
        }
    }

    @Override
    public String getContentType() {
        return super.getContentType();
    }

    @Override
    public BufferedReader getReader() throws UnsupportedEncodingException {
        return new BufferedReader(new InputStreamReader(decryptedDataBAIS, "UTF_8"));
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        return new ServletInputStream() {
            @Override
            public int read() {
                return decryptedDataBAIS.read();
            }

            @Override
            public boolean isFinished() {
                return decryptedDataBAIS.available() == 0;
            }

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

            @Override
            public void setReadListener(ReadListener arg0) {
                throw new RuntimeException("Not implemented");
            }
        };
    }

    @Override
    public Enumeration<String> getParameterNames() {
        if (parameterMap == null) {
            return wrapped.getParameterNames();
        }

        return Collections.enumeration(parameterMap.keySet());
    }

    @Override
    public String[] getParameterValues(String name) {
        if (parameterMap == null) {
            return wrapped.getParameterValues(name);
        }
        return parameterMap.get(name);
    }

    @Override
    public String getParameter(String name) {
        if (parameterMap == null) {
            return wrapped.getParameter(name);
        }

        String[] strings = parameterMap.get(name);
        if (strings != null) {
            return strings[0];
        }
        return null;
    }

    public void addParameter(String name, String value) {
        if (parameterMap == null) {
            parameterMap = new HashMap<>();
            parameterMap.putAll(wrapped.getParameterMap());
        }
        String[] values = parameterMap.get(name);
        if (values == null) {
            values = new String[0];
        }
        List<String> list = new ArrayList<>(values.length + 1);
        list.addAll(Arrays.asList(values));
        list.add(value);
        parameterMap.put(name, list.toArray(new String[0]));
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        if (parameterMap == null) {
            return wrapped.getParameterMap();
        }

        return Collections.unmodifiableMap(parameterMap);
    }

    @Override
    public String getHeader(String headerName) {
        String headerValue = null;
        if (headerMap.containsKey(headerName)) {
            headerValue = headerMap.get(headerName);
        } else {
            headerValue = super.getHeader(headerName);
        }
        return headerValue;
    }

    @Override
    public Enumeration<String> getHeaders(String name) {
        Set<String> values = new HashSet<>();
        if (headerMap.containsKey(name) || name.equalsIgnoreCase("Authorization")) {
            if (headerMap.get(name) != null)
                values.add(headerMap.get(name));

        } else {
            for (Enumeration<String> e = super.getHeaders(name); e.hasMoreElements();) {
                String headerValue = e.nextElement();
                values.add(headerValue);
            }
        }
        return Collections.enumeration(values);
    }

    @Override
    public Enumeration<String> getHeaderNames() {
        Set<String> names = new HashSet<>();
        for (String name : headerMap.keySet()) {
            names.add(name);
        }
        for (Enumeration<String> e = super.getHeaderNames(); e.hasMoreElements();) {
            String headerName = e.nextElement();
            if (!headerName.equalsIgnoreCase("Authorization"))
                names.add(headerName);
        }
        return Collections.enumeration(names);
    }

    public void addHeader(String name, String value) {
        headerMap.put(name, value);
    }

}

package com.httpmodify.test.HttpModify.filter;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

/**
 * @author Ashwini Upadhyay
 * @Version 1.0
 * @date 2019-Apr-02 12:57:17 PM 
 */
public class RestAPIResponseWrapper extends HttpServletResponseWrapper {

    private final ByteArrayOutputStream capture;
    private ServletOutputStream output;
    private PrintWriter writer;

    public RestAPIResponseWrapper(HttpServletResponse response) {
        super(response);
        capture = new ByteArrayOutputStream(response.getBufferSize());
    }

    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        if (writer != null) {
            throw new IllegalStateException("getWriter() has already been called on this response.");
        }

        if (output == null) {
            output = new ServletOutputStream() {
                @Override
                public void write(int b) throws IOException {
                    capture.write(b);
                }

                @Override
                public void flush() throws IOException {
                    capture.flush();
                }

                @Override
                public void close() throws IOException {
                    capture.close();
                }

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

                @Override
                public void setWriteListener(WriteListener arg0) {

                }
            };
        }

        return output;
    }

    @Override
    public PrintWriter getWriter() throws IOException {
        if (output != null) {
            throw new IllegalStateException("getOutputStream() has already been called on this response.");
        }

        if (writer == null) {
            writer = new PrintWriter(new OutputStreamWriter(capture, getCharacterEncoding()));
        }

        return writer;
    }

    @Override
    public void flushBuffer() throws IOException {
        super.flushBuffer();

        if (writer != null) {
            writer.flush();
        } else if (output != null) {
            output.flush();
        }
    }

    public byte[] getCaptureAsBytes() throws IOException {
        if (writer != null) {
            writer.close();
        } else if (output != null) {
            output.close();
        }
        return capture.toByteArray();
    }

    public String getCaptureAsString() throws IOException {
        return new String(getCaptureAsBytes(), getCharacterEncoding());
    }
}

After getting the request in the controller, you can validate the input value. If the input for the name is empty then make it null, and perform the same operation for other input values. After performing these operations save the object to the database.