HttpUtil工具类

package com.ityemu.common.utils.http;

import com.ityemu.common.utils.string.StringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.*;

import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;


/**
 * @ClassName: HttpUtil
 * @Description: http请求获取
 * @Author: ityemu
 */
public class HttpUtil {
     //日志
    private static final Logger logger = LoggerFactory.getLogger(HttpUtil.class);

    /**
     * 判断是否为Ajax请求
     *
     * @param request 用户发送的请求
     * @return 是否为Ajax请求
     */
    public static boolean isAjax(ServletRequest request){
        return "XMLHttpRequest".equalsIgnoreCase(((HttpServletRequest) request).getHeader("X-Requested-With"));
    }

    /**
     * 响应结果。
     *
     * @param response 响应用户请求信息
     * @param result 响应结果
     */
    public static void out(HttpServletResponse response, String result){

        PrintWriter out = null;
        try {
            response.setContentType("application/json;charset=UTF-8");
            response.setCharacterEncoding("UTF-8");
            out = response.getWriter();
            out.println(result);
        } catch (Exception e) {
            logger.error("输出JSON格式数据异常：{}", e);
        }finally{
            if(null != out){
                out.flush();
                out.close();
            }
        }
    }


    /**
     * 获取Request请求
     *
     * @return 用户请求
     */
    public static HttpServletRequest getRequest(){
        ServletRequestAttributes requestAttributes
                = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();

        return requestAttributes==null? null : requestAttributes.getRequest();
    }

    /**
     * 获取Response响应
     *
     * @return reponse响应
     */
    public static HttpServletResponse getResponse(){
        ServletRequestAttributes requestAttributes
                = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
        return requestAttributes==null? null : requestAttributes.getResponse();
    }

    /**
     * 获取session
     *
     * @return session信息
     */
    public static HttpSession getSession(){
        return getRequest().getSession(false);
    }

    /**
     * 设置session
     * @param name session的key
     * @param value key对应的value
     */
    public static void setSessionAttribute(String name,Object value){
        HttpSession session = getSession();
        if(session != null){
            session.setAttribute(name, value);
        }
    }

    /**
     * 获取session中的属性值。
     *
     * @param name session中的key值
     * @return key对应的值
     */
    public static Object getSessionAttribute(String name){
        HttpSession session = getSession();
        return session == null ? null : session.getAttribute(name);
    }

    /**
     * 移除session中的属性。
     *
     * @param name 待移除的属性
     */
    public static void removeSessionAttribute(String name){
        HttpSession session = getSession();
        session.removeAttribute(name);
    }

    /**
     * 获取请求中的参数值。
     *
     * @param name 请求中的属性名
     * @return 对应的值
     */
    public static String getRequestParameter(String name){
        HttpServletRequest request = getRequest();
        return request.getParameter(name);
    }

    /**
     * 获取IP。
     * @return IP地址
     */
    public final static String getIpAddress(){
        HttpServletRequest request = getRequest();

        // 获取请求主机IP地址,如果通过代理进来，则透过防火墙获取真实IP地址
        String ip = request.getHeader("X-Forwarded-For");

        if (StringUtil.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
            if (StringUtil.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (StringUtil.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (StringUtil.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_CLIENT_IP");
            }
            if (StringUtil.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
            }
            if (StringUtil.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
        } else if (ip.length() > 15) {
            String[] ips = ip.split(",");
            for (int index = 0; index < ips.length; index++) {
                String strIp = (String) ips[index];
                if (!("unknown".equalsIgnoreCase(strIp))) {
                    ip = strIp;
                    break;
                }
            }
        }
        return ip;
    }



    /**
     * 发送POST请求。
     *
     * @param http 请求路径
     * @param content 请求参数
     * @return 响应结果
     */
    public static String sendPostRequest(String http, String content){
        return sendRequest(http, content, "POST");
    }

    /**
     * 发送GET请求。
     *
     * @param http 请求路径+参数
     * @return 响应结果
     */
    public static String sendGetRequest(String http) {
        return sendRequest(http, null, "GET");
    }

    /**
     * 发送请求。
     * @param http 请求路径
     * @param content 请求参数，type为GET时为空。
     * @param type 请求类型
     * @return 响应结果
     */
    private static String sendRequest(String http, String content, String type) {
        StringBuffer result = new StringBuffer("");
        try {
            // 定义URL
            URL url = new URL(http);
            // 打开HTTP连接
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            // 设置是否向connect输出，默认为false
            conn.setDoOutput(true);
            // 设置是否读取connect，默认为true
            conn.setDoInput(true);
            // 设置请求方法，默认为GET
            conn.setRequestMethod(type);
            // 设置请求不使用缓存
            conn.setUseCaches(false);
            // 设置请求属性
            conn.setRequestProperty("Content-Type", "application/json; charset=UTF-8");
            conn.setRequestProperty("Accept-Charset", "UTF-8");
            conn.setRequestProperty("contentType", "UTF-8");
            conn.setRequestProperty("accept","application/json");
            conn.connect();
            // 当请求类型为POST时，写入请求参数内容
            if("POST".equals(type)){
                DataOutputStream dos = new DataOutputStream(conn.getOutputStream());
                dos.write(content.getBytes("UTF-8"));
                dos.flush();
                dos.close();
            }
            //获取响应结果
            BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
            String line = "";
            while ((line = reader.readLine()) != null) {
                result.append(line);
            }
            reader.close();
            conn.disconnect();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result.toString();
    }
}