精华内容
下载资源
问答
  • 2021-03-05 17:46:12

    548d111c355d2eae8c95dfa99aa4f155.png

    java接收远程调用的数据,得到的是如上个数的返回内容,我怎么写才能获取到值,现在使用的请求方法如下:

    public static HttpResult postJsonData(String url, Map params, String charset) throws Exception{

    CloseableHttpClient httpclient = HttpClientUtil.createDefault();

    HttpPost httpPost = new HttpPost(url);

    //拼接参数

    List list = new ArrayList();

    for (Map.Entry entry : params.entrySet()) {

    String key = entry.getKey().toString();

    String value = entry.getValue().toString();

    System.out.println("key=" \+ key + " value=" \+ value);

    NameValuePair pair = new BasicNameValuePair(key, value);

    list.add(pair);

    }

    CloseableHttpResponse response=null;

    try {

    if(StringUtils.isEmpty(charset)){

    charset = DEFAULT\_CHARSET;

    }

    httpPost.setEntity(new UrlEncodedFormEntity(list,charset));

    response = httpclient.execute(httpPost);

    /\*\*请求发送成功,并得到响应\*\*/

    if(response!=null && response.getStatusLine().getStatusCode() == HttpStatus.SC\_OK){

    HttpEntity httpEntity = response.getEntity();

    if (httpEntity!=null){

    System.out.println("响应内容为:" \+ EntityUtils.toString(httpEntity));

    //System.out.println("响应内容为1:" + httpEntity.getContent());

    }

    String result=null;

    try {

    result = EntityUtils.toString(httpEntity,DEFAULT\_CHARSET);

    logger.info(result);

    } catch (IOException e) {

    throw e;

    } finally {

    EntityUtils.consume(httpEntity);

    }

    return JSON.parseObject(result,HttpResult.class);

    //return httpEntity.getContent();

    }else{

    return null;

    }

    } catch (IOException e) {

    throw new Exception(e.getMessage());

    }finally {

    try{

    // 释放资源

    if(response!=null){

    response.close();

    }

    if(httpclient!=null){

    httpclient.close();

    }

    }catch (IOException e1){

    throw new Exception("CloseableHttpResponse close exception");

    }

    }

    }

    求教怎么写才能把返回的值取到,现在用上边的方法会报如下错误:

    bf71e9a03e1532fe4cea1bbed9f69157.png

    更多相关内容
  • 主要介绍了Java调用第三方接口示范的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java调用第三方接口示范

    万次阅读 多人点赞 2018-10-08 15:03:53
    在项目开发中经常会遇到调用第三方接口的情况,比如说调用第三方的天气预报接口。 使用流程 【1】准备工作:在项目的工具包下导入HttpClientUtil这个工具类,或者也可以使用Spring框架的restTemplate来调用,上面...

    人工智能,零基础入门!http://www.captainbed.net/inner

    在项目开发中经常会遇到调用第三方接口的情况,比如说调用第三方的天气预报接口。

    使用流程

    【1】准备工作:在项目的工具包下导入HttpClientUtil这个工具类,或者也可以使用Spring框架的restTemplate来调用,上面有调用接口的方法【分为Get和Post方式的有参和无参调用】:

    package com.njsc.credit.util;
    
    import java.io.IOException;
    import java.net.URI;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    import org.apache.http.NameValuePair;
    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.ContentType;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.util.EntityUtils;
    
    public class HttpClientUtil {
    
    	/**
    	 * 带参数的get请求
    	 * @param url
    	 * @param param
    	 * @return String
    	 */
    	public static String doGet(String url, 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);
    			// 执行请求
    			response = httpclient.execute(httpGet);
    			// 判断返回状态是否为200
    			if (response.getStatusLine().getStatusCode() == 200) {
    				resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				if (response != null) {
    					response.close();
    				}
    				httpclient.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    		return resultString;
    	}
    	
    	/**
    	 * 不带参数的get请求
    	 * @param url
    	 * @return String
    	 */
    	public static String doGet(String url) {
    		return doGet(url, null);
    	}
    
    	/**
    	 * 带参数的post请求
    	 * @param url
    	 * @param param
    	 * @return String
    	 */
    	public static String doPost(String url, Map<String, String> param) {
    		// 创建Httpclient对象
    		CloseableHttpClient httpClient = HttpClients.createDefault();
    		CloseableHttpResponse response = null;
    		String resultString = "";
    		try {
    			// 创建Http Post请求
    			HttpPost httpPost = new HttpPost(url);
    			// 创建参数列表
    			if (param != null) {
    				List<NameValuePair> paramList = new ArrayList<>();
    				for (String key : param.keySet()) {
    					paramList.add(new BasicNameValuePair(key, param.get(key)));
    				}
    				// 模拟表单
    				UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
    				httpPost.setEntity(entity);
    			}
    			// 执行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 resultString;
    	}
    
    	/**
    	 * 不带参数的post请求
    	 * @param url
    	 * @return String
    	 */
    	public static String doPost(String url) {
    		return doPost(url, null);
    	}
    	
    	/**
    	 * 传送json类型的post请求
    	 * @param url
    	 * @param json
    	 * @return String
    	 */
    	public static String doPostJson(String url, String json) {
    		// 创建Httpclient对象
    		CloseableHttpClient httpClient = HttpClients.createDefault();
    		CloseableHttpResponse response = null;
    		String resultString = "";
    		try {
    			// 创建Http Post请求
    			HttpPost httpPost = new HttpPost(url);
    			// 创建请求内容
    			StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
    			httpPost.setEntity(entity);
    			// 执行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 resultString;
    	}
    }
    

    【2】创建url和访问key 以及参数等:

    代码如下:

    /**
     * 聚合接口校验身份证
     * @param idCard
     * @param realName
     * @return boolean
     */
    public boolean identityCheck(String idCard, String realName){
    	logger.info("-----------------调用聚合数据 身份证验证API BEGIN--------------->");
    	String key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
    	String url = "http://op.juhe.cn/idcard/query" + "?key=" + key + "&idcard=" + idCard + "&realname=" + realName;
    	logger.info("请求url:" + url);
    	boolean match = false; //是否匹配
    	try {
    		String result = HttpClientUtil.doGet(url);
    		System.out.println("请求结果:" + result);
    		IdentityCheckResult identityCheckResult = JsonUtils.parse(result, IdentityCheckResult.class);
    		IdentityCheck identityCheck = JsonUtils.parse(result, "result", IdentityCheck.class);
    		logger.info(identityCheckResult);
    		logger.info(identityCheck.toString());
    		if(identityCheckResult.correct() && identityCheck.getRes() == 1){
    			match = true;
    		}
    	} catch (Exception e) {
    		e.printStackTrace();
    	}
    	logger.info("<-----------------调用聚合数据 身份证验证API END---------------");
    	return match;
    }

    【3】请求这个第三方接口:

    使用HttpClientUtil工具类中的doGet方法来请求URL,得到结果,现在大多数是一个json字符串,类型为String

    【4】根据接口返回数据格式来解析数据:

    可以看到,返回参数有六个,所以在项目中新建一个bean,包含以上六个字段,用来接住返回数据,如下:

    因为接口返回的数据是一个json的字符串,类型实际上是一个String字符串,要解析数据,用工具类JsonUtils的parse方法将字符串转换为Java对象,JsonUtils的代码如下:

    package com.eqianxian.commons.utils.json;
    
    import java.util.List;
    import java.util.Map;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.fastjson.serializer.PropertyFilter;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    
    /**
     * 在系统中统一使用这个,以方便将来切换不同的JSON生成工具
     * 
     * @author KelvinZ
     * 
     */
    public class JsonUtils {
    	public static final int TYPE_FASTJSON = 0;
    	public static final int TYPE_GSON = 1;
    
    	/**
    	 * <pre>
    	 * 对象转化为json字符串
    	 * 
    	 * @param obj 待转化对象
    	 * @return 代表该对象的Json字符串
    	 */
    	public static final String toJson(final Object obj) {
    		return JSON.toJSONString(obj);
    		// return gson.toJson(obj);
    	}
    
    	/**
    	 * <pre>
    	 * 对象转化为json字符串
    	 * 
    	 * @param obj 待转化对象
    	 * @return 代表该对象的Json字符串
    	 */
    	public static final String toJson(final Object obj, SerializerFeature... features) {
    		return JSON.toJSONString(obj, features);
    		// return gson.toJson(obj);
    	}
    
    	/**
    	 * 对象转化为json字符串并格式化
    	 * 
    	 * @param obj
    	 * @param format 是否要格式化
    	 * @return
    	 */
    	public static final String toJson(final Object obj, final boolean format) {
    		return JSON.toJSONString(obj, format);
    	}
    
    	/**
    	 * 对象对指定字段进行过滤处理,生成json字符串
    	 * 
    	 * @param obj
    	 * @param fields 过滤处理字段
    	 * @param ignore true做忽略处理,false做包含处理
    	 * @param features json特征,为null忽略
    	 * @return
    	 */
    	public static final String toJson(final Object obj, final String[] fields, final boolean ignore,
    			SerializerFeature... features) {
    		if (fields == null || fields.length < 1) {
    			return toJson(obj);
    		}
    		if (features == null)
    			features = new SerializerFeature[] { SerializerFeature.QuoteFieldNames };
    		return JSON.toJSONString(obj, new PropertyFilter() {
    			@Override
    			public boolean apply(Object object, String name, Object value) {
    				for (int i = 0; i < fields.length; i++) {
    					if (name.equals(fields[i])) {
    						return !ignore;
    					}
    				}
    				return ignore;
    			}
    		}, features);
    	}
    
    	/**
    	 * <pre>
    	 * 解析json字符串中某路径的值
    	 * 
    	 * @param json
    	 * @param path
    	 * @return
    	 */
    	@SuppressWarnings("unchecked")
    	public static final <E> E parse(final String json, final String path) {
    		String[] keys = path.split(",");
    		JSONObject obj = JSON.parseObject(json);
    		for (int i = 0; i < keys.length - 1; i++) {
    			obj = obj.getJSONObject(keys[i]);
    		}
    		return (E) obj.get(keys[keys.length - 1]);
    	}
    
    	/**
    	 * <pre>
    	 * json字符串解析为对象
    	 * 
    	 * @param json 代表一个对象的Json字符串
    	 * @param clazz 指定目标对象的类型,即返回对象的类型
    	 * @return 从json字符串解析出来的对象
    	 */
    	public static final <T> T parse(final String json, final Class<T> clazz) {
    		return JSON.parseObject(json, clazz);
    	}
    
    	/**
    	 * <pre>
    	 * json字符串解析为对象
    	 * 
    	 * @param json json字符串
    	 * @param path 逗号分隔的json层次结构
    	 * @param clazz 目标类
    	 */
    	public static final <T> T parse(final String json, final String path, final Class<T> clazz) {
    		String[] keys = path.split(",");
    		JSONObject obj = JSON.parseObject(json);
    		for (int i = 0; i < keys.length - 1; i++) {
    			obj = obj.getJSONObject(keys[i]);
    		}
    		String inner = obj.getString(keys[keys.length - 1]);
    		return parse(inner, clazz);
    	}
    
    	/**
    	 * 将制定的对象经过字段过滤处理后,解析成为json集合
    	 * 
    	 * @param obj
    	 * @param fields
    	 * @param ignore
    	 * @param clazz
    	 * @param features
    	 * @return
    	 */
    	public static final <T> List<T> parseArray(final Object obj, final String[] fields, boolean ignore,
    			final Class<T> clazz, final SerializerFeature... features) {
    		String json = toJson(obj, fields, ignore, features);
    		return parseArray(json, clazz);
    	}
    
    	/**
    	 * <pre>
    	 * 从json字符串中解析出一个对象的集合,被解析字符串要求是合法的集合类型
    	 * (形如:["k1":"v1","k2":"v2",..."kn":"vn"])
    	 * 
    	 * @param json - [key-value-pair...]
    	 * @param clazz
    	 * @return
    	 */
    	public static final <T> List<T> parseArray(final String json, final Class<T> clazz) {
    		return JSON.parseArray(json, clazz);
    	}
    
    	/**
    	 * <pre>
    	 * 从json字符串中按照路径寻找,并解析出一个对象的集合,例如:
    	 * 类Person有一个属性name,要从以下json中解析出其集合:
    	 * {
    	 * 	"page_info":{
    	 * 		"items":{
    	 * 			"item":[{"name":"KelvinZ"},{"name":"Jobs"},...{"name":"Gates"}]
    	 * 	}
    	 * }
    	 * 使用方法:parseArray(json, "page_info,items,item", Person.class),
    	 * 将根据指定路径,正确的解析出所需集合,排除外层干扰
    	 * 
    	 * @param json json字符串
    	 * @param path 逗号分隔的json层次结构
    	 * @param clazz 目标类
    	 * @return
    	 */
    	public static final <T> List<T> parseArray(final String json, final String path, final Class<T> clazz) {
    		String[] keys = path.split(",");
    		JSONObject obj = JSON.parseObject(json);
    		for (int i = 0; i < keys.length - 1; i++) {
    			obj = obj.getJSONObject(keys[i]);
    		}
    		String inner = obj.getString(keys[keys.length - 1]);
    		List<T> ret = parseArray(inner, clazz);
    		return ret;
    	}
    
    	/**
    	 * <pre>
    	 * 有些json的常见格式错误这里可以处理,以便给后续的方法处理
    	 * 常见错误:使用了\" 或者 "{ 或者 }",腾讯的页面中常见这种格式
    	 * 
    	 * @param invalidJson 包含非法格式的json字符串
    	 * @return
    	 */
    	public static final String correctJson(final String invalidJson) {
    		String content = invalidJson.replace("\\\"", "\"").replace("\"{", "{").replace("}\"", "}");
    		return content;
    	}
    
    	/**
    	 * 格式化Json
    	 * 
    	 * @param json
    	 * @return
    	 */
    	public static final String formatJson(String json) {
    		Map<?, ?> map = (Map<?, ?>) JSON.parse(json);
    		return JSON.toJSONString(map, true);
    	}
    
    	/**
    	 * 获取json串中的子json
    	 * 
    	 * @param json
    	 * @param path
    	 * @return
    	 */
    	public static final String getSubJson(String json, String path) {
    		String[] keys = path.split(",");
    		JSONObject obj = JSON.parseObject(json);
    		for (int i = 0; i < keys.length - 1; i++) {
    			obj = obj.getJSONObject(keys[i]);
    			System.out.println(obj.toJSONString());
    		}
    		return obj != null ? obj.getString(keys[keys.length - 1]) : null;
    	}
    
    }
    

     

    展开全文
  • Java 调用第三方接口方法

    千次阅读 2022-04-25 11:21:39
    Java 调用第三方接口方法 一、 通过JDK网络类Java.net.HttpURLConnection 1.java.net包下的原生java api提供的http请求 使用步骤: 1、通过统一资源定位器(java.net.URL)获取连接器(java.net.URLConnection)。 ...

    Java 调用第三方接口方法

    一、 通过JDK网络类Java.net.HttpURLConnection

    1.java.net包下的原生java api提供的http请求

    使用步骤:

    1、通过统一资源定位器(java.net.URL)获取连接器(java.net.URLConnection)。

    2、设置请求的参数。

    3、发送请求。

    4、以输入流的形式获取返回内容。

    5、关闭输入流。

    2.HttpClientUtil工具类

    /**
     * jdk 调用第三方接口
     * @author hsq
     */
    public class HttpClientUtil2 {
    
    
        /**
         * 以post方式调用对方接口方法
         * @param pathUrl
         */
        public static String doPost(String pathUrl, String data){
            OutputStreamWriter out = null;
            BufferedReader br = null;
            String result = "";
            try {
                URL url = new URL(pathUrl);
    
                //打开和url之间的连接
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    
                //设定请求的方法为"POST",默认是GET
                //post与get的不同之处在于post的参数不是放在URL字串里面,而是放在http请求的正文内。
                conn.setRequestMethod("POST");
    
                //设置30秒连接超时
                conn.setConnectTimeout(30000);
                //设置30秒读取超时
                conn.setReadTimeout(30000);
    
                // 设置是否向httpUrlConnection输出,因为这个是post请求,参数要放在http正文内,因此需要设为true, 默认情况下是false;
                conn.setDoOutput(true);
                // 设置是否从httpUrlConnection读入,默认情况下是true;
                conn.setDoInput(true);
    
                // Post请求不能使用缓存
                conn.setUseCaches(false);
    
                //设置通用的请求属性
                conn.setRequestProperty("accept", "*/*");
                conn.setRequestProperty("connection", "Keep-Alive");  //维持长链接
                conn.setRequestProperty("Content-Type", "application/json;charset=utf-8");
    
                //连接,从上述url.openConnection()至此的配置必须要在connect之前完成,
                conn.connect();
    
                /**
                 * 下面的三句代码,就是调用第三方http接口
                 */
                //获取URLConnection对象对应的输出流
                //此处getOutputStream会隐含的进行connect(即:如同调用上面的connect()方法,所以在开发中不调用上述的connect()也可以)。
                out = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
                //发送请求参数即数据
                out.write(data);
                //flush输出流的缓冲
                out.flush();
    
                /**
                 * 下面的代码相当于,获取调用第三方http接口后返回的结果
                 */
                //获取URLConnection对象对应的输入流
                InputStream is = conn.getInputStream();
                //构造一个字符流缓存
                br = new BufferedReader(new InputStreamReader(is));
                String str = "";
                while ((str = br.readLine()) != null){
                    result += str;
                }
                System.out.println(result);
                //关闭流
                is.close();
                //断开连接,disconnect是在底层tcp socket链接空闲时才切断,如果正在被其他线程使用就不切断。
                conn.disconnect();
    
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                try {
                    if (out != null){
                        out.close();
                    }
                    if (br != null){
                        br.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return result;
        }
    
        /**
         * 以get方式调用对方接口方法
         * @param pathUrl
         */
        public static String doGet(String pathUrl){
            BufferedReader br = null;
            String result = "";
            try {
                URL url = new URL(pathUrl);
    
                //打开和url之间的连接
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    
                //设定请求的方法为"GET",默认是GET
                //post与get的不同之处在于post的参数不是放在URL字串里面,而是放在http请求的正文内。
                conn.setRequestMethod("GET");
    
                //设置30秒连接超时
                conn.setConnectTimeout(30000);
                //设置30秒读取超时
                conn.setReadTimeout(30000);
    
                // 设置是否向httpUrlConnection输出,因为这个是post请求,参数要放在http正文内,因此需要设为true, 默认情况下是false;
                conn.setDoOutput(true);
                // 设置是否从httpUrlConnection读入,默认情况下是true;
                conn.setDoInput(true);
    
                // Post请求不能使用缓存(get可以不使用)
                conn.setUseCaches(false);
    
                //设置通用的请求属性
                conn.setRequestProperty("accept", "*/*");
                conn.setRequestProperty("connection", "Keep-Alive");  //维持长链接
                conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
    
                //连接,从上述url.openConnection()至此的配置必须要在connect之前完成,
                conn.connect();
    
                /**
                 * 下面的代码相当于,获取调用第三方http接口后返回的结果
                 */
                //获取URLConnection对象对应的输入流
                InputStream is = conn.getInputStream();
                //构造一个字符流缓存
                br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                String str = "";
                while ((str = br.readLine()) != null){
                    result += str;
                }
                System.out.println(result);
                //关闭流
                is.close();
                //断开连接,disconnect是在底层tcp socket链接空闲时才切断,如果正在被其他线程使用就不切断。
                conn.disconnect();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                try {
                    if (br != null){
                        br.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return result;
        }
    }
    
    

    3.第三方api接口

    /**
     * @author hsq
     */
    @RestController
    @RequestMapping("/api")
    public class HelloWorld {
    
        private static final Logger log= LoggerFactory.getLogger(HelloWorld.class);
    
        @GetMapping ("/getHello")
        public Result getHelloWord(){
            log.info("进入到api接口.......");
            return Result.success("hello world api get 接口数据");
        }
    
        @PostMapping("/postHello")
        public Result postHelloWord(@RequestBody User user){
            log.info("进入post 方法.....");
            System.out.println(user.toString());
            return Result.success("hello world api post接口数据");
        }
    }
    

    在这里插入图片描述

    4.测试类

     @Test
        public void testJDKApi(){
            //测试get方法
            String s = HttpClientUtil2.doGet("http://localhost:9092/api/getHello");
            System.out.println("get方法:"+s);
            //测试post方法
            User user = new User();
            user.setUname("胡萝卜");
            user.setRole("普通用户");
            //把对象转换为json格式
            String s1 = JsonUtil.toJson(user);
            String postString = HttpClientUtil2.doPost("http://localhost:9092/api/postHello",s1);
            System.out.println("post方法:"+postString);
        }
    

    结果:
    在这里插入图片描述

    二、通过Apache common封装好的HttpClient

    1.引入依赖

     		<!--HttpClient-->
            <dependency>
                <groupId>commons-httpclient</groupId>
                <artifactId>commons-httpclient</artifactId>
                <version>3.1</version>
            </dependency>
            <!--json-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.28</version>
            </dependency>
    

    2.httpClientUtil

    /**
    	*httpClient的get请求方式
         * 使用GetMethod来访问一个URL对应的网页实现步骤:
         * 1.生成一个HttpClient对象并设置相应的参数;
         * 2.生成一个GetMethod对象并设置响应的参数;
         * 3.用HttpClient生成的对象来执行GetMethod生成的Get方法;
         * 4.处理响应状态码;
         * 5.若响应正常,处理HTTP响应内容;
         * 6.释放连接。
     * @author hsq
     */
    public class HttpClientUtil {
    
        /**
         * @param url
         * @param charset
         * @return
         */
        public static String doGet(String url, String charset){
            /**
             * 1.生成HttpClient对象并设置参数
             */
            HttpClient httpClient = new HttpClient();
            //设置Http连接超时为5秒
            httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(5000);
    
            /**
             * 2.生成GetMethod对象并设置参数
             */
            GetMethod getMethod = new GetMethod(url);
            //设置get请求超时为5秒
            getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 5000);
            //设置请求重试处理,用的是默认的重试处理:请求三次
            getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());
    
            String response = "";
    
            /**
             * 3.执行HTTP GET 请求
             */
            try {
                int statusCode = httpClient.executeMethod(getMethod);
    
                /**
                 * 4.判断访问的状态码
                 */
                if (statusCode != HttpStatus.SC_OK){
                    System.err.println("请求出错:" + getMethod.getStatusLine());
                }
    
                /**
                 * 5.处理HTTP响应内容
                 */
                //HTTP响应头部信息,这里简单打印
                Header[] headers = getMethod.getResponseHeaders();
                for (Header h: headers){
                    System.out.println(h.getName() + "---------------" + h.getValue());
                }
                //读取HTTP响应内容,这里简单打印网页内容
                //读取为字节数组
                byte[] responseBody = getMethod.getResponseBody();
                response = new String(responseBody, charset);
                System.out.println("-----------response:" + response);
                //读取为InputStream,在网页内容数据量大时候推荐使用
                //InputStream response = getMethod.getResponseBodyAsStream();
    
            } catch (HttpException e) {
                //发生致命的异常,可能是协议不对或者返回的内容有问题
                System.out.println("请检查输入的URL!");
                e.printStackTrace();
            } catch (IOException e){
                //发生网络异常
                System.out.println("发生网络异常!");
            }finally {
                /**
                 * 6.释放连接
                 */
                getMethod.releaseConnection();
            }
            return response;
        }
    
        /**
         * post请求
         * @param url
         * @param json
         * @return
         */
        public static String doPost(String url, JSONObject json){
            HttpClient httpClient = new HttpClient();
            PostMethod postMethod = new PostMethod(url);
    
            postMethod.addRequestHeader("accept", "*/*");
            postMethod.addRequestHeader("connection", "Keep-Alive");
            //设置json格式传送
            postMethod.addRequestHeader("Content-Type", "application/json;charset=utf-8");
            //必须设置下面这个Header
            postMethod.addRequestHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36");
            //添加请求参数
            //postMethod.addParameter("param", json.getString("param"));
            StringRequestEntity param = new StringRequestEntity(json.getString("param"));
            postMethod.setRequestEntity(param);
            String res = "";
            try {
                int code = httpClient.executeMethod(postMethod);
                if (code == 200){
                    byte[] responseBody = postMethod.getResponseBody();
                    res = new String(responseBody, "UTF-8");
                    //res = postMethod.getResponseBodyAsString();
                    System.out.println(res);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return res;
        }
    }
    

    3.第三方api接口

    @RestController
    @RequestMapping("/api")
    public class HelloWorld {
    
        private static final Logger log= LoggerFactory.getLogger(HelloWorld.class);
    
    
        @GetMapping ("/getHello")
        public Result getHelloWord(){
            log.info("进入到api接口.......");
            return Result.success("hello world api get 接口数据");
        }
    
        @PostMapping("/postHello")
        public Result postHelloWord(@RequestBody User user){
            log.info("进入post 方法.....");
            System.out.println(user.toString());
            return Result.success("hello world api post接口数据");
        }
    
    }
    

    4.测试类

     	@Test
        public void testApi() {
            //测试get方法
            String s = HttpClientUtil.doGet("http://localhost:9092/api/getHello", "UTF-8");
            System.out.println("get方法:"+s);
            //测试post方法
            User user = new User();
            user.setUname("胡萝卜");
            user.setRole("普通用户");
            JSONObject jsonObject = new JSONObject();
            String s1 = JsonUtil.toJson(user);
            jsonObject.put("param",s1);
            String postString = HttpClientUtil.doPost("http://localhost:9092/api/postHello", jsonObject);
            System.out.println("post方法:"+postString);
        }
    

    结果:
    在这里插入图片描述

    三、通过Spring的RestTemplate

    1.引入依赖

    导入springboot的web包

        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.4.RELEASE</version>
        </parent>
     
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    

    2.RestTemplate配置类

    /**
     * @author hsq
     */
    @Configuration
    public class RestTemplateConfig {
    
        @Bean
        public RestTemplate restTemplate(ClientHttpRequestFactory factory){
            return new RestTemplate(factory);
        }
    
        @Bean
        public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
            SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
            factory.setConnectTimeout(15000);
            factory.setReadTimeout(5000);
            return factory;
        }
    }
    

    3.RestTemplate实现类

    /**
     * @author hsq
     */
    @Component
    public class RestTemplateToInterface {
    
        @Autowired
        private RestTemplate restTemplate;
    
        /**
         * 以get方式请求第三方http接口 getForEntity
         * @param url
         * @return
         */
        public Result doGetWith1(String url){
            ResponseEntity<Result> responseEntity = restTemplate.getForEntity(url, Result.class);
            Result result = responseEntity.getBody();
            return result;
        }
    
        /**
         * 以get方式请求第三方http接口 getForObject
         * 返回值返回的是响应体,省去了我们再去getBody()
         * @param url
         * @return
         */
        public Result doGetWith2(String url){
            Result result  = restTemplate.getForObject(url, Result.class);
            return result;
        }
    
        /**
         * 以post方式请求第三方http接口 postForEntity
         * @param url
         * @param user
         * @return
         */
        public String doPostWith1(String url,User user){
            ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, user, String.class);
            String body = responseEntity.getBody();
            return body;
        }
    
        /**
         * 以post方式请求第三方http接口 postForEntity
         * 返回值返回的是响应体,省去了我们再去getBody()
         * @param url
         * @param user
         * @return
         */
        public String doPostWith2(String url,User user){
            String body = restTemplate.postForObject(url, user, String.class);
            return body;
        }
    
        /**
         * exchange
         * @return
         */
        public String doExchange(String url, Integer age, String name){
            //header参数
            HttpHeaders headers = new HttpHeaders();
            String token = "asdfaf2322";
            headers.add("authorization", token);
            headers.setContentType(MediaType.APPLICATION_JSON);
    
            //放入body中的json参数
            JSONObject obj = new JSONObject();
            obj.put("age", age);
            obj.put("name", name);
    
            //组装
            HttpEntity<JSONObject> request = new HttpEntity<>(obj, headers);
            ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.POST, request, String.class);
            String body = responseEntity.getBody();
            return body;
        }
    
    }
    

    4.第三方api接口

    /**
     * @author hsq
     */
    @RestController
    @RequestMapping("/api")
    public class HelloWorld {
    
        private static final Logger log= LoggerFactory.getLogger(HelloWorld.class);
    
        @GetMapping ("/getHello")
        public Result getHelloWord(){
            log.info("进入到api接口.......");
            return Result.success("hello world api get 接口数据");
        }
    
        @PostMapping("/postHello")
        public Result postHelloWord(@RequestBody User user){
            log.info("进入post 方法.....");
            System.out.println(user.toString());
            return Result.success("hello world api post接口数据");
        }
    }
    

    在这里插入图片描述

    5.测试类

    //注入使用
    @Autowired
    private RestTemplateToInterface restTemplateToInterface;
    
    @Test
    public void testSpringBootApi(){
        Result result= restTemplateToInterface.doGetWith1("http://localhost:9092/api/getHello");
        System.out.println("get结果:"+result);
        User user = new User();
        user.setUname("胡萝卜");
        user.setRole("普通用户");
        String s = restTemplateToInterface.doPostWith1("http://localhost:9092/api/postHello", user);
        System.out.println("post结果:"+s);
    }
    

    结果:
    在这里插入图片描述

    展开全文
  • } 参数处理与解析数据 获得的响应参数可以使用json‘进行分析,[ ]为数组,{ }为对象,利用 JSONObject.parseObject(String text)将字符串转为json对象,调用getJSONArray(key)获取json数组JSONArray,getString...

    新建maven工程,在pom.xml中导入httpclient与fastjson包,httpclient用来请求,fastjson进行参数转换与处理数据。

    主方法

    SHA1算法加密

    POST 方法

    利用 HttpClientBuilder创建连接对象

    public static String postMethod(String url, JSONObject json){
        try {
            CloseableHttpClient httpClient = HttpClientBuilder.create().build();
            HttpPost post = new HttpPost(url);
            post.addHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36");
            StringEntity s = new StringEntity(json.toString());
            s.setContentEncoding("UTF-8");
            //发送json数据需要设置contentType
            s.setContentType("application/x-www-form-urlencoded");
            post.setEntity(s); //设置请求参数
            HttpResponse response = httpClient.execute(post);
            int statusCode = response.getStatusLine().getStatusCode();
            if (HttpStatus.SC_OK == statusCode){
                //返回String
                String res = EntityUtils.toString(response.getEntity());
                System.out.println(res);
                return res;
            }
    
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    

    GET方法 

    利用 HttpClientBuilder创建连接对象

    public static String getMethod(String url){
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpGet get = new HttpGet(url);
        try{
            //这里可以设置请求参数,token等
            get.addHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36");
            HttpResponse response = httpClient.execute(get);//执行获取响应
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK){//根据状态码处理
                //返回字符串
                String res = EntityUtils.toString(response.getEntity());
                System.out.println(res);
                return res;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    参数处理与解析数据

    获得的响应参数可以使用json‘进行分析,[ ]为数组,{ }为对象,利用 JSONObject.parseObject(String text)将字符串转为json对象,调用getJSONArray(key)获取json数组JSONArray,getString(key)获取对应的值,getJSONObject()获取json对象。可以根据json结构层层解析,获取需要的数据。
    新建json对象,调用put方法可以赋值,之后作为请求参数设置。

    展开全文
  • java调用第三方接口示例

    千次阅读 2020-05-20 17:48:30
    引言:在我们开发的过程中,常常会听到或者接触到第三方接口,那么这个第三方接口到底是什么呢?...项目中有明确要求需要调用第三方接口的,一般都会有规范的接口调用文档,调用第三方接口时,你只需要根据该接
  • 该工具类是java 调用第三方接口时需要使用到的。HttpClientUtil 包含get和post方法。
  • Java调用第三方接口(http总结)

    千次阅读 2019-09-01 12:32:57
    业务需求: 一般情况下都是 后端提供接口,前端调用,解决需求,但是有的时候为了方便,复用别人的接口(网上的,公共的第三方接口(短信、天气等))...在Java项目中调用第三方接口的方式有: ①通过JDK网络类Java....
  • https://blog.csdn.net/yzx4321/article/details/102803308
  • java调用第三方接口http工具类

    千次阅读 2020-01-08 11:53:56
    java调用第三方接口http工具类 一、描述        调用第三方接口工具。 二、代码实现 package com.lanshen.utils.lsjavaUtils; import com.alibaba.fastjson.JSON; import ...
  • * @param url 第三方接口地址 * @param jsonObject 所需传的参数 * @param multipartFile 文件流 * @return */ public static String sendHttpPostRequest(String url,JSONObject jsonObject, MultipartFile ...
  • 首先我们会得到第三方公司的接口文档,我们会依据其中的规范去做请求的参数或者获取加密手段 2.代码实践 需求 package com.seeyon.apps.hd.controller; import java.io.BufferedReader; import java.io....
  • 业务场景:当我点击一个按钮时,调用第三方接口,后台返回一个字节流,然后浏览器弹出文件另存为的弹窗,直接保存。 但是在实际操作当中,浏览器拿到返回的字节流是不能解析的,下载的文件也是一个乱码文件,所以我决定...
  • 比如java调用第三方支付宝的,我从网上看到的时候,客户端请求支付宝 然后支付宝封装参数给银行,银行付款然后通过支付宝,支付宝再通知客户。 但是我看到这个程序里面有个地方说到了异步,还有回调,对于这2个东西...
  • Java调用第三方接口获取数据方法

    千次阅读 2019-09-09 23:46:42
    java实现调用第三方接口获取数据 最近学习向第三方接口发出http请求,获取返回数据进行存储,把内容总结一下。 几种方法 查了一些资料,总共有这么几种方法发出http请求: javaJava.net.HttpURLConnection类实现 ...
  • java编写的调用国内第三方平台发送短信的例子及相关文档
  • java调用第三方接口(项目亲测)

    万次阅读 2020-08-10 15:29:21
    public static String ... //smUrl:接口地址 //data:请求参数:应该是json格式,我直接把json转成String了 OutputStreamWriter out = null; BufferedReader br = null; String result = ""; try { URL url = n.
  • 在项目开发中经常会遇到调用第三方接口的情况,比如说调用第三方的天气预报接口。1、准备工作:在项目的工具包下导入HttpClientUtil这个工具类,或者也可以使用Spring框架的restTemplate来调用,上面有调用接口的...
  • java如何调用第三方接口

    千次阅读 多人点赞 2021-01-13 16:21:43
    最近在做一个项目,因一些机制问题,需要我用java代码调用第三方接口。因其接口使用的是@RequestBody注入访问对象的,@RequestBody接受收的是一个json格式的字符串,一定是一个字符串。类似于: { “pageNumber”:1...
  • 调用第三方接口使用HttpURLConnection发送POST请求,返回数据在测试方法中返回的是正常中文,使用Tomcat跑的程序返回的数据出现中文乱码。
  • Java调用第三方http接口的常用方式

    千次阅读 多人点赞 2021-09-02 11:15:59
    Java项目中调用第三方接口的常用方式有: ①通过JDK网络类Java.net.HttpURLConnection; ②通过common封装好的HttpClient; ③通过Apache封装好的CloseableHttpClient; ④通过SpringBoot-RestTemplate; 2....
  • java调用第三方接口获取(保存)数据

    千次阅读 2019-04-16 14:26:34
    后台java获取第三方接口数据: import org.springframework.web.client.RestTemplate; import org.codehaus.jackson.JsonNode; import org.codehaus.jackson.type.TypeReference; import org.codehaus.jackson....
  • 在项目开发中经常会遇到调用第三方接口的情况,比如说调用第三方的天气预报接口。 需要更多相关资源的小伙伴,扫码就好啦。 需要更多教程,微信扫码即可 使用流程 【1】准备工作: 在项目的工具包下导入...
  • 问我一朋友然后在项目中又加一些修改 这的是我朋友给我的原版 ...//设置请求头,可根据接口文档要求设置 HttpHeaders header = new HttpHeaders(); header.set(“Accept-Charset”, “UTF-8”); header.s...
  • java直接使用url和参数调用第三方接口 import org.springframework.stereotype.Component; import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net....
  • 有时我们会调用第三方接口,并取相关的返回数据。 思路:通过Map 进行获取,如果有子层,再通过Map方式进行强转后读取(注意做一下异常处理) 示例 @Transactional public String SendStartFlow(Integer NoID,...
  • Java接口异步调用

    2020-08-26 00:11:43
    主要介绍了Java接口异步调用,下面我们来一起学习一下吧
  • 第三方接口调用1.使用HttpClient的1.1 在HttpClient4.3之前的用法1.1 在HttpClient4.3之后的写法2.使用MultiValueMap+RestTemplate3.使用自带的HttpURLConnection4.使用OkHttpClient 这里的第三方上传文件接口,是指,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 278,735
精华内容 111,494
关键字:

java调用第三方接口

java 订阅
友情链接: DCT.rar