Source/BladeX-Tool/blade-starter-http/src/main/java/org/springblade/core/http/Exchange.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,209 @@
/*
 *      Copyright (c) 2018-2028, DreamLu All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
 *  Neither the name of the dreamlu.net developer nor the names of its
 *  contributors may be used to endorse or promote products derived from
 *  this software without specific prior written permission.
 *  Author: DreamLu å¢æ˜¥æ¢¦ (596392912@qq.com)
 */
package org.springblade.core.http;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import lombok.RequiredArgsConstructor;
import okhttp3.Call;
import okhttp3.Request;
import org.springblade.core.tool.utils.Exceptions;

import javax.annotation.Nullable;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Function;

/**
 * Exchange
 *
 * @author L.cm
 */
@RequiredArgsConstructor
public class Exchange {
   private BiConsumer<Request, IOException> failedBiConsumer = (r, e) -> {};
   private final Call call;

   public Exchange onFailed(BiConsumer<Request, IOException> failConsumer) {
      this.failedBiConsumer = failConsumer;
      return this;
   }

   public <R> R onResponse(Function<ResponseSpec, R> func) {
      try (HttpResponse response = new HttpResponse(call.execute())) {
         return func.apply(response);
      } catch (IOException e) {
         throw Exceptions.unchecked(e);
      }
   }

   @Nullable
   public <R> R onSuccess(Function<ResponseSpec, R> func) {
      try (HttpResponse response = new HttpResponse(call.execute())) {
         return func.apply(response);
      } catch (IOException e) {
         failedBiConsumer.accept(call.request(), e);
         return null;
      }
   }

   @Nullable
   public <R> R onSuccessful(Function<ResponseSpec, R> func) {
      try (HttpResponse response = new HttpResponse(call.execute())) {
         if (response.isOk()) {
            return func.apply(response);
         } else {
            failedBiConsumer.accept(call.request(), new IOException(response.toString()));
         }
      } catch (IOException e) {
         failedBiConsumer.accept(call.request(), e);
      }
      return null;
   }

   public <R> Optional<R> onSuccessOpt(Function<ResponseSpec, R> func) {
      return Optional.ofNullable(this.onSuccess(func));
   }

   public <R> Optional<R> onSuccessfulOpt(Function<ResponseSpec, R> func) {
      return Optional.ofNullable(this.onSuccessful(func));
   }

   /**
    * Returns body String.
    *
    * @return body String
    */
   public String asString() {
      return onResponse(ResponseSpec::asString);
   }

   /**
    * Returns body to byte arrays.
    *
    * @return byte arrays
    */
   public byte[] asBytes() {
      return onResponse(ResponseSpec::asBytes);
   }

   /**
    * Returns body to JsonNode.
    *
    * @return JsonNode
    */
   public JsonNode asJsonNode() {
      return onResponse(ResponseSpec::asJsonNode);
   }

   /**
    * Returns body to Object.
    *
    * @param valueType value value type
    * @return Object
    */
   public <T> T asValue(Class<T> valueType) {
      return onResponse(responseSpec -> responseSpec.asValue(valueType));
   }

   /**
    * Returns body to Object.
    *
    * @param typeReference value Type Reference
    * @return Object
    */
   public <T> T asValue(TypeReference<T> typeReference) {
      return onResponse(responseSpec -> responseSpec.asValue(typeReference));
   }

   /**
    * Returns body to List.
    *
    * @param valueType value type
    * @return List
    */
   public <T> List<T> asList(Class<T> valueType) {
      return onResponse(responseSpec -> responseSpec.asList(valueType));
   }

   /**
    * Returns body to Map.
    *
    * @param keyClass  key type
    * @param valueType value type
    * @return Map
    */
   public <K, V> Map<K, V> asMap(Class<?> keyClass, Class<?> valueType) {
      return onResponse(responseSpec -> responseSpec.asMap(keyClass, valueType));
   }

   /**
    * Returns body to Map.
    *
    * @param valueType value ç±»åž‹
    * @return Map
    */
   public <V> Map<String, V> asMap(Class<?> valueType) {
      return onResponse(responseSpec -> responseSpec.asMap(valueType));
   }

   /**
    * å°† xml、heml è½¬æˆå¯¹è±¡
    *
    * @param valueType å¯¹è±¡ç±»
    * @param <T>       æ³›åž‹
    * @return å¯¹è±¡
    */
   public <T> T asDomValue(Class<T> valueType) {
      return onResponse(responseSpec -> responseSpec.asDomValue(valueType));
   }

   /**
    * å°† xml、heml è½¬æˆå¯¹è±¡
    *
    * @param valueType å¯¹è±¡ç±»
    * @param <T>       æ³›åž‹
    * @return å¯¹è±¡é›†åˆ
    */
   public <T> List<T> asDomList(Class<T> valueType) {
      return onResponse(responseSpec -> responseSpec.asDomList(valueType));
   }

   /**
    * toFile.
    *
    * @param file File
    */
   public File toFile(File file) {
      return onResponse(responseSpec -> responseSpec.toFile(file));
   }

   /**
    * toFile.
    *
    * @param path Path
    */
   public Path toFile(Path path) {
      return onResponse(responseSpec -> responseSpec.toFile(path));
   }

}