public static void main( String[] args ) {

        Map map = new HashMap<>();
        map.put("username", "test1");
        map.put("password", "888888");
        String url = "http://10.0.0.32:8098/dataExchange/login";
        String result = HttpUtil.doPost(url, map);
        System.out.println(result);

        String msg = "隐患数据备份成功!";
}


/**     
 * @文件名称: HttpUtil.java   
 * @描述: TODO  
 * @版本：V1.0     
 */ 
package com.zhjt.share.config;
 
 
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

/**  
 * @类功能说明：    封装的http的doPost()和doGet()方法
 * 需要依赖的jar包:
 * 				commons-lang3-3.4.jar
 *              commons-logging-1.2.jar
 *              httpclient-4.3.5.jar
 *              httpcore-4.4.1.jar
 *              log4j-1.2.17.jar
 * @版本：V1.0  
 */
public class HttpUtil {
//	private static Logger logger = Logger.getLogger(HttpUtil.class);
 
	/**  
	 * 方法功能说明：    http的doGet请求
	 * @参数： @param url  
	 * @参数： @param map
	 * @参数： @return      
	 * @return String     
	 * @throws  
	 */ 
	public static String doGet(String url,Map map) {
		String params = HttpUtil.formatUrlMap(map, false, false);
		//拼接成的带参数的url
		url = url+"?"+params;
        try {
        	HttpClient client = new DefaultHttpClient();
            //发送get请求
            HttpGet request = new HttpGet(url);
            HttpResponse response = client.execute(request);
 
            /**请求发送成功，并得到响应**/
            int s =response.getStatusLine().getStatusCode();
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                /**读取服务器返回过来的json字符串数据**/
                String strResult = EntityUtils.toString(response.getEntity());
                
                return strResult;
            }
        } 
        catch (IOException e) {
//        	 logger.error("HttpUtil.doGet():出错了",e);
        	
        }
        
        return null;
	}
	
	/**
	 * 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();  
            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{	//
//            	 logger.error("HttpUtil.doPost():状态码："+ code);
            	return null;
            }
        }
        catch(Exception e){
//        	 logger.error("HttpUtil.doPost():出错了",e);
        	
        	return null;
        }
	}
	
	  /** 
     *  
     * 方法用途: 对所有传入参数按照字段名的Unicode码从小到大排序（字典序），并且生成url参数串<br> 
     * 实现步骤: <br> 
     *  
     * @param paraMap   要排序的Map对象 
     * @param urlEncode   是否需要URLENCODE 
     * @param keyToLower    是否需要将Key转换为全小写 
     *            true:key转化成小写，false:不转化 
     * @return 
     */  
    public static String formatUrlMap(Map<String, String> paraMap, boolean urlEncode, boolean keyToLower)  
    {  
        String buff = "";  
        Map<String, String> tmpMap = paraMap;  
        try  
        {  
            List<Map.Entry<String, String>> infoIds = new ArrayList<Map.Entry<String, String>>(tmpMap.entrySet());  
            // 对所有传入参数按照字段名的 ASCII 码从小到大排序（字典序）  
            Collections.sort(infoIds, new Comparator<Map.Entry<String, String>>()  
            {  
                @Override  
                public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2)  
                {  
                    return (o1.getKey()).toString().compareTo(o2.getKey());  
                }  
            });  
            // 构造URL 键值对的格式  
            StringBuilder buf = new StringBuilder();  
            for (Map.Entry<String, String> item : infoIds)  
            {  
            	//StringUtils类需要依赖commons-lang3.jar包
                if (StringUtils.isNotBlank(item.getKey()))  
                {  
                    String key = item.getKey();  
                    String val = item.getValue();  
                    if (urlEncode)  
                    {  
                        val = URLEncoder.encode(val, "utf-8");  
                    }  
                    if (keyToLower)  
                    {  
                        buf.append(key.toLowerCase() + "=" + val);  
                    } else  
                    {  
                        buf.append(key + "=" + val);  
                    }  
                    buf.append("&");  
                }  
            }  
            buff = buf.toString();  
            if (buff.isEmpty() == false)  
            {  
                buff = buff.substring(0, buff.length() - 1);  
            }  
        } catch (Exception e) {  
//        	 logger.error("HttpUtil.formatUrlMap():出错了",e);
           return null;  
        }  
        return buff;  
    }
	
}

   最近公司派我出差与乙方公司对接接口，开发了将近大半年的App，突然有冲突，所以整合一下，此处省略十万八千字......

   言归正传，怎么通过java调用别人写的接口了？我们在网上看到大部分都是有点麻烦的，其实我们可以通过  RestTemplate

进行开发，常用的http基本请求方式都有  Get,Post ,Put ,Delete,等等

    我这里的是post请求，参数中含有 list 的，map传参

    首先我们创建一个配置类 

package com.japhet.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration(value = "config2")
public class Config {
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}



    @Resource
    private RestTemplate restTemplate;

//  核心
    public  String doPost(String url,Map<String, Object> params) throws Exception {
        JSONObject jsonObject =  restTemplate.postForObject(url,params,JSONObject.class);               
        return jsonObject.toString();
    }

//调用
    public static void main(String[] args) {

        if(true){//自己业务
            for(int i=0;i<10;i++){
                stringList.add("参数"+i);
            }
        }else{
            stringList.add("参数1");
        }
        JSONArray jsonArray = JSONArray.fromArray(new ArrayList[]{stringList});
        String listJson = jsonArray.toString();
        map.put("xxx", "参数1");
        map.put("xxx", listJson);
        map.put("xxx",  "参数1");
        map.put("xxx", "参数1");
        map.put("xxx", "参数1");

        try{
            String result = doPost("接口路径",map);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

get 请求 后续更新.....

REST式的Web Service使用HTTP里的方法：GET， POST， DELETE， PUT。你不需要使用URL或请求的内容来指定这个方法。
REST式的Web Service使用URL来指明你将要操作什么对象。
REST式的Web Service使用HTTP状态码作为返回值。
REST式的Web Service调用产生的HTTP请求内容只是用于服务数据——不是用来指明调用方法，目标对象或返回值的。
使用REST方法来开发Web Service的关键点是利用HTTP协议的简单性，而不是去扩展这个协议。你的Web Service调用最终应该是非常的简单而且非常的易于理解。
接收和返回的类型
MediaType指向的类型参考地址：
http://docs.oracle.com/javaee/6/api/javax/ws/rs/core/MediaType.html
常用类型：
MediaType.TEXT_PLAIN：无格式文本。
MediaType.TEXT_XML：”text/xml” 忽略xml头所指定的片吗格式而采用us-ascii编码。
MediaType.APPLICATION_XML：”application/xml” 根据xml头指定的编码格式来编码。
MediaType.APPLICATION_JSON：”application/json” json格式。
Rest所需jar包
下载地址：http://download.csdn.net/download/u012524687/7993863
此地址为CSDN整合过得jar包解压可用。
所需jar包截图：
web.xml配置
restDemo
com.sun.jersey.spi.container.servlet.ServletContainer
com.sun.jersey.config.property.packages
rest.service//包名
1//优先级
restDemo
/rest/*
//配置访问地址，如：http://localhost:8080/RestDemo/rest/RestService/123
编写中所用标注
JAX-RS是一套用Java实现rest服务的规范，使Java程序员可以使用一套固定的接口来开发rest应用，避免了依赖于第三方框架。同时，JAX-RS使用POJO编程模型和基于标注的配置，并集成了JAXB，从而可以有效缩短REST应用的开发周期。
JAX-RS提供了一些标注将一个资源类，一个POJOJava类，封装为Web资源。这些标注包括以下：
1、@Path：标注资源类或方法的相对路径。Path的参数有三种：
1.1 固定值
1.2 纯正则表达式
1.3 固定值和正则表达式的混合体
2、@GET，@PUT，@POST，@DELETE：标注方法是用的HTTP请求类型。
2.1 @GET：提供查询方法，所有的参数均在URL路径中，只能传输一个或者多个字符串无法传输对象。
2.2 @POST：提供新增方法，参数可以存在URL路径中，也可以存在BODY中。如传输文本格式的参数，使用String类型或者基本数据类型；如传输JSON格式的参数，使用map、list或者对象。
2.3 @PUT：提供修改方法。
2.4 @DELETE：提供删除方法。
3、@Produces，@Consumes：标注MIME媒体类型。
3.1 @Produces：标注返回的MIME媒体类型。
@Produces(“text/plain;charset=utf-8”)：处理返回中文乱码。(不设置的话默认为这个)
@Produces(MediaType.TEXT_XML)：返回的类型为”text/xml”，忽略xml头所指定编码格式而默认采用us-ascii编码。
3.2 @Consumes：标注可接受的MIME媒体类型。
@Consumes(MediaType.TEXT_PLAIN)：可接受的类型为”text/plain”，无格式文本。
4、@PathParam，@QueryParam，@HeaderParam，@CookieParam，
@MatrixParam，@FormParam：分别标注方法的参数来自于HTTP请求的不同位置。
4.1 @PathParam：提取URL的路径。
例如：URL地址为：
http://localhost:8080/RestDemo/rest/RestService/123
请求模板为：
@path(“RestService”)
public Class RestService{
@GET
@Path(“{id}”)
@Produces(“text/plain;charset=utf-8”)
public String getPatnParam(@PathParam(value=”id”) int id){
return “url中的参数为：”+id;
}
}
4.2 @QueryParam：来自于URL的查询参数。
例如：URL地址为：
http://localhost:8080/RestDemo/rest/RestService/getQueryParam?id=12
请求模板为：
@path(“RestService”)
public Class RestService{
@GET
@Path(“getQueryParam”)
@Produces(“text/plain;charset=utf-8”)
public String getQueryParam(@QueryParam(value=”id”) String id){
return “请求信息为：”+id;
}
}
4.3 @HeaderParam：来自于HTTP的请求头消息。
例如：URL地址为：
http://localhost:8080/RestDemo/rest/RestService/getHeaderParam
请求模板为：
@path(“RestService”)
public Class RestService{
@GET
@Path("/getHeaderParam")
public String getHeaderParam(@HeaderParam(value="host")
String host ){
return "请求头消息：" + host;
}
}
4.4 @MatrixParam：GET方式请求时获取路径中与Path正则表达式多出不一致的参数。
例如：URL地址为：
http://localhost:8080/RestDemo/rest/RestService/test--context;color=balck
请求模板为：
@path(“RestService”)
public Class RestService{
@GET
@Path(“{model}--{year}”)
@Produces(“text/plain;charset=utf-8”)
public String getMatrixParam(@MatrixParam(value=”color”) String color,
@PathParam(value=”model”)  String model,
@PathParam(value=”year”) String year ){
return “参数为：color：”+ color + “；model：”+ model+”；year：”+year;
}
}
4.5 @FormParam：其功能是可以和前端的HTML绑定
例子：
JAX-RS @FormParam Testing
Name : 
Age : 
请求模板为：
@Path(“RestService”)
public Class RestService{
@POST  //要和HTML中的对应
@Path(“/add”)
@Produces(“text/plain;charset=utf-8”)
public String add(@FormParam(”name”) String name
@FormParam(”age”) int age){
return “Name=”+name+”；Age=”+age;
}
}

一个工程中的主要方法：
public Map ky(Map map){
String url = "http://localhost:8080/api/json/ky.action";
Map reMap = new HashMap();
try{
if(map.size() == 0){
reMap.put("outResult", "0");
reMap.put("outResultReason", "无数据需要发送");
return reMap;
}
map.put("typeId", "06");
ArrayList list = (ArrayList)dao.queryMapList("billVerify.getLinkUrl",map);
/*
if(list == null || list.size() == 0){
reMap.put("outResult", "1");
reMap.put("outResultReason", "不调用物流验证接口");
return reMap;
}else{
HashMap linkMap = (HashMap)list.get(0);
url = linkMap.get("linkUrl").toString();
}
*/
HttpClient client = new HttpClient();
//返回结果集
JSONObject resJson = new JSONObject();
PostMethod postMethod = new PostMethod(url);
StringPart strPart1 = new StringPart("param", URLEncoder.encode(JSONObject.fromObject(map).toString(), "utf-8"));
client.getParams().setSoTimeout(15000);
Part[] parts = { strPart1};
//对于MIME类型的请求，httpclient建议全用MulitPartRequestEntity进行包装
MultipartRequestEntity mre = new MultipartRequestEntity(parts, postMethod.getParams());
postMethod.setRequestEntity(mre);
//执行请求，返回状态码
int status = client.executeMethod(postMethod);
if (status == HttpStatus.SC_OK) {
String result = postMethod.getResponseBodyAsString();
resJson = JSONObject.fromObject(result);
if("1".equals(resJson.get("outResult"))){
reMap.put("outResult", resJson.get("outResult"));
reMap.put("outResultReason", resJson.get("outResultReason"));
}else{
reMap.put("outResult", resJson.get("outResult"));
reMap.put("outResultReason", resJson.get("outResultReason"));
}
} else {
System.out.println("接口请求失败。");
reMap.put("outResult", "0");
reMap.put("outResultReason", "请求失败。");
}
}catch(Exception e){
e.printStackTrace();
reMap.put("outResult", "0");
reMap.put("outResultReason", "请求超时。");
}
return reMap;
}
另一个工程中的主要方法：
public String ky(){
Map map = new HashMap();
try {
jsonParam = URLDecoder.decode(param ,"UTF-8");
} catch (Exception e1) {
e1.printStackTrace();
}
if(jsonParam==null){
map.put("outResult", "0");
map.put("outResultReason", "参数：param 为空！");
result = JSONObject.fromObject(map);
return SUCCESS;
}
map = jsonService.ky(jsonParam);
result = JSONObject.fromObject(map);
return SUCCESS;
}