HttpServletResponse工具类和HttpServletRequest工具类,前台参数接收方式和后台返回(JSON)数据格式

package cn.utils;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.util.UrlPathHelper;

import javax.servlet.http.HttpServletRequest;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;



/**
 * HttpServletRequest 工具类
 */
public class RequestUtils {

	private static final Logger log = LoggerFactory
			.getLogger(RequestUtils.class);

	/**
	 * HTTP POST请求
	 */
	public static final String POST = "POST";



	/**
	 * UTF-8编码
	 */
	public static final String UTF8 = "UTF-8";



	/**
	 * 获取QueryString的参数，并使用URLDecoder以UTF-8格式转码。如果请求是以post方法提交的，
	 * 那么将通过HttpServletRequest#getParameter获取。
	 *
	 * @param request
	 *            web请求
	 * @param name
	 *            参数名称
	 * @return
	 */
	public static String getQueryParam(HttpServletRequest request, String name) {
		if (StringUtils.isBlank(name)) {
			return null;
		}
		if (request.getMethod().equalsIgnoreCase(POST)) {
			return request.getParameter(name);
		}
		String s = request.getQueryString();
		if (StringUtils.isBlank(s)) {
			return null;
		}
		try {
			s = URLDecoder.decode(s, UTF8);
		} catch (UnsupportedEncodingException e) {
			log.error("encoding " + UTF8 + " not support?", e);
		}
		String[] values = parseQueryString(s).get(name);
		if (values != null && values.length > 0) {
			return values[values.length - 1];
		} else {
			return null;
		}
	}

	@SuppressWarnings("unchecked")
	public static Map getQueryParams(HttpServletRequest request) {
		Map map;
		if (request.getMethod().equalsIgnoreCase(POST)) {
			map = request.getParameterMap();
		} else {
			String s = request.getQueryString();
			if (StringUtils.isBlank(s)) {
				return new HashMap();
			}
			try {
				s = URLDecoder.decode(s, UTF8);
			} catch (UnsupportedEncodingException e) {
				log.error("encoding " + UTF8 + " not support?", e);
			}
			map = parseQueryString(s);
		}

		Map params = new HashMap(map.size());
		int len;
		for (Map.Entry entry : map.entrySet()) {
			len = entry.getValue().length;
			if (len == 1) {
				params.put(entry.getKey(), entry.getValue()[0]);
			} else if (len > 1) {
				params.put(entry.getKey(), entry.getValue());
			}
		}
		return params;
	}

	/**
	 *
	 * Parses a query string passed from the client to the server and builds a
	 * HashTable object with key-value pairs. The query string
	 * should be in the form of a string packaged by the GET or POST method,
	 * that is, it should have key-value pairs in the form key=value,
	 * with each pair separated from the next by a & character.
	 *
	 * 

	 * A key can appear more than once in the query string with different
	 * values. However, the key appears only once in the hashtable, with its
	 * value being an array of strings containing the multiple values sent by
	 * the query string.
	 *
	 * 

	 * The keys and values in the hashtable are stored in their decoded form, so
	 * any + characters are converted to spaces, and characters sent in
	 * hexadecimal notation (like %xx) are converted to ASCII characters.
	 *
	 * @param s
	 *            a string containing the query to be parsed
	 *
	 * @return a HashTable object built from the parsed key-value
	 *         pairs
	 *
	 * @exception IllegalArgumentException
	 *                if the query string is invalid
	 *
	 */
	public static Map parseQueryString(String s) {
		String valArray[] = null;
		if (s == null) {
			throw new IllegalArgumentException();
		}
		Map ht = new HashMap();
		StringTokenizer st = new StringTokenizer(s, "&");
		while (st.hasMoreTokens()) {
			String pair = (String) st.nextToken();
			int pos = pair.indexOf(‘=‘);
			if (pos == -1) {
				continue;
			}
			String key = pair.substring(0, pos);
			String val = pair.substring(pos + 1, pair.length());
			if (ht.containsKey(key)) {
				String oldVals[] = (String[]) ht.get(key);
				valArray = new String[oldVals.length + 1];
				for (int i = 0; i  getRequestMap(HttpServletRequest request,
                                                    String prefix) {
		return getRequestMap(request, prefix, false);
	}

	public static Map getRequestMapWithPrefix(
            HttpServletRequest request, String prefix) {
		return getRequestMap(request, prefix, true);
	}

	@SuppressWarnings("unchecked")
	private static Map getRequestMap(
            HttpServletRequest request, String prefix, boolean nameWithPrefix) {
		Map map = new HashMap();
		Enumeration names = request.getParameterNames();
		String name, key, value;
		while (names.hasMoreElements()) {
			name = names.nextElement();
			if (name.startsWith(prefix)) {
				key = nameWithPrefix ? name : name.substring(prefix.length());
				value = StringUtils.join(request.getParameterValues(name), ‘,‘);
				map.put(key, value);
			}
		}
		return map;
	}

	/**
	 * 获取访问者IP
	 *
	 * 在一般情况下使用Request.getRemoteAddr()即可，但是经过nginx等反向代理软件后，这个方法会失效。
	 *
	 * 本方法先从Header中获取X-Real-IP，如果不存在再从X-Forwarded-For获得第一个IP(用,分割)，
	 * 如果还不存在则调用Request .getRemoteAddr()。
	 *
	 * @param request
	 * @return
	 */
	public static String getIpAddr(HttpServletRequest request) {
		String ip = request.getHeader("X-Real-IP");
		if (!StringUtils.isBlank(ip) && !"unknown".equalsIgnoreCase(ip)) {
			if(ip.contains("../")||ip.contains("..\\")){
				return "";
			}
			return ip;
		}
		ip = request.getHeader("X-Forwarded-For");
		if (!StringUtils.isBlank(ip) && !"unknown".equalsIgnoreCase(ip)) {
			// 多次反向代理后会有多个IP值，第一个为真实IP。
			int index = ip.indexOf(‘,‘);
			if (index != -1) {
				ip= ip.substring(0, index);
			}
			if(ip.contains("../")||ip.contains("..\\")){
				return "";
			}
			return ip;
		} else {
			ip=request.getRemoteAddr();
			if(ip.contains("../")||ip.contains("..\\")){
				return "";
			}
			if(ip.equals("0:0:0:0:0:0:0:1")){
				ip="127.0.0.1";
			}
			return ip;
		}

	}

	/**
	 * 获得当的访问路径
	 *
	 * HttpServletRequest.getRequestURL+"?"+HttpServletRequest.getQueryString
	 *
	 * @param request
	 * @return
	 */
	public static String getLocation(HttpServletRequest request) {
		UrlPathHelper helper = new UrlPathHelper();
		StringBuffer buff = request.getRequestURL();
		String uri = request.getRequestURI();
		String origUri = helper.getOriginatingRequestUri(request);
		buff.replace(buff.length() - uri.length(), buff.length(), origUri);
		String queryString = helper.getOriginatingQueryString(request);
		if (queryString != null) {
			buff.append("?").append(queryString);
		}
		return buff.toString();
	}


	public static Map getSignMap(HttpServletRequest request){
		Mapparam=new HashMap();
		Enumeration penum=(Enumeration) request.getParameterNames();
		while(penum.hasMoreElements()){
			String pKey=(String) penum.nextElement();
			String value=request.getParameter(pKey);
			//sign和uploadFile不参与 值为空也不参与
			if(!pKey.equals("sign")&&!pKey.equals("uploadFile")
					&&StringUtils.isNotBlank(value)){
				param.put(pKey,value);
			}
		}
		return param;
	}

	public static void main(String[] args) {
	}
}

package cn.utils;

import java.io.IOException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * HttpServletResponse 工具类
 */
public final class ResponseUtils {
    public static final Logger log = LoggerFactory
            .getLogger(ResponseUtils.class);

    /**
     * 发送文本。使用UTF-8编码。
     *
     * @param response
     *            HttpServletResponse
     * @param text
     *            发送的字符串
     */
    public static void renderText(HttpServletResponse response, String text) {
        render(response, "text/plain;charset=UTF-8", text);
    }

    /**
     * 发送json。使用UTF-8编码。
     *
     * @param response
     *            HttpServletResponse
     * @param text
     *            发送的字符串
     */
    public static void renderJson(HttpServletResponse response, String text) {
        render(response, "application/json;charset=UTF-8", text);
    }

    /**
     * 发送xml。使用UTF-8编码。
     *
     * @param response
     *            HttpServletResponse
     * @param text
     *            发送的字符串
     */
    public static void renderXml(HttpServletResponse response, String text) {
        render(response, "text/xml;charset=UTF-8", text);
    }

    /**
     * 发送内容。使用UTF-8编码。
     *
     * @param response
     * @param contentType
     * @param text
     */
    public static void render(HttpServletResponse response, String contentType,
                              String text) {
        response.setContentType(contentType);
        response.setHeader("Pragma", "No-cache");
        response.setHeader("Cache-Control", "no-cache");
        response.setDateHeader("Expires", 0);
        try {
            response.getWriter().write(text);
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        }
    }

    public static void renderApiJson(HttpServletResponse response,
                                     HttpServletRequest request,ApiResponse apiResult) {
        //js跨域请求
        String callback = request.getParameter("callback");
        if(StringUtils.isNotBlank(callback)){
            ResponseUtils.renderJson(response,callback+"(" + apiResult.toString() + ")" );
        }else{
            ResponseUtils.renderJson(response, apiResult.toString());
        }
    }
}

package cn.utils;

public class ApiResponse {
	
	public ApiResponse(String body, String message, String status) {
		super();
		this.body = body;
		this.message = message;
		this.status = status;
	}

	/**
	 * 返回信息主体
	 */
	public String getBody() {
		return body;
	}
	
	public void setBody(String body) {
		this.body = body;
	}
	
	/**
	 * API调用提示信息
	 */
	public String getMessage() {
		return message;
	}
	
	public void setMessage(String message) {
		this.message = message;
	}
	
	/**
	 * API接口调用状态
	 */
	public String getStatus() {
		return status;
	}
	
	public void setStatus(String status) {
		this.status = status;
	}

	@Override
	public String toString() {
		return "{\"body\":" + body + ", \"message\":" + message + ",\"status\":" + status + "}";
	}

	private String body;
	private String message;
	private String status;
}