1

我正在使用JDBC db2 driver（又名 JT400）连接到Application System/400上的 db2 服务器，这是一个中端计算机系统。

我的目标是insert into三个表，来自 IBM 大型机之外，这将是云实例（例如 Amazon WS）。

为了让性能更好

1)我正在使用已经建立的连接来连接到 db2。（使用org.apache.commons.dbcp.BasicDataSource或com.ibm.as400.access.AS400JDBCManagedConnectionPoolDataSource，两者都工作正常。）

public class AS400JDBCManagedConnectionPoolDataSource extends AS400JDBCManagedDataSource implements ConnectionPoolDataSource, Referenceable, Serializable {
}

public class AS400JDBCManagedDataSource extends ToolboxWrapper implements DataSource, Referenceable, Serializable, Cloneable {
}

2）我想缓存insert into所有三个表的语句，这样我就不必每次都发送查询并每次编译，这很昂贵。相反，我只会传递参数。（显然我正在使用JDBC prepared statements）

根据 IBM 官方文档Optimize Access to DB2 for i5/OS from Java and WebSphere，第 17-20 页 - 启用扩展动态支持，可以使用 缓存语句AS400JDBCManagedConnectionPoolDataSource。

但是，问题是insert into每次都在编译查询，这是200ms * 3 queries = 600ms每次都需要的。

我正在使用的示例，

public class CustomerOrderEventHandler extends MultiEventHandler {

    private static Logger logger = LogManager.getLogger(CustomerOrderEventHandler.class);

    //private BasicDataSource establishedConnections = new BasicDataSource();

    //private DB2SimpleDataSource nativeEstablishedConnections = new DB2SimpleDataSource();

    private AS400JDBCManagedConnectionPoolDataSource dynamicEstablishedConnections =
            new AS400JDBCManagedConnectionPoolDataSource();

    private State3 orderState3;
    private State2 orderState2;
    private State1 orderState1;

    public CustomerOrderEventHandler() throws SQLException {
        dynamicEstablishedConnections.setServerName(State.server);
        dynamicEstablishedConnections.setDatabaseName(State.DATABASE);
        dynamicEstablishedConnections.setUser(State.user);
        dynamicEstablishedConnections.setPassword(State.password);
        dynamicEstablishedConnections.setSavePasswordWhenSerialized(true);
        dynamicEstablishedConnections.setPrompt(false);
        dynamicEstablishedConnections.setMinPoolSize(3);
        dynamicEstablishedConnections.setInitialPoolSize(5);
        dynamicEstablishedConnections.setMaxPoolSize(50);
        dynamicEstablishedConnections.setExtendedDynamic(true);
        Connection connection = dynamicEstablishedConnections.getConnection();
        connection.close();
    }

    public void onEvent(CustomerOrder orderEvent){
        long start =  System.currentTimeMillis();
        Connection dbConnection = null;
        try {
            dbConnection = dynamicEstablishedConnections.getConnection();
            long connectionSetupTime = System.currentTimeMillis() - start;

            state3 = new State3(dbConnection);
            state2 = new State2(dbConnection);
            state1 = new State1(dbConnection);

            long initialisation = System.currentTimeMillis() - start - connectionSetupTime;

            int[] state3Result = state3.apply(orderEvent);
            int[] state2Result = state2.apply(orderEvent);
            long state1Result = state1.apply(orderEvent);

            dbConnection.commit();

            logger.info("eventId="+ getEventId(orderEvent) +
                    ",connectionSetupTime=" + connectionSetupTime +
                    ",queryPreCompilation=" + initialisation +
                    ",insertionOnlyTimeTaken=" +
                    (System.currentTimeMillis() - (start + connectionSetupTime + initialisation)) +
                    ",insertionTotalTimeTaken=" + (System.currentTimeMillis() - start));
        } catch (SQLException e) {
            logger.error("Error updating the order states.", e);
            if(dbConnection != null) {
                try {
                    dbConnection.rollback();
                } catch (SQLException e1) {
                    logger.error("Error rolling back the state.", e1);
                }
            }
            throw new CustomerOrderEventHandlerRuntimeException("Error updating the customer order states.", e);
        }
    }

    private Long getEventId(CustomerOrder order) {
        return Long.valueOf(order.getMessageHeader().getCorrelationId());
    }
}

带有插入命令的状态如下所示，

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class State2 extends State {

    private static Logger logger = LogManager.getLogger(DetailState.class);

    Connection connection;
    PreparedStatement preparedStatement;

    String detailsCompiledQuery = "INSERT INTO " + DATABASE + "." + getStateName() +
            "(" + DetailState.EVENT_ID + ", " +
            State2.ORDER_NUMBER + ", " +
            State2.SKU_ID + ", " +
            State2.SKU_ORDERED_QTY + ") VALUES(?, ?, ?, ?)";

    public State2(Connection connection) throws SQLException {
        this.connection = connection;
        this.preparedStatement = this.connection.prepareStatement(detailsCompiledQuery); // this is taking ~200ms each time
        this.preparedStatement.setPoolable(true); //might not be required, not sure
    }

    public int[] apply(CustomerOrder event) throws StateException {

        event.getMessageBody().getDetails().forEach(detail -> {
            try {
                preparedStatement.setLong(1, getEventId(event));
                preparedStatement.setString(2, getOrderNo(event));
                preparedStatement.setInt(3, detail.getSkuId());
                preparedStatement.setInt(4, detail.getQty());
                preparedStatement.addBatch();
            } catch (SQLException e) {
                logger.error(e);
                throw new StateException("Error setting up data", e);
            }
        });

        long startedTime = System.currentTimeMillis();
        int[] inserted = new int[0];
        try {
            inserted = preparedStatement.executeBatch();
        } catch (SQLException e) {
            throw new StateException("Error updating allocations data", e);
        }
        logger.info("eventId="+ getEventId(event) +
                ",state=details,insertionTimeTaken=" + (System.currentTimeMillis() - startedTime));
        return inserted;
    }

    @Override
    protected String getStateName() {
        return properties.getProperty("state.order.details.name");
    }
}

所以流程是每次接收到一个事件（例如CustomerOrder）时，它会获取已建立的连接，然后要求状态初始化它们statement的 s。

计时指标如下所示，

对于第一个事件，需要为 3 个表580ms创建preparedStatements。

{"timeMillis":1489982655836,"thread":"ScalaTest-run-running-CustomerOrderEventHandlerSpecs","level":"INFO","loggerName":"com.xyz.customerorder.events.handler.CustomerOrderEventHandler",
"message":"eventId=1489982654314,connectionSetupTime=1,queryPreCompilation=580,insertionOnlyTimeTaken=938,insertionTotalTimeTaken=1519","endOfBatch":false,"loggerFqcn":"org.apache.logging.log4j.spi.AbstractLogger","threadId":1,"threadPriority":5}

对于第二个事件，需要470ms为 3 个表准备语句，这比第一个事件要少，但< 100ms我认为它要少得多，因为它甚至不应该进行编译。

{"timeMillis":1489982667243,"thread":"ScalaTest-run-running-PurchaseOrderEventHandlerSpecs","level":"INFO","loggerName":"com.xyz.customerorder.events.handler.CustomerOrderEventHandler",
"message":"eventId=1489982665456,connectionSetupTime=0,queryPreCompilation=417,insertionOnlyTimeTaken=1363,insertionTotalTimeTaken=1780","endOfBatch":false,"loggerFqcn":"org.apache.logging.log4j.spi.AbstractLogger","threadId":1,"threadPriority":5}

我在想的是，因为我正在关闭preparedStatement那个特定的连接，它甚至不存在新的连接。如果是这种情况，那么在多线程环境中进行语句缓存有什么意义。

该文档有类似的示例，其中它在同一内部进行交易，connection这对我来说不是这种情况，因为我需要同时有多个连接。

快照

问题

基本的

Q1) DB2 JDBC 驱动程序是否在多个连接之间缓存语句？因为我在准备声明时没有看到太大的不同。（参见示例，第一个需要~600ms，第二个需要~500ms）

参考

ODP = 开放数据路径

SQL 包

SQL 包是永久对象，用于存储与准备好的 SQL 语句相关的信息。IBM iSeries Access 可以将它们用于 IBM Toolbox for Java JDBC 驱动程序。它们也被使用 QSQPRCED（SQL 进程扩展动态）API 接口的应用程序使用。

在 JDBC 的情况下，当客户端应用程序发出第一个 SQL 语句准备时，会检查 SQL 包的存在。如果包不存在，则在那时创建它（即使它可能还没有包含任何 SQL 语句）

Tomcat jdbc 连接池配置 - iSeries(AS400) 上的 DB2

用于 JDBC 和 SQLJ 语句缓存的 IBM 数据服务器驱动程序

4

2 回答 2

2

关于语句缓存需要注意的几个重要事项：

  • 因为Statement对象是给定的子对象Connection，一旦Connection关闭所有子对象（例如所有Statement对象）也必须关闭。
  • 不可能将来自一个连接的语句与不同的连接相关联。
  • 语句池可能由给定的 JDBC 驱动程序完成，也可能不完成。语句池也可以由连接管理层（即应用服务器）执行
  • 根据 JDBC 规范， 和 的默认值Statement.isPoolable() == false，PreparedStatement.isPoolable() == true但是此标志只是JDBC 驱动程序的提示。规范不保证会发生语句池。

首先，我不确定 JT400 驱动程序是否会缓存语句。您在问题评论中引用的文档Optimize Access to DB2 for i5/OS from Java and WebSphere特定于将 JT400 JDBC 驱动程序与 WebSphere 应用程序服务器一起使用，在幻灯片 #3 上它表明语句缓存来自 WebSphere 连接管理层，而不是原生 JDBC 驱动层。鉴于此，我将假设 JT400 JDBC 驱动程序本身不支持语句缓存。

所以此时你可能想要插入某种应用服务器（除非你想自己实现语句缓存，这有点重新发明轮子）。我确信 WebSphere Application Server 产品（传统和 Liberty）都支持任何 JDBC 驱动程序的语句缓存。

对于 WebSphere Liberty（较新的产品），数据源配置如下：

<dataSource jndiName="jdbc/myDS" statementCacheSize="10">
    <jdbcDriver libraryRef="DB2iToolboxLib"/>
    <properties.db2.i.toolbox databaseName="YOURDB" serverName="localhost"/>
</dataSource>

<library id="DB2iToolboxLib">
    <fileset dir="/path/to/jdbc/driver/dir" includes="jt400.jar"/>
</library>

关键位是 的statementCacheSize属性<dataSource>，默认值为 10。

（免责声明，我是 WebSphere 开发人员，所以我将谈谈我所知道的）

于 2017-03-21T02:51:14.130 回答
0

首先，IBM i Java 文档在这里：IBM Toolbox for Java

其次，我看不到您将“扩展动态”属性设置为 true 的位置，该属性提供

一种在服务器上缓存动态 SQL 语句的机制。第一次准备特定的 SQL 语句时，它会存储在服务器上的 SQL 包中。如果包不存在，则会自动创建。在随后准备相同的 SQL 语句时，服务器可以通过使用 SQL 包中存储的信息跳过处理的重要部分。如果设置为“true”，则必须使用“package”属性设置包名称。

我认为您在使用托管池时遗漏了一些步骤……这是IBM 文档中的第一个示例 

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;

import com.ibm.as400.access.AS400JDBCManagedConnectionPoolDataSource;
import com.ibm.as400.access.AS400JDBCManagedDataSource;


public class TestJDBCConnPoolSnippet
{
    void test()
    {
        AS400JDBCManagedConnectionPoolDataSource cpds0 = new AS400JDBCManagedConnectionPoolDataSource();

        // Set general datasource properties.  Note that both connection pool datasource (CPDS) and managed
               // datasource (MDS) have these properties, and they might have different values.
        cpds0.setServerName(host);
        cpds0.setDatabaseName(host);//iasp can be here
        cpds0.setUser(userid);
        cpds0.setPassword(password);


        cpds0.setSavePasswordWhenSerialized(true);

        // Set connection pooling-specific properties.
        cpds0.setInitialPoolSize(initialPoolSize_);
        cpds0.setMinPoolSize(minPoolSize_);
        cpds0.setMaxPoolSize(maxPoolSize_);
        cpds0.setMaxLifetime((int)(maxLifetime_/1000));  // convert to seconds
        cpds0.setMaxIdleTime((int)(maxIdleTime_/1000));  // convert to seconds
        cpds0.setPropertyCycle((int)(propertyCycle_/1000));  // convert to seconds
        //cpds0.setReuseConnections(false);  // do not re-use connections

        // Set the initial context factory to use.
        System.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory");


        // Get the JNDI Initial Context.
        Context ctx = new InitialContext();

        // Note: The following is an alternative way to set context properties locally:
        //   Properties env = new Properties();
        //   env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory");
        //   Context ctx = new InitialContext(env);

        ctx.rebind("mydatasource", cpds0);  // We can now do lookups on cpds, by the name "mydatasource".

        // Create a standard DataSource object that references it.

        AS400JDBCManagedDataSource mds0 = new AS400JDBCManagedDataSource();
        mds0.setDescription("DataSource supporting connection pooling");
        mds0.setDataSourceName("mydatasource");
        ctx.rebind("ConnectionPoolingDataSource", mds0);

        DataSource dataSource_ = (DataSource)ctx.lookup("ConnectionPoolingDataSource");

        AS400JDBCManagedDataSource mds_ = (AS400JDBCManagedDataSource)dataSource_;

        boolean isHealthy = mds_.checkPoolHealth(false);  //check pool health

        Connection c = dataSource_.getConnection(); 

    }

}
于 2017-03-20T13:43:43.123 回答