影响性能的测试报告（数据库版）测试源代码

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应用所造成影响.

 *
 * 

Copyright: Copyright (c) 2005

 *
 * 

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: 

 * 

Copyright: Copyright (c) 2004

 * 

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"?>
<DataResources>
   <ResourceParams dateIndentity="boat1">
     <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>

测试用例

TAG: 测试报告 数据库 性能测试 源代码