使用情景：在一个项目中需要通过接口调用另一个项目的某一个方法时使用。
 
代码如下：
 发送post请求工具类：
 
package com.cosmoseye.core.utils;

import java.io.IOException;
import java.util.List;
import java.util.concurrent.Future;

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.springframework.scheduling.annotation.AsyncResult;

import com.alibaba.fastjson.JSONObject;
import com.cosmoseye.core.entity.ArticleAnalysisDto;

public class SendPost {
	
    public static Future<String> doPostJson(List<ArticleAnalysisDto> articleList, String dir ) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost("http://127.0.0.1:8084/detail/rewardQuest");
            // 创建请求内容
            JSONObject json = new JSONObject();
            json.put("articleList", articleList);
            json.put("dir", dir);
            StringEntity stringEntity = new StringEntity(json.toJSONString(),"utf-8");
            httpPost.setEntity(stringEntity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
                return new AsyncResult<String>("failed");
            }
        }

        return new AsyncResult<String>("succeed");
    }
}
 
请求接收端代码：
 
package com.cosmoseyePdf.pdf.controller;

import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.cosmoseyePdf.component.service.GeneratePdfService;
import com.cosmoseyePdf.core.annotation.LoginRequired;
import com.cosmoseyePdf.core.entity.ArticleAnalysisDto;

@RestController
@RequestMapping("/detail")
public class GenreatePdfController {
	
    @Autowired
    private GeneratePdfService generatePdfService;
	@Autowired
	protected HttpServletRequest request;
	
	/**
	 * <pre>
	 * 抓取pdf并保存
	 * </pre>
	 * @param session
	 * @return
	 * @throws IOException 
	 * @throws InterruptedException 
	 * @throws ExecutionException 
	 */
	@LoginRequired
	@RequestMapping(value = "/rewardQuest", method=RequestMethod.POST)
	public Future<String> generatepdf(@RequestBody  String json) {
		
		JSONObject jsonObject = JSON.parseObject(json);
		String dir = jsonObject.getString("dir");
		String aListStr = jsonObject.getString("articleList");
		ArrayList<ArticleAnalysisDto> articleList = JSON.parseObject(aListStr, new TypeReference<ArrayList<ArticleAnalysisDto>>() {});

		Future<String> future= generatePdfService.generatePdf(articleList, dir);
		
		return future;
	}

}

 
这里写请求的接收端主要是想表达，通过json格式如何实现参数的传递与接收，里面包含了一些自定义的实体类和方法，可合理删减，整体的代码可以直接使用。在需要请求该功能的地方，直接通过类名调用post请求发送的方法即可。

java向第三方发送post请求，数据格式为json。废话不多说，直接上代码
 
import com.alibaba.fastjson.JSON;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.InputStreamRequestEntity;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.RequestEntity;
import org.apache.commons.httpclient.params.HttpMethodParams;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.omg.Messaging.SYNC_WITH_TRANSPORT;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

public class HttpRequestTest {


    public static void main(String [] args ) throws Exception {
        httpPost();
    }



// get请求
// 实际的请求头设置还不完善，以后再补充
  public static void httpGet() throws IOException {
        HttpClient client = new HttpClient();
        GetMethod getMethod = new GetMethod("http://。。。");
        int i = client.executeMethod(getMethod);
        System.out.println(new String(getMethod.getResponseBody()));
    }

    // 向第三方接口发送一个post 请求的参数的看具体的要求，该接口想要的数据是什么类型，如果是json，那就把参数转换为json类型，其他的转换为其它类型，如阿里的接口参数就有的不是json类型
    public static void httpPost() throws Exception {

        // json格式的参数，我们可以用map来封装参数，然后将参数转换为json格式
        Map<String ,Object> params = new HashMap<>();
        params.put("articleID",44);
        params.put("columnID",44);
        params.put("desColumnID",44);
        params.put("title","44");
        params.put("subTitle","44");
        params.put("leadTitle","44");
        params.put("abstract","44");
        params.put("articleType",0);
        params.put("source","44");
        params.put("tag","44");
        params.put("optUser","44");
        params.put("author","44");
        params.put("editor","44");
        params.put("liability","44");
        params.put("status",1);
        params.put("content","44");
        params.put("imgUrl","44");
        String paramsJson = JSON.toJSONString(params); // 将参数转换为json字符串
        System.out.println(paramsJson);

        //String params="{\"articleID\":44,\"columnID\":44,\"desColumnID\":44,\"title\":\"44\",\"subTitle\":\"44\",\"leadTitle\":\"44\",\"abstract\":\"44\",\"articleType\":0,\"source\":44\",\"tag\":\"44\",\"optUser\":\"44\",\"author\":\"44\",\"editor\":\"44\",\"liability\":\"44\",\"status\":1,\"content\":\"44\",\"imgUrl\":\"http://dev-file.aimingtai.com/webdata/45/images/2018/0829/15355154473121002.jpg\"}";


        // 服务端通常是根据请求头（headers）中的 Content-Type 字段来获知请求中的消息主体是用何种方式编码，再对主体进行解析。所以说到 POST 提交数据方案，包含了 Content-Type 和消息主体编码方式两部分
        HttpClient client = new HttpClient(); // 客户端实例化
        PostMethod postMethod = new PostMethod("http://。。。。"); // 请求方法post，可以将请求路径传入构造参数中
        postMethod.addRequestHeader("Content-type", "application/json; charset=utf-8");

        byte[] requestBytes = paramsJson.getBytes("utf-8"); // 将参数转为二进制流
        InputStream inputStream = new ByteArrayInputStream(requestBytes, 0,
                requestBytes.length);
        RequestEntity requestEntity = new InputStreamRequestEntity(inputStream,
                requestBytes.length, "application/json; charset=utf-8"); // 请求体
        postMethod.setRequestEntity(requestEntity);   // 将参数放入请求体

        int i = client.executeMethod(postMethod);  // 执行方法
        System.out.println("请求状态"+i); 
        // 这里因该有判断的，根据请求状态判断请求是否成功，然后根据第三方接口返回的数据格式，解析出我们需要的数据
        
        byte[] responseBody = postMethod.getResponseBody(); // 得到相应数据
        String s = new String(responseBody);
        System.out.println(s);

    }



}

 
本篇博客会持续更新，用来记录自己的学习

1、java原生httpClient4.5 post请求 
 
import java.util.HashMap;
import java.util.Map;

import net.sf.json.JSONObject;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.config.RequestConfig;
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.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class SendHttp {	
	/**
	 * java httpClient4.5 post请求
	 */
	@SuppressWarnings("unchecked")
	public static Map<String, Object> sendPost(String sendMsg, String sendUrl) {
		HttpPost httpPost = new HttpPost(sendUrl);
		HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
		CloseableHttpClient closeableHttpClient = httpClientBuilder.build();
		StringEntity entity;
		Map<String,Object> mres = new HashMap<String, Object>();
		try {
			entity = new StringEntity(sendMsg, "UTF-8"); //解决参数中文乱码问题
			entity.setContentEncoding("UTF-8");//设置编码格式
			entity.setContentType("application/json");
			httpPost.setEntity(entity);
			// 发起请求
			HttpResponse httpResponse = closeableHttpClient.execute(httpPost);
			// 请求结束，返回结果。并解析json。
			String resData = EntityUtils.toString(httpResponse.getEntity(),"UTF-8");
			mres = (Map<String, Object>) JSONObject.toBean(JSONObject.fromObject(resData), Map.class);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (null != closeableHttpClient) {
				try {
					closeableHttpClient.close();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		return mres;
	}
	
	//测试发送请求
	public static void main(String[] args) throws Exception {
		Map<String, Object> sendMsg = new HashMap<String, Object>();
		sendMsg.put("user_name", "lanqinger");
		sendMsg.put("real_name", "蓝卿儿");
		String sendUrl = "http://localhost:8080/sm/test/getPostData.form";
		Map<String, Object> result = sendPost(JSONObject.fromObject(sendMsg).toString(),sendUrl);
		System.out.println(result);
	}
}
 
注意：StringEntity entity = new StringEntity(sendMsg, "UTF-8");才是真正解决传参（@RequestBody String requestBody）乱码的问题，这个问题费了我好大的劲才解决。。。
 
 
 
2、java原生HttpClient3.1 post请求
 
       /**
	 * java原生HttpClient3.1 post请求
	 */
	@SuppressWarnings("unchecked")
	public static Map<String, Object> sendPost2(String sendMsg, String sendUrl) {
		HttpClient httpclient = null;
		PostMethod post = null;
		String info = "";
		Map<String, Object> mres = new HashMap<String, Object>();
		try {
			httpclient = new HttpClient();
			post = new PostMethod(sendUrl);
			//解决中文乱码问题
			post.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
			post.addParameter("info", sendMsg);
			httpclient.executeMethod(post);
			info = new String(post.getResponseBody(), "UTF-8");
			mres = (Map<String, Object>) JSONObject.toBean(JSONObject.fromObject(info), Map.class);
		} catch (Exception e) {
			mres.put("status", "9999");
			mres.put("message", "请求处理异常" + e.getMessage());
		} finally {
			// 关闭连接，释放资源
			post.releaseConnection();
		}
		return mres;
	}
	
 
接收请求：
 
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
  
import javax.annotation.Resource;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
  
import net.sf.json.JSONObject;  
  
import org.apache.log4j.Logger;  
import org.springframework.stereotype.Controller;  
import org.springframework.web.bind.annotation.RequestBody;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.ResponseBody;  
  
import com.lhm.service.UserInfoService;  
import com.lhm.value.UserInfoPage;  
  
@Controller  
@RequestMapping("/test")  
public class TestController {  
    @Resource  
    private UserInfoService userInfoService;  
      
    @RequestMapping(value="/getPostData.form", produces="application/json;charset=UTF-8")  
    @ResponseBody  
    public Object getPostData(@RequestBody String requestBody, HttpServletRequest request, HttpServletResponse response) throws Exception {  
        JSONObject json = JSONObject.fromObject(requestBody);  
        UserInfoPage userInfoPage = (UserInfoPage) JSONObject.toBean(json, UserInfoPage.class);  
        userInfoPage.setCurrentPage(1);  
        userInfoPage.setPageSize(10);  
        List<Map<String, Object>> list = userInfoService.listUsersMap(userInfoPage);  
        Map<String, Object> map = new HashMap<String, Object>();  
        map.put("success", "1");  
        map.put("total", list.size());  
        map.put("message", "执行成功");  
        return JSONObject.fromObject(map).toString();  
    }  
}  
 
注意：produces="application/json;charset=UTF-8" 解决返回结果集中文乱码问题。

public static String uploadFileToOSS(MultipartFile multfile) {
    CloseableHttpClient client = null;
    String result = null;
    try {
		client = HttpClients.createDefault();
		HttpPost httpPost = new HttpPost("请求地址");
		MultipartEntityBuilder builder = MultipartEntityBuilder.create();
        //addTextBody(String,String)该方法可以传入参数，例如请求的地址需要接受一个id
        //builder.addTextBody("id", "1");
		builder.addTextBody("arg", "value");
        //addBinaryBody()该方法传入二进制内容，可以传入InputStream，File, 参数三是传入的类型，参数四是文件名称
		builder.addBinaryBody("form", multfile.getInputStream(), ContentType.MULTIPART_FORM_DATA, "1.jpg");
		httpPost.setEntity(builder.build());
		HttpResponse response = client.execute(httpPost);
		if (response.getStatusLine().getStatusCode() == 200) {
			// 取回服务器端的响应结果
			String result = EntityUtils.toString(response.getEntity(), "utf-8");
		}
	} catch (Exception e) {
		e.printStackTrace();
	}finally {
	    try {
		    client.close();
	    } catch (IOException e) {
		    e.printStackTrace();
	    }
    }
	return result;
}