Remove CachedWorld (#7894)

* Update NonBlocking

* Remove CachedWorld

frameworks/Java/redkale/benchmark_config.json

@@ -73,27 +73,6 @@
                 "display_name": "redkale-native",
                 "notes": "",
                 "versus": "Redkale"
-            },
-            "mysql": {
-                "db_url": "/db",
-                "query_url": "/queries?q=", 
-                "fortune_url": "/fortunes",
-                "update_url": "/updates?q=",
-                "port": 8080,
-                "approach": "Realistic",
-                "classification": "Fullstack",
-                "database": "MySQL",
-                "framework": "Redkale",
-                "language": "Java",
-                "flavor": "None",
-                "orm": "Raw",
-                "platform": "Redkale",
-                "webserver": "Redkale",
-                "os": "Linux",
-                "database_os": "Linux",
-                "display_name": "redkale-mysql",
-                "notes": "",
-                "versus": "Redkale"
             }
         }
     ]

frameworks/Java/redkale/conf/application.xml

@@ -2,10 +2,7 @@
 
 <application port="8585">     
     
-    <executor threads="0"/>
-    
     <properties>    
-        <property name="system.property.redkale.convert.tiny" value="false"/>    
         <property name="system.property.redkale.http.request.pipeline.sameheaders" value="true"/>  
         <property name="system.property.redkale.http.response.header.server" value="redkale"/>
         <property name="system.property.redkale.http.response.header.connection" value="none"/>

frameworks/Java/redkale/conf/source-mysql.properties

@@ -1,8 +0,0 @@
-
-
-############ DataSource ############
-redkale.datasource[].url = jdbc:mysql://tfb-database:3306/hello_world?useSSL=false&rewriteBatchedStatements=true&serverTimezone=UTC&characterEncoding=utf8
-redkale.datasource[].user = benchmarkdbuser
-redkale.datasource[].password = benchmarkdbpass
-redkale.datasource[].warnslowms = 0
-redkale.datasource[].errorslowms = 0

frameworks/Java/redkale/config.toml

@@ -54,18 +54,3 @@ orm = "Raw"
 platform = "Redkale"
 webserver = "Redkale"
 versus = "Redkale"
-
-[mysql]
-urls.db = "/db"
-urls.fortune = "/fortunes"
-urls.query = "/queries?q="
-urls.update = "/updates?q="
-approach = "Realistic"
-classification = "Fullstack"
-database = "MySQL"
-database_os = "Linux"
-os = "Linux"
-orm = "Raw"
-platform = "Redkale"
-webserver = "Redkale"
-versus = "Redkale"

frameworks/Java/redkale/redkale-mysql.dockerfile

@@ -1,12 +0,0 @@
-FROM maven:3.8.6-openjdk-18-slim as maven
-WORKDIR /redkale
-COPY src src
-COPY conf conf
-RUN rm conf/source.properties
-RUN mv conf/source-mysql.properties  conf/source.properties
-COPY pom.xml pom.xml
-RUN mvn package -q
-
-EXPOSE 8080
-
-CMD ["java", "-server", "-XX:+UseNUMA", "-XX:+UseParallelGC", "-XX:AutoBoxCacheMax=80000", "-DAPP_HOME=./", "-jar", "/redkale/target/redkale-benchmark-1.0.0.jar"]

frameworks/Java/redkale/src/main/java/org/redkalex/benchmark/BenchmarkService.java

@@ -7,8 +7,9 @@ package org.redkalex.benchmark;
 
 import java.util.*;
 import java.util.concurrent.*;
+import java.util.function.IntFunction;
 import java.util.stream.IntStream;
-import org.redkale.annotation.Resource;
+import org.redkale.annotation.*;
 import org.redkale.net.http.*;
 import org.redkale.service.AbstractService;
 import org.redkale.source.DataSource;
@@ -18,6 +19,7 @@ import org.redkale.util.AnyValue;
  *
  * @author zhangjx
  */
+@NonBlocking
 @RestService(name = " ", repair = false)
 public class BenchmarkService extends AbstractService {
 
@@ -26,9 +28,11 @@ public class BenchmarkService extends AbstractService {
     @Resource
     private DataSource source;
 
+    private WorldCache cache;
+
     @Override
     public void init(AnyValue conf) {
-        CachedWorld.Cache.getInstance(source);
+        this.cache = new WorldCache(source);
     }
 
     @RestMapping(name = "plaintext")
@@ -59,7 +63,7 @@ public class BenchmarkService extends AbstractService {
         IntStream ids = ThreadLocalRandom.current().ints(size, 1, 10001);
         int[] newNumbers = ThreadLocalRandom.current().ints(size, 1, 10001).toArray();
         return source.findsListAsync(World.class, ids.boxed())
-            .thenCompose(words -> source.updateAsync(World.setNewNumbers(words.toArray(new World[words.size()]), newNumbers))
+            .thenCompose(words -> source.updateAsync(World.updateNewNumbers(words, newNumbers))
             .thenApply(v -> words));
     }
 
@@ -73,8 +77,28 @@ public class BenchmarkService extends AbstractService {
     }
 
     @RestMapping(name = "cached-worlds")
-    public CachedWorld[] cachedWorlds(int q) {
+    public World[] cachedWorlds(int q) {
         int size = Math.min(500, Math.max(1, q));
-        return CachedWorld.Cache.getInstance(source).random(ThreadLocalRandom.current(), size);
+        return cache.random(size);
+    }
+
+    static class WorldCache {
+
+        private final IntFunction<World[]> arrayFunc = c -> new World[c];
+
+        private final World[] array;
+
+        private final IntFunction<World> mapFunc;
+
+        public WorldCache(DataSource source) {
+            List<World> list = source.queryList(World.class);
+            this.array = list.toArray(new World[list.size()]);
+            this.mapFunc = c -> array[c];
+        }
+
+        public World[] random(int size) {
+            IntStream ids = ThreadLocalRandom.current().ints(size, 0, 10000);
+            return ids.mapToObj(mapFunc).toArray(arrayFunc);
+        }
     }
 }

frameworks/Java/redkale/src/main/java/org/redkalex/benchmark/CachedWorld.java

@@ -1,85 +0,0 @@
-package org.redkalex.benchmark;
-
-import java.util.*;
-import java.util.function.IntFunction;
-import java.util.stream.IntStream;
-import org.redkale.convert.json.JsonConvert;
-import org.redkale.persistence.*;
-import org.redkale.source.DataSource;
-
-/**
- *
- * @author zhangjx
- */
-@Entity
-@Table(name = "World")
-public final class CachedWorld implements Comparable<CachedWorld> {
-
-    @Id
-    private int id;
-
-    private int randomNumber;
-
-    public CachedWorld randomNumber(int randomNumber) {
-        this.randomNumber = randomNumber;
-        return this;
-    }
-
-    public int getId() {
-        return id;
-    }
-
-    public void setId(int id) {
-        this.id = id;
-    }
-
-    public int getRandomNumber() {
-        return randomNumber;
-    }
-
-    public void setRandomNumber(int randomNumber) {
-        this.randomNumber = randomNumber;
-    }
-
-    @Override
-    public int compareTo(CachedWorld o) {
-        return Integer.compare(id, o.id);
-    }
-
-    @Override
-    public String toString() {
-        return JsonConvert.root().convertTo(this);
-    }
-
-    public static class Cache {
-
-        private static Cache instance;
-
-        static Cache getInstance(DataSource source) {
-            if (instance == null) {
-                synchronized (Cache.class) {
-                    if (instance == null) {
-                        instance = new Cache(source);
-                    }
-                }
-            }
-            return instance;
-        }
-
-        private CachedWorld[] array;
-
-        private IntFunction<CachedWorld> mapFunc = c -> array[c];
-
-        private IntFunction<CachedWorld[]> arrayFunc = c -> new CachedWorld[c];
-
-        public Cache(DataSource source) {
-            List<CachedWorld> list = source.queryList(CachedWorld.class);
-            this.array = list.toArray(new CachedWorld[list.size()]);
-        }
-
-        public CachedWorld[] random(Random random, int size) {
-            IntStream ids = random.ints(size, 0, 10000);
-            return ids.mapToObj(mapFunc).toArray(arrayFunc);
-        }
-    }
-}

frameworks/Java/redkale/src/main/java/org/redkalex/benchmark/World.java

@@ -5,7 +5,7 @@
  */
 package org.redkalex.benchmark;
 
-import java.util.Arrays;
+import java.util.*;
 import org.redkale.convert.json.JsonConvert;
 import org.redkale.persistence.*;
 
@@ -21,13 +21,10 @@ public final class World implements Comparable<World> {
 
     private int randomNumber;
 
-    public World randomNumber(int randomNumber) {
-        this.randomNumber = randomNumber;
-        return this;
-    }
-
-    public static World[] setNewNumbers(World[] worlds, int[] newNumbers) {
+    public static World[] updateNewNumbers(List<World> list, int[] newNumbers) {
+        World[] worlds = new World[list.size()];
         for (int i = 0; i < worlds.length; i++) {
+            worlds[i] = list.get(i);
             worlds[i].randomNumber = newNumbers[i];
         }
         Arrays.sort(worlds);