影響性能的測試報告（數據庫版）測試源代碼_性能測試

影響性能的測試報告（數據庫版）測試源代碼

發表于：2007-05-22來源：作者：點擊數：標簽：數據庫性能測試報告測試報告源代碼

CapabilityForConnection主運行程序，讀取配置文件init.properties、reference.properties初始化參數。調用 POOLTEST（一次完整的測試用例），計算其平均時間與使用連接數 package com.cea.repository.test; import org.apache.commons.logging.LogFactory;

CapabilityForConnection 主運行程序，讀取配置文件init.properties、reference.properties初始化參數。調用POOLTEST（一次完整的測試用例），計算其平均時間與使用連接數

package com.cea.repository.test;

import org.apache.commons.logging.LogFactory;
import org.apache.commons.logging.Log;
import java.util.Properties;
import java.io.FileInputStream;
import java.io.InputStream;

public class CapabilityForConnection {
    private static Log log = LogFactory.getLog(CapabilityForConnection.class);
    /**
     * 計算一次測試所消耗的時間
     */
    public static long times = 0;
    /**
     * 連接數
     */
    public static long psize = 0;

    public static void main(String[] args) throws Exception {
        /**
         * 運行的次數
         */
        int size = 1;
        /**
         * 見POOLTEST說明
         */
        int execsum = 0;
        /**
         * 見POOLTEST說明
         */
        int opencon = 0;
        /**
         * execsum對應properties的命名
         */
        String execs = null;
        /**
         * opencon對應properties的命名
         */
        String openc = null;

        long sumtime = 0;
        Properties prop = initProperty("reference.properties");
        Properties init = initProperty("init.properties");

        if (init.size() > 0) {
            Object o = init.get("init");
            size = Integer.parseInt(o.toString());
            execs = init.get("name0").toString();
            openc = init.get("name1").toString();
        }

        for (int i = 0; i < prop.size() / 2; i++) {
            execsum = Integer.parseInt(prop.getProperty(execs + i).toString());
            opencon = Integer.parseInt(prop.getProperty(openc + i).toString());
            sumtime = 0;
            psize = 0;
            log.info("第" + (i + 1) + "組數據:");
            log.info("并發應用數：" + execsum + " 模擬連接數：" + opencon);

            String[] reference = {"" + execsum, "" + opencon};
            for (int j = 0; j < size; j++) {
                times = 0;
                PoolTest.main(reference);
                sumtime += times;
            }
            log.info("第" + (i + 1) + "組數據共執行" + size + "次;平均耗時為：" +
                     sumtime / (size * execsum) + "毫秒");
            log.info("平均使用" + psize / size + "個連接");

        }
    }

    private static Properties initProperty(String filename) throws Exception {
        InputStream is = new FileInputStream(filename);
        Properties prop = new Properties();
        prop.load(is);
        return prop;

    }
}

POOLTEST計算一次完整過程耗時，統計消耗的連接

package com.cea.repository.test;

import com.cea.repository.test.testdata.MainExecute;
import java.util.HashMap;
import java.util.Map;
import com.cea.repository.connection.PoolSupper;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.logging.Log;
/**
*
*

Title: 連接池性能測試

*
*

Description: 測試不合理的利用連接對WEB應用所造成影響.

*
*

Company:

*
* @author 小舟
* @version 1.0
*/
public class PoolTest extends Thread {
    private static Log log = LogFactory.getLog(PoolTest.class);
    /**
     * 并發執行MainExecute的數量
     */
    private static int EXECUTESUM = 35;
    /**
     * 一次MainExecute執行所請求的連接數
     */
    public static int CONNECTIONS = 3;
    /**
     * 記錄所使用的連接
     */
    public static Map poolTestMap = new HashMap();
    /**
     * 第sum次執行MainExecute所需要的時間
     */
    public int sum = 0;

    public void run() {
        try {
            long s = System.currentTimeMillis();
            com.cea.repository.test.testdata.MainExecute.main(null);
            long t = System.currentTimeMillis() - s;
            CapabilityForConnection.times +=t;
//            if(CapabilityForConnection.times < t){
//                CapabilityForConnection.times = t;
//            }

//            log.info("time" + (++sum) + ":" +
//                               (System.currentTimeMillis() - s));
        } catch (Exception ex) {
        }
    }

    public static void main(String[] args) throws Exception {
        if(args!= null && args.length>1){
            EXECUTESUM = Integer.parseInt(args[0]);
            CONNECTIONS = Integer.parseInt(args[1]);
        }

        PoolSupper.initPool();
        startExec(EXECUTESUM);
        //設定足夠長的時間等待所有程序執行完，得到準確的并發執行所消耗的時間
        try {
            Thread.sleep(6000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        log.info("運行平均耗時：" + CapabilityForConnection.times/EXECUTESUM);
        //如果條件成立，證明連接沒有被回收，只要存在一個相同的，就證明連接被重復利用了
        CapabilityForConnection.psize +=poolTestMap.size();
        if (poolTestMap.size() == EXECUTESUM) {
            log.info("不存在重復使用的連接，共創建" + poolTestMap.size()+ "個連接" );
        } else {
            log.info("共使用" + poolTestMap.size()+ "個連接" );
        }
        clear();
    }

    private static void startExec(int EXECUTESUM) {
        int i = 0;
        while (i < EXECUTESUM) {
            if (i++ < EXECUTESUM) {
                try {
                    new PoolTest().start();
                } catch (Exception ex2) {
                }
            }
        }
    }
    private static void clear() {
        poolTestMap = new HashMap();
    }

}

簡單的不能再簡單的測試代碼：

package com.cea.repository.test.testdata;

import com.cea.repository.connection.drive.ConnectionFactory;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.PreparedStatement;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import com.cea.repository.test.PoolTest;
import com.cea.repository.connection.poolpository.PoolFactory;

/**
*
*

Title:

Description:

Company: cea

* @author 小舟
* @version 1.0
*/
public class MainExecute {
    public static void main(String[] args) throws Exception {
       testConnection();
    }

    static void testConnection() throws Exception {
        for (int i = 0; i < PoolTest.CONNECTIONS; i++) {
            Connection con = PoolFactory.newInstance();
            //這里的改變直接影響連接的復用
            Thread.sleep(50);
            PoolTest.poolTestMap.put(con.toString(), "");
            con.close();
        }
    }

}

三個配置文件的內容：
init.properties文件

#運行的次數
init=5
#并發執行MainExecute的數量所匹配的名字
name0=execsum
#一次MainExecute執行所請求的連接數所匹配的名字
name1=opencon

reference.properties文件

#過濾數據
execsum0=10
opencon0=1
#第一次測試數據
execsum1=100
opencon1=6
#第二次測試數據
execsum2=85
opencon2=9
#第三次測試數據
execsum3=140
opencon3=3

最后一個是pool-config.xml數據源配置：

xml version="1.0" encoding="GB2312"?>

<defaultAutoCommit>falsedefaultAutoCommit>

<initialSize>30initialSize>

<maxActive>40maxActive>

<minIdle>0minIdle>

<maxIdle>18maxIdle>

<maxWait>10000maxWait>

<username>forumusername>

<password>kingpassword>

<driverClassName>oracle.jdbc.driver.OracleDriverdriverClassName>

<url>jdbc:oracle:thin:@192.168.1.3:1521:gzesturl>

<removeAbandoned>trueremoveAbandoned>

<removeAbandonedTimeout>10removeAbandonedTimeout>

<logAbandoned>truelogAbandoned>

ResourceParams>

DataResources>

原文轉自：http://www.kjueaiud.com

軟件測試 > 測試技術 > 性能測試 >