fix batch 2

Author: wzy1935

src/main/java/io/vertx/httpproxy/HttpProxy.java

@@ -15,6 +15,7 @@
 import io.vertx.codegen.annotations.VertxGen;
 import io.vertx.core.Future;
 import io.vertx.core.Handler;
+import io.vertx.core.Vertx;
 import io.vertx.core.http.HttpClient;
 import io.vertx.core.http.HttpClientRequest;
 import io.vertx.core.http.HttpServerRequest;

src/main/java/io/vertx/httpproxy/cache/CacheOptions.java

@@ -3,8 +3,8 @@
 import io.vertx.codegen.annotations.DataObject;
 import io.vertx.codegen.json.annotations.JsonGen;
 import io.vertx.core.json.JsonObject;
-import io.vertx.httpproxy.impl.CacheImpl;
-import io.vertx.httpproxy.spi.cache.Cache;
+
+import java.util.Objects;
 
 /**
  * Cache options.
@@ -13,19 +13,53 @@
 @JsonGen(publicConverter = false)
 public class CacheOptions {
 
+  /**
+   * Default max size of the cache = 1000
+   */
   public static final int DEFAULT_MAX_SIZE = 1000;
 
+  /**
+   * Actual name of anonymous shared cache = {@code __vertx.DEFAULT}
+   */
+  public static final String DEFAULT_NAME = "__vertx.DEFAULT";
+
+  /**
+   * Default shared cache = {@code false}
+   */
+  public static final boolean DEFAULT_SHARED = false;
+
   private int maxSize = DEFAULT_MAX_SIZE;
+  private String name = DEFAULT_NAME;
+  private boolean shared = DEFAULT_SHARED;
 
+  /**
+   * Default constructor
+   */
   public CacheOptions() {
   }
 
+  /**
+   * Copy constructor
+   *
+   * @param other the options to copy
+   */
+  public CacheOptions(CacheOptions other) {
+    this.maxSize = other.getMaxSize();
+    this.name = other.getName();
+    this.shared = other.getShared();
+  }
+
+  /**
+   * Constructor to create an options from JSON
+   *
+   * @param json  the JSON
+   */
   public CacheOptions(JsonObject json) {
     CacheOptionsConverter.fromJson(json, this);
   }
 
   /**
-   * @return the max number of entries the cache can hold
+   * @return the max number of entries the cache can hold.
    */
   public int getMaxSize() {
     return maxSize;
@@ -45,15 +79,55 @@ public CacheOptions setMaxSize(int maxSize) {
     return this;
   }
 
-  public Cache newCache() {
-    return new CacheImpl(this);
+  /**
+   * @return the cache name used for sharing
+   */
+  public String getName() {
+    return this.name;
+  }
+
+  /**
+   * Set the cache name, used when the cache is shared, otherwise ignored.
+   * @param name the new name
+   * @return a reference to this, so the API can be used fluently
+   */
+  public CacheOptions setName(String name) {
+    Objects.requireNonNull(name, "Client name cannot be null");
+    this.name = name;
+    return this;
+  }
+
+  /**
+   * @return whether the cache is shared
+   */
+  public boolean getShared() {
+    return shared;
+  }
+
+  /**
+   * Set to {@code true} to share the cache.
+   *
+   * <p> There can be multiple shared caches distinguished by {@link #getName()}, when no specific
+   * name is set, the {@link #DEFAULT_NAME} is used.
+   *
+   * @param shared {@code true} to use a shared client
+   * @return a reference to this, so the API can be used fluently
+   */
+  public CacheOptions setShared(boolean shared) {
+    this.shared = shared;
+    return this;
   }
 
   @Override
   public String toString() {
     return toJson().toString();
   }
 
+  /**
+   * Convert to JSON
+   *
+   * @return the JSON
+   */
   public JsonObject toJson() {
     JsonObject json = new JsonObject();
     CacheOptionsConverter.toJson(this, json);

src/main/java/io/vertx/httpproxy/impl/CacheImpl.java

@@ -1,6 +1,7 @@
 package io.vertx.httpproxy.impl;
 
 import io.vertx.core.Future;
+import io.vertx.core.Vertx;
 import io.vertx.httpproxy.cache.CacheOptions;
 import io.vertx.httpproxy.spi.cache.Cache;
 import io.vertx.httpproxy.spi.cache.Resource;
@@ -16,25 +17,22 @@
 public class CacheImpl implements Cache {
 
   private final int maxSize;
-  private final Map<String, Resource> data;
-  private final LinkedList<String> records;
+  private final LinkedHashMap<String, Resource> data;
 
   public CacheImpl(CacheOptions options) {
     this.maxSize = options.getMaxSize();
-    this.data = new HashMap<>();
-    this.records = new LinkedList<>();
+    this.data = new LinkedHashMap<>() {
+      @Override
+      protected boolean removeEldestEntry(Map.Entry<String, Resource> eldest) {
+        return size() > maxSize;
+      }
+    };
   }
 
 
   @Override
   public Future<Void> put(String key, Resource value) {
-    while (records.size() >= maxSize) {
-      String toRemove = records.removeLast();
-      data.remove(toRemove);
-    }
-
     data.put(key, value);
-    records.addFirst(key);
     return Future.succeededFuture();
   }
 
@@ -45,8 +43,12 @@ public Future<Resource> get(String key) {
 
   @Override
   public Future<Void> remove(String key) {
-    records.remove(key);
     data.remove(key);
     return Future.succeededFuture();
   }
+
+  @Override
+  public Future<Void> close() {
+    return Future.succeededFuture();
+  }
 }

src/main/java/io/vertx/httpproxy/impl/ReverseProxy.java

@@ -11,7 +11,11 @@
 package io.vertx.httpproxy.impl;
 
 import io.vertx.core.Future;
+import io.vertx.core.Vertx;
 import io.vertx.core.http.*;
+import io.vertx.core.internal.CloseFuture;
+import io.vertx.core.internal.VertxInternal;
+import io.vertx.core.internal.http.*;
 import io.vertx.core.internal.logging.Logger;
 import io.vertx.core.internal.logging.LoggerFactory;
 import io.vertx.core.net.NetSocket;
@@ -33,13 +37,27 @@ public class ReverseProxy implements HttpProxy {
   public ReverseProxy(ProxyOptions options, HttpClient client) {
     CacheOptions cacheOptions = options.getCacheOptions();
     if (cacheOptions != null) {
-      Cache cache = cacheOptions.newCache();
+      Cache cache = newCache(cacheOptions, ((HttpClientInternal) client).vertx());
       addInterceptor(new CachingFilter(cache));
     }
     this.client = client;
     this.supportWebSocket = options.getSupportWebSocket();
   }
 
+  public Cache newCache(CacheOptions options, Vertx vertx) {
+    if (options.getShared()) {
+      CloseFuture closeFuture = new CloseFuture();
+      return ((VertxInternal) vertx).createSharedResource("__vertx.shared.proxyCache", options.getName(), closeFuture, (cf_) -> {
+        Cache cache = new CacheImpl(options);
+        cf_.add(completion -> {
+          cache.close().onComplete(completion);
+        });
+        return cache;
+      });
+    }
+    return new CacheImpl(options);
+  }
+
   @Override
   public HttpProxy originRequestProvider(BiFunction<HttpServerRequest, HttpClient, Future<HttpClientRequest>> provider) {
     selector = provider;

src/main/java/io/vertx/httpproxy/spi/cache/Cache.java

@@ -1,6 +1,7 @@
 package io.vertx.httpproxy.spi.cache;
 
 import io.vertx.core.Future;
+import io.vertx.core.dns.SrvRecord;
 
 
 /**
@@ -9,7 +10,9 @@
 public interface Cache {
 
   /**
-   * Being called when the cache attempts to add a new cache item.
+   * Being called when the proxy attempts to add a new cache item.
+   * The cache can only store up to maxSize of the latest items based
+   * on CacheOptions.
    *
    * @param key the URI of the resource
    * @param value the cached response
@@ -18,20 +21,27 @@ public interface Cache {
   Future<Void> put(String key, Resource value);
 
   /**
-   * Being called when the cache attempts to fetch a cache item.
+   * Being called when the proxy attempts to fetch a cache item.
    *
    * @param key the URI of the resource
    * @return the cached response, null if not exist
    */
   Future<Resource> get(String key);
 
   /**
-   * Being called when the cache attempts to delete a cache item,
+   * Being called when the proxy attempts to delete a cache item,
    * typically caused by invalidating an existing item. Do nothing
    * if not exist.
    *
    * @param key the URI of the resource
    * @return a succeed void future
    */
   Future<Void> remove(String key);
+
+  /**
+   * Being called when need to close the cache.
+   *
+   * @return a succeed void future
+   */
+  Future<Void> close();
 }

src/main/java/io/vertx/httpproxy/spi/cache/Resource.java

@@ -18,14 +18,16 @@
 import io.vertx.httpproxy.ProxyResponse;
 import io.vertx.httpproxy.impl.ParseUtils;
 
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.time.Instant;
 
 /**
  * The cached object.
  */
 public class Resource implements ClusterSerializable {
 
-  private static final String UTF_8 = "utf-8";
+  private static final Charset UTF_8 = StandardCharsets.UTF_8;
 
   private String absoluteUri;
   private int statusCode;
@@ -148,7 +150,7 @@ private static Buffer readBuffer(Buffer buffer, Cursor cursor) {
   }
 
   private static void appendString(Buffer buffer, String string) {
-    appendBuffer(buffer, string == null ? null : Buffer.buffer(string, UTF_8));
+    appendBuffer(buffer, string == null ? null : Buffer.buffer(string.getBytes(UTF_8)));
   }
 
   private static String readString(Buffer buffer, Cursor cursor) {