• （转）学习使用Jmeter做压力测试(一)--压力测试基本概念

    一、性能测试的概念

            性能测试是通过自动化的测试工具模拟多种正常峰值及异常负载条件来对系统的各项性能指标进行测试。负载测试和压力测试都属于性能测试，两者可以结合进行。

    通过负载测试，确定在各种工作负载下系统的性能，目标是当负载逐渐增加时，测试系统各项性能指标的变化情况。压力测试时通过确定一个系统的瓶颈或者不能接受的

    性能点，来获取系统能提供的最大服务级别的测试。性能测试主要包括负载测试、强度测试、容量测试。

    二、性能测试的指标

            web服务器：
                Avg Rps: 平均每秒的响应次数 = 总请求数 /秒数;

                Avg time to last byte per terstion(mstes): 平均每秒业务脚本的迭代次数;

                Successful Rounds: 成功的请求;

                Failed Rounds: 失败的请求;

                Successful Hits: 成功的点击次数;

                Failed Hits: 失败的点击次数;

                Hits Per Second: 每秒点击次数;

                Successful Hits Per Second:每秒成功的点击次数;

                Failed Hits Per Second: 每秒失败的点击次数;

                Attempted Connections: 尝试连接数;

                Throughput: 吞吐率;


            数据库服务器：
                User Connections: 用户连接数，也就是数据库的连接数量;

                Number of Deadlocks: 数据库死锁;

                Butter Cache Hit: 数据库Cache 的命中情况;

     

    三、性能测试的流程

            1.明确性能测试需求;

            2.制定性能测试方案;

               2.1.测试范围

               2.2.入口标准

               2.3.出口标准

               2.4.测试策略（测试环境指标、存量数据、业务场景、测试通过标准等）

               2.5.测试风险

               2.6.测试资源         

            3.设计性能测试用例;

            4.执行性能测试用例;

            5.分析性能测试结果;

            6.生成性能测试报告;

     

    四、性能测试的工具--JMeter

            为什么是JMeter而不是LoadRunner呢  1.更少的投入，针对有限的测试成本；  2.开源工具的可定制性无可比拟；  3.通过社区得到最大程度的支持。

            JMeter是Apache组织开发的基于Java的压力测试工具。最初被设计用于web应用的测试，后来扩展到其他测试领域。可用于测试静态和动态资源，如文件、Java服务

    程序、Java对象、数据库等。JMeter能够对应用程序做功能/回归测试，通过创建带有断言的脚本来验证被测程序返回了期望的结果。而且为了保证最大限度的灵活性，

    JMeter允许使用正则表达式创建断言。

            

    五、JMeter的特性

            1.支持对多种服务类型进行测试;

            2.支持通过录制/回访方式获取测试脚本;

            3.具备高可移植性，是纯Java 程序;

            4.采用多线程框架，允许通过多个线程并发取样及通过独立的线程组对不同的功能同时取样;

            5.精心设计的GUI支持高速用户操作和精确计时;

            6.支持缓存和离线的方式分析/回放测试结果;

            7.高扩展性;

    六、JMeter常用测试元件

    1.线程组

        用来管理执行性能测试所需的JMeter线程。

        a.可以设置线程数量

        b.设置线程启动周期

        c.设置执行测试脚本的循环次数

    2.控制器

        JMeter有两种类型的控制器：采样器和逻辑控制器。

        采样器被用来向服务器发送请求。JMeter采样器包含：FTP Request、HTTP Request、JDBC Request等。

        逻辑控制器用来控制JMeter的测试逻辑，特别是何时发送请求。

    3.监听器

        监听器提供了对JMeter在测试期间收集到的信息的访问方法。

    4.定时器

        JMeter线程在发送请求之间没有间歇，通过添加定时器，设定请求之间应该间隔的时间。

    5.断言

        可以使用断言来检查从服务器获得的响应内容。

    6.配置元件

        配置元件与采样器紧密关联。虽然配置元件并不发送请求，但可添加或修改请求。

    7.前置处理器

        会在采样器发出请求之前做一些操作。

    8.后置处理器

        会在采样器发出请求之后做一些操作。

    JMeter执行顺序：配置元件=》前置处理器=》定时器=》采样器=》后置处理器=》断言=》监听器


    七、辅助测试工具开发

            下面的代码（工具:sqlexec）是一个用来向数据库（目前支持Oracle、Mysql）插入测试数据的工具。支持多线程，可插入千万级别测试数据。在后续压测中会用到该

    工具，工具开发尽量简单，一个工具只完成一个任务，同时不要重复制造轮子。

    [java] view plain copy
     
    1. package d706;  
    2.   
    3. /* 
    4.  * sql处理 
    5.  */  
    6. public class Test_DB_Insert extends Thread{  
    7.       
    8.     public static String SQLTEXT = null;  // 待处理的sql语句  
    9.       
    10.     private InputStream ins = null;       // 用于读取配置文件   
    11.     private Properties property = new Properties(); // 读取数据库配置文件  
    12.               
    13.     private String databaseType = null; // 数据库连接类型  
    14.     private String driver = null;       // 数据库驱动  
    15.         private String url = null;          // 数据库连接  
    16.         private String uName = null;        // 数据库登录用户名  
    17.         private String pwd = null;          // 数据库登录用户密码  
    18.               
    19.         private  int numOfTestRecords;      // 插入数据条数  
    20.     private  Connection con = null;     // 连接数据库  
    21.     private  PreparedStatement statement = null;  // 获取数据库操作对象  
    22.   
    23.     public  Test_DB_Insert(String sql){  
    24.         SQLTEXT = sql;                  // sql语句以参数的形式，在构造实例的时候传入  
    25.     }  
    26.               
    27.     private void init(){   // 初始化配置文件  
    28.         try{  
    29.              ins = new FileInputStream("./d706/dbconf.properties");   
    30.            }catch(FileNotFoundException ffe){  
    31.              ffe.printStackTrace();  
    32.         }  
    33.         try{  
    34.             property.load(ins);   //  
    35.            }catch(IOException ie){  
    36.              ie.printStackTrace();  
    37.         }  
    38.              
    39.         databaseType = property.getProperty("databasetype"); // 获取配置文件中设置的连接数据库类型  
    40.              
    41.         if(databaseType.toUpperCase().equals("MYSQL")){      // 判断连接数据库类型  
    42.             driver = property.getProperty("driver_mysql");  
    43.             url = property.getProperty("url_mysql");  
    44.             uName = property.getProperty("db_userName_mysql"); // 连接数据库的用户信息;  
    45.             pwd = property.getProperty("db_pwd_mysql");  
    46.         }else if(databaseType.toLowerCase().equals("oracle")){ //  
    47.             driver = property.getProperty("driver_oracle");  
    48.             url = property.getProperty("url_oracle");  
    49.             uName = property.getProperty("db_userName_oracle");  
    50.             pwd = property.getProperty("db_pwd_oracle");  
    51.         }  
    52.           
    53.     }                 
    54.               
    55.     private  synchronized  void Insert_DB(){    
    56.           
    57.         try {  
    58.               
    59.             try {  
    60.                  Class.forName( driver );  // 注册驱动;  
    61.             }catch(ClassNotFoundException cf){  
    62.                  cf.printStackTrace();  
    63.             }  
    64.                       
    65.             con = DriverManager.getConnection(url,uName, pwd); // 获取数据库连接  
    66.                       
    67.             con.setAutoCommit(false);  // 关闭事务自动提交  
    68.                        
    69.             SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss:SS");  // 记录执行时间  
    70.             TimeZone t = sdf.getTimeZone();    
    71.             t.setRawOffset(0);    
    72.             sdf.setTimeZone(t);    
    73.             Long startTime = System.currentTimeMillis();    
    74.             System.out.println("插入数据操作开始...");  
    75.                        
    76.             statement = con.prepareStatement(SQLTEXT); //创建数据库操作对象  
    77.                       
    78.             /* 
    79.              * "INSERT INTO TEST_DB(name,sex,nickname,test1,test2,test3,test4," + 
    80.                         "test5,test6,test7,test8,test9,test10,test11,test12,test13,test14," + 
    81.                         "test15,test16,test17,test18,test19,test20,test21,test22,test23," + 
    82.                         "test24,test25,test26,test27,test28,test29,test30,test31,test32," + 
    83.                         "test33,test34,test35,test36,test37,test38,test39,test40,test41," + 
    84.                         "test42) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?," + 
    85.                         "?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)" 
    86.             */  
    87.                       
    88.                 numOfTestRecords = 1000;                               //插入的测试数据量;  
    89.            
    90.                 for(int i = 0; i<numOfTestRecords; i++) {              //循环  
    91.                       statement.setString(i + 1, "DBTest-" + i);   
    92.                       //statement.setString(2, "" + i%2);          //0表示男 1表示女   
    93.                       statement.addBatch();  // 把一个SQL命令加入命令列表    
    94.                       //statement.executeUpdate(); //执行SQL;  
    95.                   }  
    96.                   statement.executeBatch(); //执行批量更新  
    97.                   con.commit();//语句执行完毕，提交事务                    
    98.                   //int[] ref = statement.executeBatch();                 
    99.                   //if(ref[numOfTestRecords-1] == 0){System.out.println("插入数据操作完成");} //  
    100.                     
    101.                   System.out.println("插入数据操作完成");  
    102.                   Long endTime = System.currentTimeMillis();    
    103.                       System.out.println("插入"+numOfTestRecords+"条数据,"+"用时(时：分：秒：毫秒)" +   
    104.                                                             sdf.format(new Date(endTime - startTime))); //  
    105.                     
    106.                 }catch(Exception e) {   
    107.                       System.out.println("异常: " + e.toString());  
    108.                       e.printStackTrace();   
    109.                 }finally{  
    110.                       
    111.                     if(statement != null){   // 关闭数据库操作对象                         
    112.                         try{  
    113.                             statement.close();  
    114.                         }catch(SQLException se){  
    115.                             se.printStackTrace();  
    116.                         }  
    117.                     }  
    118.   
    119.                     if(con != null){         // 关闭数据库连接                       
    120.                         try{  
    121.                             if(con.isClosed()){con.close();}    
    122.                         }catch(SQLException se){  
    123.                             se.printStackTrace();  
    124.                         }  
    125.                     }  
    126.                 }         
    127.     }  
    128.       
    129.     @Override  
    130.     public void run() {    // 类外调用   
    131.           
    132.         Test_DB_Insert ti = new Test_DB_Insert(SQLTEXT); // 构造实例  
    133.         ti.init();      // 初始化  
    134.                 ti.Insert_DB(); // 执行插入数据  
    135.     }  
    136.       
    137. //  public static void main(String[] args){  
    138. //                    
    139. //          Test_DB_Insert ti = new Test_DB_Insert(SQLTEXT);  
    140. //          ti.init();  //初始化  
    141. //          ti.Insert_DB();  //执行插入数据  
    142. //  }  
    143.       
    144. }  

    // 针对增删查改，可放到一个SQL处理类（Test_DB_crud）中，判断传入的SQL字符串，然后交给对应的方法去执行并在控制台输出结果。 在Test_DB_Control类

    中只是new一个Test_DB_crud类，形成了Test_DB_crud对Test_DB_Control的依赖关系。

    [java] view plain copy
     
    1. package d706;  
    2. /* 
    3.  *程序界面 
    4.  *按钮事件 
    5.  */  
    6. public class Test_DB_gui extends JFrame implements ActionListener{  
    7.   
    8.         private static final long serialVersionUID = 1L;  
    9.           
    10.         public static String SQLTEXT = null; // 界面输入的sql文本  
    11.           
    12.         private JScrollPane js = null;  
    13.           
    14.         private JPanel jp1 = null;  
    15.           
    16.         private JTextArea ta = null;  
    17.           
    18.         private JButton jb = new JButton();  
    19.           
    20.         public Test_DB_gui(){  
    21.               
    22.             this.setTitle("sqlExecV1.0");  
    23.               
    24.             ta = new JTextArea();  
    25.             ta.setText("");  
    26.               
    27.             js = new JScrollPane(ta);  
    28.             jp1 = new JPanel();  
    29.             jp1.setLayout(new BorderLayout());  
    30.             jp1.add(js,BorderLayout.CENTER);  
    31.               
    32.             jb = new JButton();  
    33.             jb.setText("执行");  
    34.             jb.addActionListener(this); // 添加监听  
    35.           
    36.             jp1.add(jb,BorderLayout.SOUTH);  
    37.               
    38.             this.getContentPane().add(jp1);  
    39.               
    40.             this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
    41.             this.setBounds(400,200,700,500);  
    42.             this.setVisible(true);        
    43.               
    44.         jb.addActionListener(new ActionListener(){  // 按钮事件  
    45.                   
    46.                 public void  actionPerformed(ActionEvent e) {  // 匿名内部类的形式实现按钮事件  
    47.                       
    48.                     SQLTEXT = ta.getText(); // 将要执行的SQL设置成静态的  
    49.                       
    50.                     Multi_process mp = new Multi_process(SQLTEXT); // 在构造实例时，传入sql  
    51.                       
    52.                     mp.run(); // 运行程序  
    53.                       
    54.                     //System.out.println( mp.SQLTEXT +"***"); // 控制台输出  
    55.                 }     
    56.             });  
    57.         }  
    58.           
    59.         public void  actionPerformed(ActionEvent e) {   
    60.             // 实现 ActionListener 接口，需要实现的方法  
    61.         }  
    62.           
    63.         public void run() {  // 运行方法  
    64.               
    65.                Test_DB_gui np =  new Test_DB_gui();  
    66.                System.out.println( np.getTitle() );   
    67.         }  
    68.     }  
    [java] view plain copy
     
    1. public class Multi_process {  
    2. /* 
    3.  *多线程 
    4.  */  
    5.     public static String SQLTEXT = null;  // 待处理的sql语句  
    6.       
    7.     public Multi_process(String sql){  
    8.         SQLTEXT = sql;                    // sql语句以参数的形式，在构造实例的时候传入  
    9.     }  
    10.       
    11.     public  void run(){  
    12.           
    13.        Test_DB_Insert  td1 = new Test_DB_Insert(SQLTEXT); // 创建实例  
    14. //     Test_DB_Insert  td2 = new Test_DB_Insert(SQLTEXT);  
    15.          
    16.        Thread t1 = td1;  // 创建线程  
    17. //         Thread t2 = td2;  
    18.          
    19.        t1.start(); // 启动线程   
    20. //         t2.start();  
    21.   
    22. //     Test_DB_Insert t3 = new Test_DB_Insert();  
    23. //     Test_DB_Insert t4 = new Test_DB_Insert();  
    24. //     t3.run();  
    25. //     t4.run();  
    26.       
    27.     }  
    28. }  
    [java] view plain copy
     
    1. public class Test_Exec {  
    2. /* 
    3.  * 程序入口 
    4.  */  
    5.     public static void main(String[] args){  
    6.         Test_DB_gui np = new Test_DB_gui();  
    7.         np.run();  
    8.     }  
    9. }  

    在Linux下执行，需打成jar包，通过shell脚本执行。以下是sqlexec的startup.sh执行脚本.

    [plain] view plain copy
     
    1. #!/bin/sh  
    2.   
    3. #  
    4. #Author: bruce  
    5. #Version: sqlExecv1.0  
    6. #Date:2013-11-20  
    7. #  
    8. read -p "please input jar file path:" jarpath  
    9. java -jar "$jarpath"  
    10.   
    11. echo "running sqlExec."  

    注：

            今天突然想到测试数据的一个问题。即造出来的数据应该更接近真实，而不是都一样。所以想利用配置文件的方式，在配置文件中写好SQL，程序读取执行配置文件

    并动态生成SQL，完成插入测试数据。这样就解决了测试数据不够真实，可能影响测试结果的问题。---------2014年11月27日 
  • 相关阅读:
    Luogu P1160 【队列安排】
    Luogu P1566 【加等式】
    CF614A 【Link/Cut Tree】
    AT994 【11の倍数】
    Luogu P2310 【loidc,看看海】
    CF401D 【Roman and Numbers】
    【[国家集训队]小Z的袜子】
    UVA10212 【The Last Non-zero Digit.】
    Luogu P3384 【【模板】树链剖分】
    20161005 NOIP 模拟赛 T2 解题报告
  • 原文地址：https://www.cnblogs.com/hua520/p/5775741.html
Copyright © 2020-2023  润新知