Restful风格的资源获取实现的JAVA工具类

于 2023-07-19 22:27:18 发布
阅读量173 收藏
点赞数
分类专栏： 工具类 文章标签： restful java 后端
我爱你，一起加油 ！
本文链接：https://blog.csdn.net/m0_59252007/article/details/131819279
版权

公司内部的一个工具类实现Restful风格的资源获取


 

import com.keycenter.client.HmacClient;
 
import net.sf.json.JSONObject;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.*;
import org.apache.commons.httpclient.params.HttpMethodParams;
import org.apache.http.HttpHeaders;
import org.apache.http.HttpStatus;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.DeserializationConfig.Feature;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * Restful风格的资源获取
 */
public class RestFulUtil {

    /**logger*/
    private static final Logger       LOGGER           = LoggerFactory.getLogger(
            com.bioperation.common.util.RestFulUtil.class);

    /** json mapper */
    private static final ObjectMapper mapper = new ObjectMapper();

    private static final String       APPLICATION_JSON = "application/json";

    /**
     * buc授权key
     */
    // private static String             apiKey;

    /**
     * 秘钥信息
     */
    //private static String             secretKey;

    /**
     * buc服务
     */
    private static HmacClient         client;

    /**初始化配置*/
    static {
        //设置输入时忽略JSON字符串中存在而Java对象实际没有的属性  
        mapper.getDeserializationConfig().set(Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    }

    /**
     * 执行Get请求，返回数据。
     * 
     * @param para
     * @param url
     * @param connectTimeOut http连接超时时间 ， s
     * @param soTimeOut   so socket连接超时时间 s
     * @return
     */
    public static String executeBucGet(Map<String, String> para, String url,
                                       Integer connectTimeOut, Integer soTimeOut, String apiKey,
                                       String secretKey) {
        try {
            client = new HmacClient(apiKey, secretKey, Version.V1);
            LoggerUtil.info(LOGGER, "Initialization BUC connection success");
        } catch (Exception e) {
            LOGGER.fatal("Initialize the buc connection fails", e);
        }

        try {
            String params = com.buc.keycenter.common.util.HttpClientUtils
                .encodeParams(para);
            String reqUrl = url + "?" + params;
            String result = client.get(reqUrl);
            LoggerUtil.debug(LOGGER, "【 Call BUC】execute buc get call：reqUrl:" + reqUrl + ",result："
                                  + result);

            return result;
        } catch (Exception e) {
            LOGGER.error("【Call BUC】Perform buc call fails", e);
            return null;
        }
    }

    /**
     * 执行Post restful资源请求
     * 
     * @param <T>
     * @param c
     * @param para
     * @param url
     * @return
     */
    public static <T> T executeBucGet(Class<T> c, Map<String, String> para, String url,
                                      String apiKey, String secretKey) {

        String body = executeBucGet(para, url, 18, 15, apiKey, secretKey);
        if (body == null || body.length() < 1) {
            return null;
        }
        //执行http访问
        try {
            T jsonToObject = jsonToObject(body, c);
            LoggerUtil.info(LOGGER, "Convert to object【" + jsonToObject + "】");

            return jsonToObject;
        } catch (Exception e) {
            LOGGER.error("Access 【" + url + "】to get data exception, result=" + body, e);
        }

        return null;
    }

    /**
     * 执行Post restful资源请求
     * 
     * @param <T>
     * @param c
     * @param para
     * @param url
     * @param connectTimeOut 超时时间
     * @return
     */
    public static <T> T executeBucGet(Class<T> c, Map<String, String> para, String url,
                                      Integer connectTimeOut, String apiKey, String secretKey) {

        String body = executeBucGet(para, url, connectTimeOut, connectTimeOut, apiKey, secretKey);
        LoggerUtil.info(LOGGER, "请求buc返回结果：", body);
        if (body == null || body.length() < 1) {
            return null;
        }
        //执行http访问
        try {
            T jsonToObject = jsonToObject(body, c);
            LoggerUtil.info(LOGGER, "Convert to object【" + jsonToObject + "】");

            return jsonToObject;
        } catch (Exception e) {
            LOGGER.error("Access 【" + url + "】to get data exception, result=" + body, e);
        }

        return null;
    }

    public static <T> T executeBucPost(Class<T> c, Map<String, String> para, String url,
                                       String apiKey, String secretKey) {
        try {
            client = new HmacClient(apiKey, secretKey, Version.V1);
            LoggerUtil.info(LOGGER, "Initialization BUC connection success");
        } catch (Exception e) {
            LOGGER.fatal("Initialize the buc connection fails", e);
        }
        //执行http访问
        try {
            String body = client.post(url, ClassCastUtils.castMapStringToMapList(para));
            LoggerUtil.info(LOGGER,"POST BUC Result:", body);
            if (StringUtil.isNotBlank(body)) {
                if (StringUtil.contains(body, "null")) {
                    body = StringUtil.replace(body, "null", "\\\"\\\"");
                }
                LoggerUtil.info(LOGGER, "According to the【" + url + "】get http return data【" + body
                                     + "】 success");

                T jsonToObject = jsonToObject(body, c);
                LoggerUtil.info(LOGGER, "Convert to object【" + jsonToObject + "】");

                return jsonToObject;
            } else {
                LOGGER.error("From 【" + url + "】get http return data is null ");
                return null;
            }
        } catch (Exception ex) {
            LOGGER.error("Access 【" + url + "】exception", ex);
        }
        return null;
    }

    /**
     * 执行Get restful资源请求
     * 
     * @param <T>
     * @param c
     * @param para
     * @param url
     * @return
     */
    public static <T> T executeGet(Class<T> c, Map<String, ?> para, String url,Map<String,String> requestHeaders) {
        HttpClient httpClient = new HttpClient();
        //默认超时时间设置为8s
        httpClient.getParams().setConnectionManagerTimeout(8000);
        httpClient.getParams().setSoTimeout(5000);
        HttpMethod httpMethod = new GetMethod(url);

        //设置查询参数
        if (!CollectionUtils.isEmpty(para)) {
            List<NameValuePair> paras = new ArrayList<NameValuePair>();
            Set<Entry<String, ?>> entrySet = (Set) para.entrySet();
            for (Entry<String, ?> entry : entrySet) {
                String val = entry.getValue() == null ? null : entry.getValue().toString();
                paras.add(new NameValuePair(entry.getKey(), val));
            }
            httpMethod.setQueryString(paras.toArray(new NameValuePair[paras.size()]));
        }
        //设置请求头
        if (!CollectionUtils.isEmpty(requestHeaders)) {
            Set<Entry<String, String>> entrySet = (Set) requestHeaders.entrySet();
            for (Entry<String, String> entry : entrySet) {
                String val = entry.getValue() == null ? null : entry.getValue().toString();
                httpMethod.setRequestHeader(entry.getKey(),val);

            }
        }
        //执行http访问
        try {
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Execute http get request, url" + url + ", para: " + para);
            }
            int returnCode = httpClient.executeMethod(httpMethod);
            if (returnCode == HttpStatus.SC_OK) {
                String body = httpMethod.getResponseBodyAsString();
                if (StringUtil.isBlank(body)) {
                    LOGGER.error("can not get data from url:" + url);
                    return null;
                }

                if (LOGGER.isInfoEnabled()) {
                    LOGGER.info("get data body from url : " + url + ", response body:" + body);
                }
                T jsonToObject = jsonToObject(body, c);
                if (LOGGER.isInfoEnabled()) {
                    LOGGER.info("convert body to object: " + jsonToObject);
                }

                return jsonToObject;
            } else {
                LOGGER.error("request error, url:" + url + ", code=" + returnCode);
            }
        } catch (HttpException e) {
            LOGGER.error("request error, " + url + ", client exception", e);
        } catch (IOException e) {
            LOGGER.error("request error, " + url + ", IO exception", e);
        } catch (Exception e) {
            LOGGER.error("request error, " + url + ", get data error", e);
        }

        return null;
    }

    /**
     * 执行rest的post请求
     * 
     * @param c
     * @param para
     * @param url
     * @return
     */
    public static <T> T executePost(Class<T> c, Map<String, ?> para, String url,
                                    Map<String, ?> jsonPostPara,Map<String,String> requestHeaders) {
        HttpClient httpClient = new HttpClient();
        //默认超时时间设置为8s
        httpClient.getParams().setConnectionManagerTimeout(8000);
        httpClient.getParams().setSoTimeout(5000);
        PostMethod post = new PostMethod(url);
        post.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");

        //执行json的post参数封装
        if (!CollectionUtils.isEmpty(jsonPostPara)) {
            post.setRequestHeader(HttpHeaders.CONTENT_TYPE, APPLICATION_JSON);
            try {
                String postJsonStr = JSONObject.fromObject(jsonPostPara).toString();
                RequestEntity se = new StringRequestEntity(postJsonStr, APPLICATION_JSON, "utf-8");
                post.setRequestEntity(se);
            } catch (Exception e) {
                LOGGER.error("execute post json failed, params:" + jsonPostPara);
            }
        }
        //设置请求头
        if (!CollectionUtils.isEmpty(requestHeaders)) {
            Set<Entry<String, String>> entrySet = (Set) requestHeaders.entrySet();
            for (Entry<String, String> entry : entrySet) {
                String val = entry.getValue() == null ? null : entry.getValue().toString();
                post.setRequestHeader(entry.getKey(),val);

            }
        }
        //设置post参数
        if (!CollectionUtils.isEmpty(para)) {
            List<NameValuePair> paras = new ArrayList<NameValuePair>();
            Set<Entry<String, ?>> entrySet = (Set) para.entrySet();
            for (Entry<String, ?> entry : entrySet) {
                String val = entry.getValue() == null ? null : entry.getValue().toString();
                paras.add(new NameValuePair(entry.getKey(), val));
            }
            post.setRequestBody(paras.toArray(new NameValuePair[paras.size()]));
        }
        //执行http访问
        try {
            int returnCode = httpClient.executeMethod(post);
            if (returnCode == HttpStatus.SC_OK) {
                String body = post.getResponseBodyAsString();
                if (StringUtil.isBlank(body)) {
                    LOGGER.error("get empty body from url:" + url);
                    return null;
                }
                if (StringUtil.contains(body, "null")) {
                    body = StringUtil.replace(body, "null", "\\\"\\\"");
                }
                if (LOGGER.isInfoEnabled()) {
                    LOGGER.info("get body from url:" + url + ", body:" + body);
                }

                T jsonToObject = jsonToObject(body, c);
                if (LOGGER.isInfoEnabled()) {
                    LOGGER
                        .info("convert body to object, body:" + body + ", object:" + jsonToObject);
                }

                return jsonToObject;
            } else {
                LOGGER.error("unkown status from url:" + url + ", status:" + returnCode);
            }
        } catch (Exception ex) {
            LOGGER.error("request error url:" + url, ex);
        }
        return null;
    }

    /**
     * 执行rest的put请求
     * @param c
     * @param url
     * @return
     */
    public static <T> T executePut(Class<T> c, String url, Map<String, ?> jsonPutPara, Map<String, String> requestHeaders) {
        HttpClient httpClient = new HttpClient();
        //默认超时时间设置为8s
        httpClient.getParams().setConnectionManagerTimeout(8000);
        httpClient.getParams().setSoTimeout(5000);
        PutMethod put = new PutMethod(url);
        put.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
        //执行json的post参数封装
        if (!CollectionUtils.isEmpty(jsonPutPara)) {
            put.setRequestHeader(HttpHeaders.CONTENT_TYPE, APPLICATION_JSON);
            try {
                String postJsonStr = JSONObject.fromObject(jsonPutPara).toString();
                RequestEntity se = new StringRequestEntity(postJsonStr, APPLICATION_JSON, "utf-8");
                put.setRequestEntity(se);
            } catch (Exception e) {
                LOGGER.error("executePut execute put json failed, params:" + jsonPutPara);
            }
        }
        //设置请求头
        if (!CollectionUtils.isEmpty(requestHeaders)) {
            Set<Entry<String, String>> entrySet = (Set) requestHeaders.entrySet();
            for (Entry<String, String> entry : entrySet) {
                String val = entry.getValue() == null ? null : entry.getValue().toString();
                put.setRequestHeader(entry.getKey(), val);
            }
        }
        //执行http访问
        try {
            int returnCode = httpClient.executeMethod(put);
            String body = put.getResponseBodyAsString();
            if (returnCode == HttpStatus.SC_OK) {
                if (StringUtil.isBlank(body)) {
                    LOGGER.error("executePut get empty body from url:" + url);
                    return null;
                }
                if (LOGGER.isInfoEnabled()) {
                    LOGGER.info("executePut get body from url:" + url + ", body:" + body);
                }
                T jsonToObject = jsonToObject(body, c);
                if (LOGGER.isInfoEnabled()) {
                    LOGGER
                            .info("executePut convert body to object, body:" + body + ", object:" + jsonToObject);
                }
                return jsonToObject;
            } else {
                LOGGER.error("executePut unkown status from url:" + url + ", status:" + returnCode + "responseBody = " + body);
            }
        } catch (Exception ex) {
            LOGGER.error("executePut request error url:" + url, ex);
        }
        return null;
    }

    /**
     * 从json格式反序列化回java object对象
     * 
     * @param jsonStr
     * @param clazz
     * @return <T>
     * @throws IOException 
     * @throws JsonMappingException
     * @throws JsonParseException 
     */
    private static <T> T jsonToObject(String jsonStr, Class<T> clazz) throws Exception {
        if (String.class.equals(clazz)) {
            return (T) jsonStr;
        }
        return mapper.readValue(jsonStr, clazz);
    }

}

道阻且长-行则将至-行而不辍-未来可期
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java使用restful接收数据,java 利用HttpURLConnection方式获取restful格式的服务数据
weixin_39960147的博客
03-11 451
/*** @Author：* @Description：利用HttpURLConnection方式获取restful格式的服务数据* @Date：*/private static List getjsonlist(String targetURL){List result_list = new ArrayList();try {URL restServiceURL = new URL(target...
Java进阶：SpringMVC中获取Restful风格的参数(从请求路径中获取参数 )
最新发布
m0_60575487的博客
04-03 398
现在其实从大厂招聘需求可见，在招聘要求上有高并发经验优先，包括很多朋友之前都是做传统行业或者外包项目，一直在小公司，技术搞的比较简单，没有怎么搞过分布式系统，但是现在互联网公司一般都是做分布式系统。所以说，如果你想进大厂，想脱离传统行业，这些技术知识都是你必备的，下面自己手打了一份Java并发体系思维导图，希望对你有所帮助。助。[外链图片转存中…(img-2GwYILB7-1712091482379)]
Java通用restful返回工具类
03-28
通用restful返回工具类
Java HttpClient-Restful 工具各种请求高度封装提炼总结及案例
weixin_44131922的博客
10-19 1085
总的工具要求底层完全可复用的代码全部提炼，也就是不通类型（GET, POST， DELETE, PUT 等等）请求的决定性公共步骤其实是可以提炼出来的。 即 一个请求，请求头一定会有，请求路径一定会有，发起请求一定会有，返回处理一定会有。但同时由于请求头内容可能会有不同的要求或者加密方式，所以需要将相关加工过程放到基础工具类之外，保证调用基础工具类时只执行所有请求都需要的的步骤，不带有特殊处理。这里主要使用的都是 org.apache.http 已包装的 httpClient ，项目中进一步将各种类型的请
JAVA http请求工具类
热门推荐
拾一二的博客
01-25 2万+
指定请求头自定义Cookie（cookie方法）指定是否keepAlive（keepAlive方法）指定表单内容（form方法）指定请求内容，比如rest请求指定JSON请求体（body方法）超时设置（timeout方法）指定代理（setProxy方法）指定SSL协议（setSSLProtocol）简单验证（basicAuth方法）很多时间受限于项目，开发环境，还是必须自己封装http,下边就这几贴代码了/**
restful 测试工具
06-18
restclient-1.2.jar是这个工具的主要执行文件，它是一个Java Archive（JAR）文件，包含了该RESTful测试工具的所有类和资源。运行这个JAR文件，用户可以打开一个命令行界面或者图形用户界面（GUI），根据需求输入...
三步轻松实现java restful web services
03-18
在本文中，我们将深入探讨如何分三步轻松实现Java RESTful服务。 第一步：理解REST原则 REST是一种软件架构风格，用于设计网络应用程序。它的核心概念包括资源、URI（统一资源标识符）和HTTP方法。资源通过URI来...
springmvc-restful:第一个基于springmvc-restful风格 获取url的案例
05-26
本案例将深入探讨如何在Spring MVC中实现RESTful风格的URL处理。 首先，了解RESTful的基本原则至关重要。RESTful设计通常遵循以下原则： 1. 资源导向：每个URL代表一个资源。 2. HTTP方法：使用GET、POST、PUT、...
Building RESTful Web Services with Java EE 8_Code
01-09
在构建现代Web应用程序时，RESTful（Representational State Transfer）架构风格已经成为标准，因为它提供了简单、灵活且可扩展的方式来进行客户端和服务器之间的通信。Java EE 8，全称为Java Platform, Enterprise ...
SpringMVC学习之获取Restful风格的参数
rambo_csdn_123的博客
01-07 1198
1.Restful风格简介 Restful风格的请求是使用"url+请求方式"表示一次请求方式的，有四个表示操作方式的动词： GET: 用于获取资源 POST: 用于新建资源 PUT: 用于更新资源 DELETE: 用于删除资源 例如： /user/1 GET 获得 id=1 的user /user/1 DELETE 删除 id=1 的user /user/1 PUT 更新 id=1 的user /user POST 新增user 2.Restful风格请求和
Http请求Restful风格的远程调用工具类
06-30
Http请求Restful风格的远程调用，在远程调用的过程中会出现四种请求方式，这个工具把此部分代码给封装了一下。
一款最好用的Java RESTful 接口测试工具
03-28
RESTClient一款优秀的http接口测试工具，在不知道这个工具之前还在傻傻的通过编写代码测试接口请求，有了这个工具后，测试效率极大提升。
Restful风格的参数获取
m0_63378258的博客
12-15 986
客户端使用GET、POST、PUT、DELETE4个表示操作方式的动词对服务端资源进行操作：GET用来获取资源，POST用来新建资源（也可以用于更新资源），PUT用来更新资源，DELETE用来删除资源
RESTful介绍和使用教程
dgzhang_reg的博客
08-07 286
一.REST起源 REST（Representational State Transfer）表象化状态转变（表述性状态转变），在2000年被 提出，基于HTTP、URI、XML、JSON等标准和协议，支持轻量级、跨平台、跨语言的架 计。是Web服务的一种新的架构风格（一种思想）。 1.什么是轻量级： 代码不被侵入（正例：SpringMVC中不用接口和继承，仅用注解完成。反例：Struts中每一个Action都要继承核心控制器），轻量级跟包大小无关。耦合性越低，越轻量。 ...
HttpRestful工具类
weixin_40476233的博客
07-30 452
package com.alpha.util; import net.sf.json.JSONObject; import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler; import org.apache.commons.httpclient.HttpClient; import org.apache.commons.httpclient.HttpException; import org.apache.commons.httpc
IDEA插件 RestfulTool插件——Restful服务开发辅助工具集
weixin_46411355的博客
02-19 1988
IDEA插件 RestfulTool插件——Restful服务开发辅助工具集 1.插件介绍 2.安装方式 3.使用方法
调用 Restful (RestTemplate) 接口 Util
weixin_41133273的博客
11-18 348
【代码】调用 Restful (RestTemplate) 接口 Util。
Java调用REST接口（get，post请求方法）
瑶少的博客
06-30 1万+
网上的调用方法实例千奇百怪，以下为本人自己整理的Java调用rest接口方法实例，包含get请求和post请求，可创建工具类方便调用，其中post请求解决了入出参中文乱码问题。 get方式请求 //get方式请求 public String restCallerGet(String path, String param) { //path 接口路径 xxx/xxx/xxx //param 入参 ?xxx=x&xxx=x&xxx=x //接口ip String http
restful风格的http接口调用
m0_37606574的博客
03-22 4487
说明：参数1：http请求的访问路径参数2：请求方式 post get patch delete参数3：请求内容，xml或json格式的报文，字符串都可以附代码：import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStrea...
RESTful Web Services开发者指南
"Web服务教程" 本教程是关于Web服务的深入学习指南，特别是针对使用Java技术开发的RESTful Web...这个Web服务教程是Java开发者深入理解RESTful服务设计和实现的宝贵资源，有助于提升构建现代、高效网络应用的能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

道阻且长-行则将至-行而不辍-未来可期

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值