RequestUtils.java 操作类
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 < oldVals.length; i++) {
valArray[i] = oldVals[i];
}
valArray[oldVals.length] = val;
} else {
valArray = new String[1];
valArray[0] = val;
}
ht.put(key, valArray);
}
return ht;
}
public static Map 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) {
}
}
ResponseUtils.java 操作类
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());
}
}
}
ApiResponse.java
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;
}