HTTP的远程请求

HTTP的远程请求

添加坐标

		<dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.9</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>

package com.bosssoft.open.api.login.controller.login;

import com.bosssoft.open.api.login.common.util.ParamUtils;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;

/**
 * 公采云登录对接产品示例
 * 包括：授权码模式、密码模式两种
 * 授权码模式，需要配置外网能访问的域名才能访问（公采云系统进行回调时，不是外网则访问不到）
 *
 * 密码模式，特别声明：建议密码模式用于桌面的客户端，而非浏览器的网站
 *  原因：密码模式获取的token，只能用于接口的调用。当访问公采云页面时，公采云系统会认为未登录，需要重新认证登录。
 *
 * @author lk
 */
@Controller
public class LoginController {

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

    // 配置
    private static final String DOMAIN = "127.0.0.1";
    private static final String PORT = ":18001";
    private static final String ADDRESS = "http://" + DOMAIN + PORT;

    @RequestMapping({"/index", "/"})
    public String toIndex(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 登录成功判断
        String jwtToken = request.getHeader("access_token");
        if (StringUtils.isEmpty(jwtToken) && request.getCookies() != null) {
            Cookie[] cookies = request.getCookies();
            for (Cookie cookie : cookies) {
                if ("access_token".equals(URLDecoder.decode(cookie.getName(), "UTF-8"))) {
                    jwtToken = cookie.getValue();
                }
            }
        }
        log.debug("===jwt信息为===" + jwtToken);
        if (StringUtils.isEmpty(jwtToken)) {
            // 进行登录
            Map<String, Object> params = new HashMap<>(16);
            params.put("response_type", "code");
            params.put("scope", "read write");
            // 申请得到的客户端ID
            params.put("client_id", "gp-gateway-center");
            // 回调地址，必须为外网能访问的域名地址， 并且需要经过URL编码
            String uri = ADDRESS + "/gcy-demo-login/call/back";
            params.put("redirect_uri", URLEncoder.encode(uri, "UTF-8"));
            // 参数可选
            params.put("state", "stateTest");
            params.put("systemRegion", "150601");

            String authorizeUrl = "https://dev.gcycloud.cn/gp-auth-center/oauth/authorize";
            String url = ParamUtils.getUrlParamsByMap(authorizeUrl, params);
            response.sendRedirect(url);
            return "index.html";
        } else {
            return "index.html";
        }
    }

    @RequestMapping("call/back")
    public void callBack(String code, String state, HttpServletResponse response) throws IOException {
        log.debug("code: {}", code);
        log.debug("state: {}", state);
        String tokenUrl = "https://dev.gcycloud.cn/gateway/gp-auth-center/oauth/token";

        Map<String, Object> params = new HashMap<>(16);
        params.put("grant_type", "authorization_code");
        params.put("client_id", "gp-gateway-center");
        params.put("client_secret", "gp-gateway-center-secret");
        params.put("code", code);
        String uri = ADDRESS + "/gcy-demo-login/call/back";
        params.put("redirect_uri", URLEncoder.encode(uri, "UTF-8"));
        String url = ParamUtils.getUrlParamsByMap(tokenUrl, params);
        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpPost httppost = new HttpPost(url);
        CloseableHttpResponse responseResult = httpclient.execute(httppost);
        HttpEntity entity = responseResult.getEntity();
        String result = EntityUtils.toString(entity);
        log.debug(result);
        Map<String, String> map = new Gson().fromJson(result, new TypeToken<Map<String, String>>() {
        }.getType());
        String accessToken = map.get("access_token");

        Cookie tokenCookie = new Cookie("access_token", accessToken);
        tokenCookie.setMaxAge(86400);
        tokenCookie.setPath("/");
        tokenCookie.setDomain(DOMAIN);
        response.addCookie(tokenCookie);
        response.sendRedirect(ADDRESS + "/gcy-demo-login/index");
    }

    @RequestMapping("user")
    @ResponseBody
    public Map<String, Object> getUserInfo(HttpServletRequest request) throws IOException {
        Map<String, Object> result = new HashMap<>();
        // 登录成功判断
        String jwtToken = request.getHeader("access_token");
        if (StringUtils.isEmpty(jwtToken) && request.getCookies() != null) {
            Cookie[] cookies = request.getCookies();
            for (Cookie cookie : cookies) {
                if ("access_token".equals(URLDecoder.decode(cookie.getName(), "UTF-8"))) {
                    jwtToken = cookie.getValue();
                }
            }
        }
        log.debug("===jwt信息为===" + jwtToken);
        if (StringUtils.isEmpty(jwtToken)) {
            result.put("code", "-1");
            result.put("msg", "未登录，请登录！");
            return result;
        }
        String url = "https://dev.gcycloud.cn/gateway/gp-auth-center/rest/v1/user/userInfo";
        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpGet httpGet = new HttpGet(url);
        httpGet.addHeader("access_token", jwtToken);
        CloseableHttpResponse responseResult = httpclient.execute(httpGet);
        HttpEntity entity = responseResult.getEntity();
        String userInfo = EntityUtils.toString(entity);
        log.debug(userInfo);
        result = new Gson().fromJson(userInfo, new TypeToken<Map<String, Object>>() {}.getType());
        return result;
    }

    // 退出接口
    @RequestMapping("logout")
    public void logout(HttpServletResponse response) throws IOException {
        String logoutSuccessUrl = URLEncoder.encode(ADDRESS + "/gcy-demo-login/index", "UTF-8");
        Cookie jwtCookie = new Cookie("access_token", null);
        jwtCookie.setMaxAge(0);
        jwtCookie.setDomain(DOMAIN);
        jwtCookie.setPath("/");
        response.addCookie(jwtCookie);
        response.sendRedirect("https://dev.gcycloud.cn/gateway/api/oauth/logout?logoutRedirectUrl=" + logoutSuccessUrl);
    }
}

package com.bosssoft.open.api.login.common.util;

import org.springframework.util.CollectionUtils;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.StringJoiner;

/**
 * 2020/5/25
 * 参数处理工具类
 *
 * @author lk
 */
public class ParamUtils {

    /**
     * 将request中的请求参数格式修正
     *
     * @param requestParams request中的请求参数
     * @return 参数
     */
    public static Map<String, String> parameter2Map(Map<String, String[]> requestParams) {
        Map<String, String> params = new HashMap<>();
        StringJoiner stringJoiner = null;
        for (Entry<String, String[]> stringEntry : requestParams.entrySet()) {
            stringJoiner = new StringJoiner(",", "", "");
            String key = stringEntry.getKey();
            String[] value = stringEntry.getValue();
            Arrays.asList(value).forEach(stringJoiner::add);
            params.put(key, stringJoiner.toString());
        }
        return params;
    }

    /**
     * 将map转换成url
     *
     * @param map 参数MAP
     * @return url参数串
     */
    public static String getUrlParamsByMap(String baseUrl, Map<String, Object> map) {
        if (CollectionUtils.isEmpty(map)) {
            return baseUrl;
        }
        StringJoiner urlJoiner = new StringJoiner("&", "", "");
        for (Entry<String, Object> entry : map.entrySet()) {
            if (entry.getValue() != null) {
                urlJoiner.add(entry.getKey().concat("=").concat(entry.getValue().toString()));
            }
        }
        baseUrl = baseUrl.endsWith("?") ? baseUrl : baseUrl.concat("?");
        return baseUrl.concat(urlJoiner.toString());
    }
}

package com.mall.utils;

import com.alibaba.fastjson.JSONObject;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.http.*;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.util.*;

public class HttpUtil {

    /**
     * Http Get方法
     *
     * @param url
     * @param param
     * @return
     */
    public static String doGet(String url,Map<String, String> headMap,Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpclient = HttpClients.createDefault();
        String resultString = "";
        CloseableHttpResponse response = null;
        try {
            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }

            URI uri = builder.build();

            // 创建http GET请求
            HttpGet httpGet = new HttpGet(uri);

            if (headMap != null && !headMap.isEmpty()) {
                for (String key : headMap.keySet()) {

                    httpGet.addHeader(key, headMap.get(key));
                }
            }

            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {

        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpclient.close();
            } catch (IOException e) {

            }
        }
        return resultString;
    }


    /**
     * post请求(用于key-value格式的参数)
     * @param url
     * @param params
     * @return
     */
    public static String doPost(String url, Map params){

        BufferedReader in = null;
        try {
            // 定义HttpClient  
            HttpClient client = new DefaultHttpClient();
            // 实例化HTTP方法  
            HttpPost request = new HttpPost(url);
//            request.setURI(new URI(url));

            //设置参数
            List<NameValuePair> nvps = new ArrayList<NameValuePair>();
            for (Iterator iter = params.keySet().iterator(); iter.hasNext();) {
                String name = (String) iter.next();
                String value = String.valueOf(params.get(name));
                nvps.add(new BasicNameValuePair(name, value));

                //System.out.println(name +"-"+value);
            }
            request.setEntity(new UrlEncodedFormEntity(nvps,HTTP.UTF_8));

            HttpResponse response = client.execute(request);
            int code = response.getStatusLine().getStatusCode();
            //请求成功
            if(code == 200){
                in = new BufferedReader(new InputStreamReader(response.getEntity()
                        .getContent(),"utf-8"));
                StringBuffer sb = new StringBuffer("");
                String line = "";
                String NL = System.getProperty("line.separator");
                while ((line = in.readLine()) != null) {
                    sb.append(line + NL);
                }

                in.close();

                return sb.toString();
            }
            else{
                System.out.println("状态码：" + code);
                return null;
            }
        }
        catch(Exception e){
            e.printStackTrace();

            return null;
        }
    }
    public static void main(String[] args) throws Exception{
    	doPostObject();
	}
    /**
     * post请求(用于key-value格式的参数)

     * @return
     */
	public static void doPostObject( ) throws Exception{ // 1.设置参数
		List<NameValuePair> pairs = new ArrayList<NameValuePair>();
		BasicNameValuePair basicNameValuePair1 = new BasicNameValuePair("platformId", "20");
		BasicNameValuePair basicNameValuePair2 = new BasicNameValuePair("backhandName", "3333333333");
		BasicNameValuePair basicNameValuePair3 = new BasicNameValuePair("accountId", "61770298");
		BasicNameValuePair basicNameValuePair4 = new BasicNameValuePair("invoiceType", "5");
		pairs.add(basicNameValuePair1);
		pairs.add(basicNameValuePair2);
		pairs.add(basicNameValuePair3);
		pairs.add(basicNameValuePair4);
		HttpEntity urlEncodedFormEntity = new UrlEncodedFormEntity(pairs, "UTF-8");
		// 2.设置地址
		String url = "http://gateway.isv.jd.com/trade-service/buyer/backhand/saveBackhandInfo";
		HttpPost httpRequestBase = new HttpPost(url);
		httpRequestBase.setEntity(urlEncodedFormEntity);
		// 3.设置头信息
		httpRequestBase.addHeader("Cache-Control", "no-cache");
		httpRequestBase.addHeader("Connection", "Keep-Alive");
		httpRequestBase.addHeader("Pragma", "no-cache");
//		httpRequestBase.addHeader("Content-Type", "application/json; charset=UTF-8");
		// 4.调用
        HttpClient client = new DefaultHttpClient();
		HttpResponse response = client.execute(httpRequestBase);
		HttpEntity entity = response.getEntity();
		System.out.println(EntityUtils.toString(entity, "UTF-8"));
	}

    /**
     * post请求（用于请求json格式的参数）
     * @param url
     * @param params
     * @return
     */
    public static String doPost(String url, String params) throws Exception {

        CloseableHttpClient httpclient = HttpClients.createDefault();
        // 创建httpPost
        HttpPost httpPost = new HttpPost(url);
        httpPost.setHeader("Accept", "application/json");
        httpPost.setHeader("Content-Type", "application/json");
        String charSet = "UTF-8";
        StringEntity entity = new StringEntity(params, charSet);
        httpPost.setEntity(entity);
        CloseableHttpResponse response = null;
        try {
            response = httpclient.execute(httpPost);
            StatusLine status = response.getStatusLine();
            int state = status.getStatusCode();
            if (state == HttpStatus.SC_OK) {
                HttpEntity responseEntity = response.getEntity();
                String jsonString = EntityUtils.toString(responseEntity);
                return jsonString;
            }
            else
                throw new RuntimeException("请求返回:"+state+"("+url+")");
        }catch (Exception e) {
			e.printStackTrace();
		}finally {
            if (response != null) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            try {
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
		return null;
    }
}