update smart-http to 1.0.15 (#5787)

* update smart-http to 1.0.15-SNAPSHOT

* optimize performance

* update smart-http to 1.0.15

Co-authored-by: 三刀 <[email protected]>

frameworks/Java/smart-socket/benchmark_config.json

@@ -5,10 +5,13 @@
       "default": {
         "json_url": "/json",
         "plaintext_url": "/plaintext",
+        "db_url": "/db",
+        "query_url": "/queries?queries=",
+        "update_url": "/updates?queries=",
         "port": 8080,
         "approach": "Realistic",
         "classification": "Platform",
-        "database": "None",
+        "database": "Postgres",
         "framework": "None",
         "language": "Java",
         "flavor": "None",

frameworks/Java/smart-socket/pom.xml

@@ -9,23 +9,34 @@
     <parent>
         <groupId>org.smartboot.http</groupId>
         <artifactId>smart-http-parent</artifactId>
-        <version>1.0.15-SNAPSHOT</version>
+        <version>1.0.15</version>
     </parent>
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <maven.compiler.source>11</maven.compiler.source>
         <maven.compiler.target>11</maven.compiler.target>
         <log4j.version>2.11.0</log4j.version>
+        <aio-enhance.version>1.0.0</aio-enhance.version>
     </properties>
     <dependencies>
         <dependency>
             <groupId>org.smartboot.http</groupId>
             <artifactId>smart-http-server</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.smartboot.aio</groupId>
+            <artifactId>aio-enhance</artifactId>
+            <version>${aio-enhance.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP</artifactId>
+            <version>3.4.5</version>
+        </dependency>
         <dependency>
             <groupId>org.smartboot.socket</groupId>
             <artifactId>aio-pro</artifactId>
-            <version>1.4.12-SNAPSHOT</version>
+            <version>1.4.12</version>
         </dependency>
         <dependency>
             <groupId>com.jsoniter</groupId>
@@ -48,6 +59,11 @@
             <artifactId>log4j-core</artifactId>
             <version>${log4j.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>42.2.5</version>
+        </dependency>
     </dependencies>
     <repositories>
         <repository>

frameworks/Java/smart-socket/src/main/java/org/smartboot/http/Bootstrap.java

@@ -8,10 +8,9 @@
 
 package org.smartboot.http;
 
-import com.jsoniter.output.JsonStream;
-import com.jsoniter.output.JsonStreamPool;
-import com.jsoniter.spi.JsonException;
-import com.jsoniter.spi.Slice;
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import org.smartboot.aio.EnhanceAsynchronousChannelProvider;
 import org.smartboot.http.server.HttpMessageProcessor;
 import org.smartboot.http.server.HttpRequestProtocol;
 import org.smartboot.http.server.Request;
@@ -24,47 +23,40 @@ import org.smartboot.socket.extension.processor.AbstractMessageProcessor;
 import org.smartboot.socket.transport.AioQuickServer;
 import org.smartboot.socket.transport.AioSession;
 
+import javax.sql.DataSource;
 import java.io.IOException;
 
 public class Bootstrap {
     static byte[] body = "Hello, World!".getBytes();
 
     public static void main(String[] args) {
-//        System.setProperty("sun.nio.ch.maxCompletionHandlersOnStack", "32");
+        System.setProperty("java.nio.channels.spi.AsynchronousChannelProvider", EnhanceAsynchronousChannelProvider.class.getName());
+
         HttpRouteHandle routeHandle = new HttpRouteHandle();
-        routeHandle.route("/plaintext", new HttpHandle() {
+        routeHandle
+                .route("/plaintext", new HttpHandle() {
 
 
-            @Override
-            public void doHandle(HttpRequest request, HttpResponse response) throws IOException {
-                response.setContentLength(body.length);
-                response.setContentType("text/plain; charset=UTF-8");
-                response.write(body);
-            }
-        }).route("/json", new HttpHandle() {
+                    @Override
+                    public void doHandle(HttpRequest request, HttpResponse response) throws IOException {
+                        response.setContentLength(body.length);
+                        response.setContentType("text/plain; charset=UTF-8");
+                        response.write(body);
+                    }
+                })
+                .route("/json", new HttpHandle() {
 
-            @Override
-            public void doHandle(HttpRequest request, HttpResponse response) throws IOException {
+                    @Override
+                    public void doHandle(HttpRequest request, HttpResponse response) throws IOException {
 
-                response.setContentType("application/json");
-                JsonStream stream = JsonStreamPool.borrowJsonStream();
-                try {
-                    stream.reset(null);
-                    stream.writeVal(Message.class, new Message("Hello, World!"));
-                    Slice slice = stream.buffer();
-                    response.setContentLength(slice.tail());
-                    response.getOutputStream().write(slice.data(), 0, slice.tail());
-                } catch (IOException e) {
-                    throw new JsonException(e);
-                } finally {
-                    JsonStreamPool.returnJsonStream(stream);
-                }
-            }
-        });
+                        response.setContentType("application/json");
+                        JsonUtil.writeJsonBytes(response, new Message("Hello, World!"));
+                    }
+                });
+        initDB(routeHandle);
         HttpMessageProcessor processor = new HttpMessageProcessor();
         processor.pipeline(routeHandle);
         http(processor);
-//        https(processor);
     }
 
     public static void http(final HttpMessageProcessor processor) {
@@ -102,4 +94,21 @@ public class Bootstrap {
             e.printStackTrace();
         }
     }
+
+    private static void initDB(HttpRouteHandle routeHandle) {
+        try {
+            Class.forName("org.postgresql.Driver");
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        HikariConfig config = new HikariConfig();
+        config.setJdbcUrl("jdbc:postgresql://tfb-database:5432/hello_world");
+        config.setUsername("benchmarkdbuser");
+        config.setPassword("benchmarkdbpass");
+        config.setMaximumPoolSize(64);
+        DataSource dataSource = new HikariDataSource(config);
+        routeHandle.route("/db", new SingleQueryHandler(dataSource))
+                .route("/queries", new MultipleQueriesHandler(dataSource))
+                .route("/updates", new UpdateHandler(dataSource));
+    }
 }

frameworks/Java/smart-socket/src/main/java/org/smartboot/http/JsonUtil.java

@@ -0,0 +1,30 @@
+package org.smartboot.http;
+
+import com.jsoniter.output.JsonStream;
+import com.jsoniter.output.JsonStreamPool;
+import com.jsoniter.spi.JsonException;
+import com.jsoniter.spi.Slice;
+
+import java.io.IOException;
+
+/**
+ * @author 三刀
+ * @version V1.0 , 2020/6/16
+ */
+public class JsonUtil {
+    public static void writeJsonBytes(HttpResponse httpResponse, Object obj) {
+        JsonStream stream = JsonStreamPool.borrowJsonStream();
+        try {
+            stream.reset(null);
+            stream.writeVal(obj.getClass(), obj);
+            stream.buffer();
+            Slice slice = stream.buffer();
+            httpResponse.setContentLength(slice.tail());
+            httpResponse.getOutputStream().write(slice.data(), 0, slice.tail());
+        } catch (IOException e) {
+            throw new JsonException(e);
+        } finally {
+            JsonStreamPool.returnJsonStream(stream);
+        }
+    }
+}

frameworks/Java/smart-socket/src/main/java/org/smartboot/http/MultipleQueriesHandler.java

@@ -0,0 +1,52 @@
+package org.smartboot.http;
+
+import org.smartboot.http.server.handle.HttpHandle;
+import org.smartboot.http.utils.NumberUtils;
+
+import javax.sql.DataSource;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.concurrent.ThreadLocalRandom;
+
+/**
+ * @author 三刀
+ * @version V1.0 , 2020/6/16
+ */
+public class MultipleQueriesHandler extends HttpHandle {
+    private DataSource dataSource;
+
+    public MultipleQueriesHandler(DataSource dataSource) {
+        this.dataSource = dataSource;
+    }
+
+    @Override
+    public void doHandle(HttpRequest httpRequest, HttpResponse response) throws IOException {
+        try (Connection connection = dataSource.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM World WHERE id=?");) {
+            int queries = Math.min(Math.max(NumberUtils.toInt(httpRequest.getParameter("queries"), 1), 1), 500);
+            World[] worlds = new World[queries];
+
+            for (int i = 0; i < queries; i++) {
+                preparedStatement.setInt(1, getRandomNumber());
+                ResultSet resultSet = preparedStatement.executeQuery();
+                resultSet.next();
+                World world = new World();
+                world.setId(resultSet.getInt(1));
+                world.setRandomNumber(resultSet.getInt(2));
+                worlds[i] = world;
+                preparedStatement.clearParameters();
+            }
+            response.setContentType("application/json");
+            JsonUtil.writeJsonBytes(response, worlds);
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+        }
+    }
+
+    protected int getRandomNumber() {
+        return 1 + ThreadLocalRandom.current().nextInt(10000);
+    }
+}

frameworks/Java/smart-socket/src/main/java/org/smartboot/http/SingleQueryHandler.java

@@ -0,0 +1,44 @@
+package org.smartboot.http;
+
+import org.smartboot.http.server.handle.HttpHandle;
+
+import javax.sql.DataSource;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.concurrent.ThreadLocalRandom;
+
+/**
+ * @author 三刀
+ * @version V1.0 , 2020/6/16
+ */
+public class SingleQueryHandler extends HttpHandle {
+    private DataSource dataSource;
+
+    public SingleQueryHandler(DataSource dataSource) {
+        this.dataSource = dataSource;
+    }
+
+    @Override
+    public void doHandle(HttpRequest httpRequest, HttpResponse response) throws IOException {
+        try (Connection connection = dataSource.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM World WHERE id=?");) {
+            preparedStatement.setInt(1, getRandomNumber());
+            ResultSet resultSet = preparedStatement.executeQuery();
+            resultSet.next();
+            World world = new World();
+            world.setId(resultSet.getInt(1));
+            world.setRandomNumber(resultSet.getInt(2));
+            response.setContentType("application/json");
+            JsonUtil.writeJsonBytes(response, world);
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+        }
+    }
+
+    protected int getRandomNumber() {
+        return 1 + ThreadLocalRandom.current().nextInt(10000);
+    }
+}

frameworks/Java/smart-socket/src/main/java/org/smartboot/http/UpdateHandler.java

@@ -0,0 +1,61 @@
+package org.smartboot.http;
+
+import org.smartboot.http.server.handle.HttpHandle;
+import org.smartboot.http.utils.NumberUtils;
+
+import javax.sql.DataSource;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.concurrent.ThreadLocalRandom;
+
+/**
+ * @author 三刀
+ * @version V1.0 , 2020/6/16
+ */
+public class UpdateHandler extends HttpHandle {
+    private DataSource dataSource;
+
+    public UpdateHandler(DataSource dataSource) {
+        this.dataSource = dataSource;
+    }
+
+    @Override
+    public void doHandle(HttpRequest httpRequest, HttpResponse response) throws IOException {
+        try (Connection connection = dataSource.getConnection();
+             PreparedStatement queryPreparedStatement = connection.prepareStatement("SELECT * FROM World WHERE id=?");
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE world SET randomnumber=? WHERE id=?");) {
+            int queries = Math.min(Math.max(NumberUtils.toInt(httpRequest.getParameter("queries"), 1), 1), 500);
+            World[] worlds = new World[queries];
+
+            for (int i = 0; i < queries; i++) {
+                queryPreparedStatement.setInt(1, getRandomNumber());
+                ResultSet resultSet = queryPreparedStatement.executeQuery();
+                resultSet.next();
+                World world = new World();
+                world.setId(resultSet.getInt(1));
+                world.setRandomNumber(resultSet.getInt(2));
+                worlds[i] = world;
+                worlds[i].setRandomNumber(getRandomNumber());
+                queryPreparedStatement.clearParameters();
+            }
+
+            for (int i = 0; i < queries; i++) {
+                preparedStatement.setInt(1, worlds[i].getRandomNumber());
+                preparedStatement.setInt(2, worlds[i].getId());
+                preparedStatement.addBatch();
+            }
+            preparedStatement.executeBatch();
+            response.setContentType("application/json");
+            JsonUtil.writeJsonBytes(response, worlds);
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+        }
+    }
+
+    protected int getRandomNumber() {
+        return 1 + ThreadLocalRandom.current().nextInt(10000);
+    }
+}

frameworks/Java/smart-socket/src/main/java/org/smartboot/http/World.java

@@ -0,0 +1,26 @@
+package org.smartboot.http;
+
+/**
+ * @author 三刀
+ * @version V1.0 , 2020/6/16
+ */
+public class World {
+    private int id;
+    private int randomNumber;
+
+    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;
+    }
+}