create UserServiceFactory

Author: kanat

src/main/java/io/getstream/chat/java/services/framework/DefaultClient.java

@@ -8,7 +8,6 @@
 import io.jsonwebtoken.Jwts;
 import io.jsonwebtoken.SignatureAlgorithm;
 import java.io.IOException;
-import java.lang.reflect.Proxy;
 import java.nio.charset.StandardCharsets;
 import java.security.Key;
 import java.time.Duration;
@@ -32,6 +31,7 @@ public class DefaultClient implements Client {
   private static volatile DefaultClient defaultInstance;
   @NotNull private OkHttpClient okHttpClient;
   @NotNull private Retrofit retrofit;
+  @NotNull private UserServiceFactory serviceFactory;
   @NotNull private final String apiSecret;
   @NotNull private final String apiKey;
   @NotNull private final Properties extendedProperties;
@@ -76,6 +76,7 @@ public DefaultClient(Properties properties) {
     this.apiSecret = apiSecret.toString();
     this.apiKey = apiKey.toString();
     this.retrofit = buildRetrofitClient();
+    this.serviceFactory = new UserServiceFactory(retrofit);
   }
 
   private Retrofit buildRetrofitClient() {
@@ -154,12 +155,7 @@ public <TService> TService create(Class<TService> svcClass) {
 
   @Override
   public <TService> @NotNull TService create(Class<TService> svcClass, String userToken) {
-     TService service = retrofit.create(svcClass);
-     return (TService) Proxy.newProxyInstance(
-       svcClass.getClassLoader(),
-       new Class<?>[] { svcClass },
-       new UserTokenCallProxy(okHttpClient, service, new UserToken(userToken))
-     );
+    return serviceFactory.create(svcClass, new UserToken(userToken));
   }
 
   public <TService> @NotNull TService create2(Class<TService> svcClass, String userToken) {
@@ -281,57 +277,4 @@ private static boolean hasFailOnUnknownProperties(@NotNull Properties properties
     var hasEnabled = properties.getOrDefault(propName, "false");
     return Boolean.parseBoolean(hasEnabled.toString());
   }
-
-  private static class UserCall<T> implements retrofit2.Call<T> {
-    private final retrofit2.Call<T> delegate;
-    private final UserToken token;
-
-    UserCall(retrofit2.Call<T> delegate, UserToken token) {
-      this.delegate = delegate;
-      this.token = token;
-    }
-
-    @Override
-    public retrofit2.Response<T> execute() throws IOException {
-      return delegate.execute();
-    }
-
-    @Override
-    public void enqueue(retrofit2.Callback<T> callback) {
-      delegate.enqueue(callback);
-    }
-
-    @Override
-    public boolean isExecuted() {
-      return delegate.isExecuted();
-    }
-
-    @Override
-    public void cancel() {
-      delegate.cancel();
-    }
-
-    @Override
-    public boolean isCanceled() {
-      return delegate.isCanceled();
-    }
-
-    @Override
-    public retrofit2.Call<T> clone() {
-      return new UserCall<>(delegate.clone(), token);
-    }
-
-    @Override
-    public Request request() {
-      Request original = delegate.request();
-      return original.newBuilder()
-        .tag(UserToken.class, token)
-        .build();
-    }
-
-    @Override
-    public okio.Timeout timeout() {
-      return delegate.timeout();
-    }
-  }
 }

src/main/java/io/getstream/chat/java/services/framework/UserCall.java

@@ -0,0 +1,59 @@
+package io.getstream.chat.java.services.framework;
+
+import okhttp3.Request;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+
+public class UserCall<T> implements retrofit2.Call<T> {
+  private final retrofit2.Call<T> delegate;
+  private final UserToken token;
+
+  UserCall(retrofit2.Call<T> delegate, UserToken token) {
+    this.delegate = delegate;
+    this.token = token;
+  }
+
+  @Override
+  public @NotNull retrofit2.Response<T> execute() throws IOException {
+    return delegate.execute();
+  }
+
+  @Override
+  public void enqueue(@NotNull retrofit2.Callback<T> callback) {
+    delegate.enqueue(callback);
+  }
+
+  @Override
+  public boolean isExecuted() {
+    return delegate.isExecuted();
+  }
+
+  @Override
+  public void cancel() {
+    delegate.cancel();
+  }
+
+  @Override
+  public boolean isCanceled() {
+    return delegate.isCanceled();
+  }
+
+  @Override
+  public @NotNull retrofit2.Call<T> clone() {
+    return new UserCall<>(delegate.clone(), token);
+  }
+
+  @Override
+  public @NotNull Request request() {
+    Request original = delegate.request();
+    return original.newBuilder()
+        .tag(UserToken.class, token)
+        .build();
+  }
+
+  @Override
+  public @NotNull okio.Timeout timeout() {
+    return delegate.timeout();
+  }
+}

src/main/java/io/getstream/chat/java/services/framework/UserServiceFactory.java

@@ -0,0 +1,24 @@
+package io.getstream.chat.java.services.framework;
+
+import retrofit2.Retrofit;
+
+import static java.lang.reflect.Proxy.newProxyInstance;
+
+class UserServiceFactory {
+
+  private final Retrofit retrofit;
+
+  public UserServiceFactory(Retrofit retrofit) {
+    this.retrofit = retrofit;
+  }
+
+  @SuppressWarnings("unchecked")
+  public final <TService> TService create(Class<TService> svcClass, UserToken userToken) {
+    return (TService) newProxyInstance(
+        svcClass.getClassLoader(),
+        new Class<?>[] { svcClass },
+        new UserTokenCallProxy(retrofit.callFactory(), retrofit.create(svcClass), userToken)
+    );
+  }
+
+}

src/main/java/io/getstream/chat/java/services/framework/UserTokenCallAdapterFactory.java

@@ -5,35 +5,36 @@
 import io.getstream.chat.java.services.framework.DefaultClient;
 import org.junit.jupiter.api.Test;
 import java.lang.management.ManagementFactory;
+import java.util.concurrent.TimeUnit;
 
 public class CustomTest {
 
   @Test
   void customTest() throws Exception {
-    var userId = "han_solo";
-    var userToken = User.createToken("han_solo", null, null);
+    var userId = "admin";
+    var userToken = User.createToken(userId, null, null);
     var response = User.list().userId(userId).filterCondition("id", userId).request();
     System.out.println(response);
   }
 
 
   @Test
   void userReqTest() throws Exception {
-    var userId = "han_solo";
-    var userToken = User.createToken("han_solo", null, null);
+    var userId = "admin";
+    var userToken = User.createToken(userId, null, null);
     var response = User.list().filterCondition("id", userId).withUserToken(userToken).request();
-    System.out.println("\n> " + response + "\n");
+    System.out.println("\n!.!.! " + response + "\n");
   }
 
   @Test
   void measureClientCreate() throws Exception {
-    var userId = "han_solo";
+    var userId = "admin";
     var userToken = User.createToken(userId, null, null);
 
     // Test creating a UserClient directly - should use Client-Side auth
     var defaultClient = new DefaultClient();
 
-    var iterations = 10_000_000;
+    var iterations = 100_000_000;
 
     // Warm up JVM to avoid cold start effects
     for (int i = 0; i < 10_000; i++) {
@@ -53,14 +54,14 @@ void measureClientCreate() throws Exception {
     }
     long endTime = System.nanoTime();
     long allocatedAfter1 = threadBean.getCurrentThreadAllocatedBytes();
-    long elapsedTime1 = endTime - startTime;
+    long elapsedTimeInNs1 = endTime - startTime;
     long allocated1 = allocatedAfter1 - allocatedBefore1;
 
     System.out.println("=========================================================");
 
-    System.out.println("> First loop elapsed time: " + (elapsedTime1 / 1_000_000) + " ms");
+    System.out.println("> First loop elapsed time: " + TimeUnit.NANOSECONDS.toMillis(elapsedTimeInNs1) + " ms");
     System.out.println("> First loop memory allocated: " + (allocated1 / 1024 / 1024) + " MB");
-    System.out.println("> First loop avg time per call: " + (elapsedTime1 / (double) iterations) + " ns");
+    System.out.println("> First loop avg time per call: " + (elapsedTimeInNs1 / (double) iterations) + " ns");
     System.out.println("> First loop avg memory per call: " + (allocated1 / (double) iterations) + " bytes");
 
     // Measure second test
@@ -71,20 +72,20 @@ void measureClientCreate() throws Exception {
     }
     endTime = System.nanoTime();
     long allocatedAfter2 = threadBean.getCurrentThreadAllocatedBytes();
-    long elapsedTime2 = endTime - startTime;
+    long elapsedTimeInNs2 = endTime - startTime;
     long allocated2 = allocatedAfter2 - allocatedBefore2;
 
-    System.out.println("> Second loop elapsed time: " + (elapsedTime2 / 1_000_000) + " ms");
+    System.out.println("> Second loop elapsed time: " + TimeUnit.NANOSECONDS.toMillis(elapsedTimeInNs2) + " ms");
     System.out.println("> Second loop memory allocated: " + (allocated2 / 1024 / 1024) + " MB");
-    System.out.println("> Second loop avg time per call: " + (elapsedTime2 / (double) iterations) + " ns");
+    System.out.println("> Second loop avg time per call: " + (elapsedTimeInNs2 / (double) iterations) + " ns");
     System.out.println("> Second loop avg memory per call: " + (allocated2 / (double) iterations) + " bytes");
 
     // Performance comparison
-    if (elapsedTime1 < elapsedTime2) {
-      double timesFaster = (double) elapsedTime2 / elapsedTime1;
+    if (elapsedTimeInNs1 < elapsedTimeInNs2) {
+      double timesFaster = (double) elapsedTimeInNs2 / elapsedTimeInNs1;
       System.out.println("> create is " + String.format("%.2fx", timesFaster) + " faster than create2");
     } else {
-      double timesFaster = (double) elapsedTime1 / elapsedTime2;
+      double timesFaster = (double) elapsedTimeInNs1 / elapsedTimeInNs2;
       System.out.println("> create2 is " + String.format("%.2fx", timesFaster) + " faster than create");
     }
 
@@ -96,6 +97,6 @@ void measureClientCreate() throws Exception {
       System.out.println("> create2 allocates " + String.format("%.2fx", timesLess) + " less memory than create");
     }
 
-    System.out.println("======================================================================");
+    System.out.println("=========================================================");
   }
 }