通过HttpClient传递字节数组

俞渐俞烈

Success

Base64

   一个加密技术,由64个不同的字符进行加密,在本文章中，我传递过去的数据是加密后的字节，而提供者接收参数后将数据进行解析并且转换字节数组。

Base64依赖

<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.13</version>
</dependency>

OkHttp

   最近做了一个小测试,那就是如何通过HttpClient请求的时候进行传递字节数组,因为我们一般都是网页中请求，并且如果要是照片或者文件的话我们都会以流的行式进行传递，所以突发想象，想通过HttpClient的方式来传递字节数组，刚开始传递的时候发现如果不把字节进行加密传递的话，最终获取到的字节会和传递的字节不一致,当把字节加密后之后，是可以的，但是仅限于小文件或小图片(几kb)，由于http的请求限制参数的最长长度，所以我们如果想要传递大图片或文件的话，需要通过body体来进行实现，HttpClient的方式可以实现，但是较为麻烦，又要设置头又要设置尾的，所以我就用了OkHttp（基于HttpClient的优化），它有个工具类,特别方便，只要将要放在body体中的参数传递过去即可，具体实现都由OkHttp帮我们做好了，它会把我们的参数放置到body体中,通过RequestBody来进行存储，而我们被请求端(可以理解为提供者)这边接收参数的时候只需要从body体中获取即可，无需在进行参数名称对应。
OkHttp依赖

  <!--okhttp的依赖地址-->
     <dependency>
          <groupId>com.squareup.okhttp3</groupId>
          <artifactId>okhttp</artifactId>
           <version>3.14.7</version>
     </dependency>

TestRequest.java方法中

class TestRequest {
    //调用
    public static void main(String[] args) {
        result(url);  //url参数
    }
	//进行请求
	public static String result(String url) {
       File f = new File("D:\\logs\\30.png");  //本地图片地址
        byte [] fileByte = File2byte(f);	  //将流转换成字节数组 
        String post = null;
        try {
            post = HttpClientUtil.post(url, urlencode2(fileByte)); //进行请求
        } catch (IOException e) {
            e.printStackTrace();
        }
        //返回值
        System.out.println(post);
        return null;
    }
	/**
     * 将文件转换成byte数组
     * @param tradeFile
     * @return
     */
    public static byte[] File2byte(File tradeFile){
        byte[] buffer = null;
        try
        {
            FileInputStream fis = new FileInputStream(tradeFile);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            byte[] b = new byte[1024];
            int n;
            while ((n = fis.read(b)) != -1)
            {
                bos.write(b, 0, n);
            }
            fis.close();
            bos.close();
            buffer = bos.toByteArray();
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }
        return buffer;
    }
	
	//import org.apache.commons.codec.binary.Base64 包结构
	//base64进行加密  
	 public static String urlencode2(byte[] bytes) {
        String str = Base64.encodeBase64String(bytes);
        return str;
    }	
}	

HttpClietUtil.java    由OkHttp进行提供

public class HttpClientUtil {
  private static final Logger log = LoggerFactory.getLogger(HttpClientUtil.class);
  private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
  private static final OkHttpClient CLIENT = client();

  private static OkHttpClient client() {
    return new OkHttpClient.Builder()
        // 记录请求和响应
        .addInterceptor(new LogInterceptor())
        // 连接超时
        .connectTimeout(10, TimeUnit.SECONDS)
        // 读取超时
        .readTimeout(10, TimeUnit.SECONDS)
        // 写入超时
        .writeTimeout(10, TimeUnit.SECONDS)
        .build();
  }

  private static Request request(String uri) {
    return new Request.Builder().url(uri).build();
  }

  public static String response(String uri) throws IOException {
    log.info("HttpClientUtil-request: {}", uri);
    try (Response response = CLIENT.newCall(request(uri)).execute()) {
      if (!response.isSuccessful()) {
        throw new IOException("Unexpected code " + response);
      }
      String string = response.body().string();
      log.info("HttpClientUtil-responsebody: {}", string);
      return string;
    }
  }

  public static String post(String url, String json) throws IOException {
    RequestBody body = RequestBody.create(JSON, json);
    Request request = new Request.Builder()
            .url(url)
            .post(body)
            .build();
    Response response = CLIENT.newCall(request).execute();
    return response.body().string();
  }

  public static String get(String url, Map<String, String> params, Map<String, String> headMap) throws IOException{
    // 设置HTTP请求参数
    String result = null;
    url += getParams(params);
    Headers setHeaders = SetHeaders(headMap);
    Request request = new Request.Builder().url(url).headers(setHeaders).build();
    Call call = CLIENT.newCall(request);
    try {
      Response response = call.execute();
      result = response.body().string();
    } catch (Exception e) {
      throw new IOException("Unexpected code " + e);
    }
    return result;
  }

  public static String getParams(Map<String, String> params) {
    StringBuffer sb = new StringBuffer("?");
    if (!params.isEmpty()) {
      for (Map.Entry<String, String> item : params.entrySet()) {
        String value = item.getValue();
        if (StringUtils.isNotEmpty(value)) {
          sb.append("&");
          sb.append(item.getKey());
          sb.append("=");
          sb.append(value);
        }
      }
      return sb.toString();
    } else {
      return "";
    }
  }

  public static Headers SetHeaders(Map<String, String> headersParams) {
    Headers headers = null;
    Headers.Builder headersbuilder = new Headers.Builder();
    if (!headersParams.isEmpty()) {
      Iterator<String> iterator = headersParams.keySet().iterator();
      String key = "";
      while (iterator.hasNext()) {
        key = iterator.next().toString();
        headersbuilder.add(key, headersParams.get(key));
      }
    }
    headers = headersbuilder.build();
    return headers;
  }


  private static class LogInterceptor implements Interceptor {
    // TODO 优化HttpClientUtil - zany
    @Override
    public Response intercept(Chain chain) throws IOException {
      Request request = chain.request();
      Response response = chain.proceed(request);
      MediaType mediaType = response.body().contentType();
      String str = response.body().string();
      return response.newBuilder().body(ResponseBody.create(mediaType, str)).build();
    }
  }
}

提供者

 @PostMapping(value = "/demoArray")
    @ResponseBody
    public String index3(@RequestBody String val) {
		//+符号传递过程中会变成空格,所以需要引用一下。
        String replace = val.replace(" ", "+");
		//paramone代表的是解析后的字节数组，paramtwo代表的是要将文件或照片写在某个地址
        byte2File(Base64.decodeBase64(replace), "D:\\logs\\13.png"); 
        return "success";
    }

    /**
     * @param b          字节数组
     * @param outputFile 文件全路径
     */
    public void byte2File(byte[] b, String outputFile) {
        File file = null;
        FileOutputStream output = null;
        try {
            file = new File(outputFile);
            if (file.exists()) {
                file.delete();
            }
            output = new FileOutputStream(file);
            output.write(b);
            output.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (output != null) {
                try {
                    output.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

效果图