'commit'

pom.xml

@@ -251,11 +251,20 @@
         </dependency>
 
         <!-- https://mvnrepository.com/artifact/org.opengauss/opengauss-jdbc -->
+<!--        <dependency>-->
+<!--            <groupId>org.opengauss</groupId>-->
+<!--            <artifactId>opengauss-jdbc</artifactId>-->
+<!--            <version>5.0.0</version>-->
+<!--        </dependency>-->
+
+        <!-- https://mvnrepository.com/artifact/org.postgresql/postgresql -->
         <dependency>
-            <groupId>org.opengauss</groupId>
-            <artifactId>opengauss-jdbc</artifactId>
-            <version>5.0.0</version>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>42.6.0</version>
         </dependency>
+
+
         <!--引入kafka-->
         <dependency>
             <groupId>org.apache.kafka</groupId>

src/main/java/UnitTest/OpenGaussReadWriteSplit.java

@@ -1,7 +1,6 @@
 package UnitTest;
 
 
-import com.alibaba.druid.filter.stat.StatFilter;
 import com.jfinal.plugin.activerecord.ActiveRecordPlugin;
 import com.jfinal.plugin.activerecord.Db;
 import com.jfinal.plugin.activerecord.Record;
@@ -18,9 +17,9 @@ public class OpenGaussReadWriteSplit {
     public static DruidPlugin createDruidPlugin(String url, String username, String password, String driverClass) {
         DruidPlugin druidPlugin = new DruidPlugin(url, username, password, driverClass);
         //最大连接池数量
-        druidPlugin.setMaxActive(20);
+        druidPlugin.setMaxActive(100);
         //最小连接池数量
-        druidPlugin.setMinIdle(1);
+        druidPlugin.setMinIdle(50);
         //初始化时建立物理连接的个数，默认为0
         druidPlugin.setInitialSize(1);
         //获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
@@ -32,21 +31,22 @@ public class OpenGaussReadWriteSplit {
         //建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
         druidPlugin.setTestWhileIdle(true);
         //申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。默认为true
-        druidPlugin.setTestOnBorrow(false);
+        druidPlugin.setTestOnBorrow(true);
         //归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。默认为true
-        druidPlugin.setTestOnReturn(false);
+        druidPlugin.setTestOnReturn(true);
         //数据监控
-        druidPlugin.addFilter(new StatFilter());
+        //druidPlugin.addFilter(new StatFilter());
         return druidPlugin;
     }
 
     public static void main(String[] args) {
-        String masterUrl = "jdbc:postgresql://10.10.14.61:15400/test_db";
-        String slaveUrl = "jdbc:postgresql://10.10.14.62:15400/test_db";
-        //String slaveUrl = "jdbc:postgresql://10.10.14.61:15400,10.10.14.62:15400/test_db?loadBalanceHosts=true&targetServerType=preferSlave";
+        String masterUrl = "jdbc:postgresql://10.10.14.63:15400/test_db";
+        String passWord = "DsideaL147258369";
+
+        String slaveUrl = "jdbc:postgresql://10.10.14.61:15400,10.10.14.62:15400/test_db?loadBalanceHosts=true&targetServerType=preferSlave";
+
         String driverClass = "org.postgresql.Driver";
         String userName = "postgres";
-        String passWord = "DsideaL147258369";
 
         DruidPlugin druidMaster = createDruidPlugin(masterUrl, userName, passWord, driverClass);
         druidMaster.start();
@@ -69,11 +69,11 @@ public class OpenGaussReadWriteSplit {
         long start = System.currentTimeMillis();
 
         List<String> list=new ArrayList<>();
-        for (int i = 1; i <= 100000; i++) {
+        for (int i = 1; i <= 1000; i++) {
             sql = "insert into test(id,txt) values("+i+",'黄海')";
             list.add(sql);
         }
-        Db.batch(list,2000);
+        Db.batch(list,500);
 
         long end = System.currentTimeMillis();
         long elapsed = end - start;

src/main/java/UnitTest/OpenGaussWriteBatch.java

@@ -0,0 +1,70 @@
+package UnitTest;
+
+
+import com.jfinal.plugin.activerecord.ActiveRecordPlugin;
+import com.jfinal.plugin.activerecord.Db;
+import com.jfinal.plugin.activerecord.dialect.PostgreSqlDialect;
+import com.jfinal.plugin.druid.DruidPlugin;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static com.dsideal.FengHuang.Const.DbConst.MASTER;
+
+public class OpenGaussWriteBatch {
+    public static DruidPlugin createDruidPlugin(String url, String username, String password, String driverClass) {
+        DruidPlugin druidPlugin = new DruidPlugin(url, username, password, driverClass);
+        //最大连接池数量
+        druidPlugin.setMaxActive(100);
+        //最小连接池数量
+        druidPlugin.setMinIdle(50);
+        //初始化时建立物理连接的个数，默认为0
+        druidPlugin.setInitialSize(1);
+        //获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
+        druidPlugin.setMaxWait(60000);
+        //如果连接空闲时间大于等于minEvictableIdleTimeMillis则关闭物理连接。
+        druidPlugin.setTimeBetweenEvictionRunsMillis(60000);
+        //连接保持空闲而不被驱逐的最小时间
+        druidPlugin.setMinEvictableIdleTimeMillis(300000);
+        //建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
+        druidPlugin.setTestWhileIdle(true);
+        //申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。默认为true
+        druidPlugin.setTestOnBorrow(true);
+        //归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。默认为true
+        druidPlugin.setTestOnReturn(true);
+        return druidPlugin;
+    }
+
+    public static void main(String[] args) {
+        String masterUrl = "jdbc:postgresql://10.10.14.63:15400/test_db";
+        String passWord = "DsideaL147258369";
+
+        String driverClass = "org.postgresql.Driver";
+        String userName = "postgres";
+
+        DruidPlugin druidMaster = createDruidPlugin(masterUrl, userName, passWord, driverClass);
+        druidMaster.start();
+
+        ActiveRecordPlugin arpMaster = new ActiveRecordPlugin(MASTER, druidMaster);
+        arpMaster.setDevMode(false);
+        arpMaster.setDialect(new PostgreSqlDialect());
+        arpMaster.start();
+
+
+        String sql = "truncate table test";
+        Db.use(MASTER).update(sql);
+
+        long start = System.currentTimeMillis();
+
+        List<String> list=new ArrayList<>();
+        for (int i = 1; i <= 100000; i++) {
+            sql = "insert into test(id,txt) values("+i+",'黄海')";
+            list.add(sql);
+        }
+        Db.batch(list,500);
+
+        long end = System.currentTimeMillis();
+        long elapsed = end - start;
+        System.out.println("程序耗时：" + elapsed + " 毫秒");
+    }
+}

src/main/java/UnitTest/OpenGaussWriteShiWu_JDBC.java

@@ -0,0 +1,76 @@
+package UnitTest;
+
+import java.sql.*;
+
+public class OpenGaussWriteShiWu_JDBC {
+
+    // JDBC连接参数
+    private static final String DB_DRIVER = "org.postgresql.Driver";
+    private static final String DB_CONNECTION = "jdbc:postgresql://10.10.14.63:15400/test_db";
+    private static final String DB_USER = "postgres";
+    private static final String DB_PASSWORD = "DsideaL147258369";
+
+    // 批量插入数据
+    public static void batchInsertData() {
+        // JDBC连接对象
+        Connection conn = null;
+        // JDBC执行语句对象
+        Statement stmt = null;
+
+        try {
+            // 加载JDBC驱动程序
+            Class.forName(DB_DRIVER);
+            // 获取JDBC连接对象
+            conn = DriverManager.getConnection(DB_CONNECTION, DB_USER, DB_PASSWORD);
+            // 设置事务自动提交为false
+            conn.setAutoCommit(false);
+            // 获取JDBC执行语句对象
+            stmt = conn.createStatement();
+            // 批量插入数据的SQL语句
+            String sql = "INSERT INTO test(id, txt) " +
+                    "VALUES (?, ?)";
+            // 预编译SQL语句并添加批量操作数据
+            long start = System.currentTimeMillis();
+
+            int cnt=0;
+            for (int k = 1; k <= 10; k++) {
+                PreparedStatement pstmt = conn.prepareStatement(sql);
+                for (int i = 1; i <= 10000; i++) {
+                    cnt++;
+                    pstmt.setInt(1, cnt);
+                    pstmt.setString(2, "黄海_" + i);
+                    pstmt.addBatch();
+                }
+                // 执行批量插入操作
+                pstmt.executeBatch();
+                // 提交事务
+                conn.commit();
+            }
+
+            long end = System.currentTimeMillis();
+            long elapsed = end - start;
+            System.out.println("程序耗时：" + elapsed + " 毫秒");
+        } catch (SQLException | ClassNotFoundException e) {
+            e.printStackTrace();
+            try {
+                conn.rollback();
+            } catch (SQLException ex) {
+                ex.printStackTrace();
+            }
+        } finally {
+            try {
+                if (stmt != null) {
+                    stmt.close();
+                }
+                if (conn != null) {
+                    conn.close();
+                }
+            } catch (SQLException ex) {
+                ex.printStackTrace();
+            }
+        }
+    }
+    public static void main(String[] args) {
+        batchInsertData();
+    }
+}

src/main/java/UnitTest/OpenGaussWriteShiWu_Jfinal.java

@@ -0,0 +1,96 @@
+package UnitTest;
+
+
+import com.jfinal.plugin.activerecord.*;
+import com.jfinal.plugin.activerecord.dialect.PostgreSqlDialect;
+import com.jfinal.plugin.druid.DruidPlugin;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static com.dsideal.FengHuang.Const.DbConst.MASTER;
+
+public class OpenGaussWriteShiWu_Jfinal {
+    public static DruidPlugin createDruidPlugin(String url, String username, String password, String driverClass) {
+        DruidPlugin druidPlugin = new DruidPlugin(url, username, password, driverClass);
+        //最大连接池数量
+        druidPlugin.setMaxActive(100);
+        //最小连接池数量
+        druidPlugin.setMinIdle(50);
+        //初始化时建立物理连接的个数，默认为0
+        druidPlugin.setInitialSize(1);
+        //获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
+        druidPlugin.setMaxWait(60000);
+        //如果连接空闲时间大于等于minEvictableIdleTimeMillis则关闭物理连接。
+        druidPlugin.setTimeBetweenEvictionRunsMillis(60000);
+        //连接保持空闲而不被驱逐的最小时间
+        druidPlugin.setMinEvictableIdleTimeMillis(300000);
+        //建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
+        druidPlugin.setTestWhileIdle(true);
+        //申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。默认为true
+        druidPlugin.setTestOnBorrow(true);
+        //归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。默认为true
+        druidPlugin.setTestOnReturn(true);
+        return druidPlugin;
+    }
+
+    public static void main(String[] args) throws SQLException {
+        String masterUrl = "jdbc:postgresql://10.10.14.63:15400/test_db";
+        String passWord = "DsideaL147258369";
+
+        String driverClass = "org.postgresql.Driver";
+        String userName = "postgres";
+
+        DruidPlugin druidMaster = createDruidPlugin(masterUrl, userName, passWord, driverClass);
+        druidMaster.start();
+
+        ActiveRecordPlugin arpMaster = new ActiveRecordPlugin(MASTER, druidMaster);
+        arpMaster.setDevMode(false);
+        arpMaster.setDialect(new PostgreSqlDialect());
+        arpMaster.start();
+
+
+        String truncateSql = "truncate table test";
+        Db.use(MASTER).update(truncateSql);
+
+        //记录开始时间
+        long start = System.currentTimeMillis();
+        // 声明数据库连接
+        Connection conn = null;
+        try {
+            conn = DbKit.getConfig().getDataSource().getConnection();
+            DbKit.getConfig().setThreadLocalConnection(conn);
+            conn.setAutoCommit(false);
+            String sql = "INSERT INTO test(id, txt) " + "VALUES (?, ?)";
+            PreparedStatement pstmt = conn.prepareStatement(sql);
+            for (int i = 1; i <= 100000; i++) {
+                pstmt.setInt(1, i);
+                pstmt.setString(2, "黄海_" + i);
+                pstmt.addBatch();
+            }
+            // 执行批量插入操作
+            pstmt.executeBatch();
+            conn.commit();
+            System.out.println("事务操作成功");
+        } catch (Exception e) {
+            e.printStackTrace();
+            System.err.println("事务操作失败");
+            try {
+                conn.rollback();
+            } catch (SQLException eSql) {
+                System.err.println("Connection 回滚失败");
+            }
+        } finally {
+            if (null != conn) {
+                conn.close();
+            }
+            DbKit.getConfig().removeThreadLocalConnection();
+        }
+        long end = System.currentTimeMillis();
+        long elapsed = end - start;
+        System.out.println("程序耗时：" + elapsed + " 毫秒");
+    }
+}