mina socket登录性能测试

重爱

mina socket 做的登录，客户端的原理，先生成json串（这个是我们拼接的发送报文，其中的用户名等要做参数化），再进行加密（加密规则问开发），再进行gzip加压，生成iobuffer，向服务端发送。
服务端原理，有个IP，一个端口，监听来自客户端的请求，接收iobuffer，进行gunzip解压，解密。转成json串。响应后再按加密和gzip发给客户端
客户端接收到服务端的响应信息，再进行gunzip解压，解密后转后json串（这个是我们判断响应是否正确的地方）


1.使用抓包工具，发现iobuffer的字节流没办法找出做参数化规律
2.便想从json串的地方开始做参数化，然后去查看工程，断点发登录的过程，得到json串。再找出加密和加压规则，生成iobuffer
3.eclipse写成的脚本

1. 
   
2. <blockquote>package com.test;

复制代码

4.转成jmeter脚本

1. package jmeter;
   
2. 
   
3. import java.io.InputStream;
   
4. import java.io.OutputStream;
   
5. import java.net.Socket;
   
6. import net.sf.json.JSONObject;  
   
7. 
   
8. import org.apache.jmeter.config.Arguments;
   
9. import org.apache.jmeter.protocol.java.sampler.AbstractJavaSamplerClient;
   
10. import org.apache.jmeter.protocol.java.sampler.JavaSamplerContext;
    
11. import org.apache.jmeter.samplers.SampleResult;
    
12. 
    
13. /**
    
14. *  socket 测试jmeter脚本
    
15. * @author wenhuang
    
16. *
    
17. */
    
18. public class LoginSocketTestJmeter extends AbstractJavaSamplerClient {
    
19.         private String Ip;
    
20.     private int Post;
    
21.     private String user;
    
22.     private String password;
    
23.     private String resultData;
    
24. 
    
25.     // 这个方法是用来自定义java方法入参的。
    
26.     //设置可用参数及的默认值；
    
27.     public Arguments getDefaultParameters() {
    
28.         Arguments params = new Arguments();
    
29.         params.addArgument("Ip", "192.168.1.1");
    
30.         params.addArgument("Post", "1111");
    
31.         params.addArgument("user", "test");
    
32.         params.addArgument("password", "1111");
    
33.         return params;
    
34.     }
    
35. 
    
36.     //每个线程测试前执行一次，做一些初始化工作；
    
37.     public void setupTest(JavaSamplerContext arg0) {
    
38.     }
    
39. 
    
40.     //开始测试，从arg0参数可以获得参数值；
    
41.     public SampleResult runTest(JavaSamplerContext arg0) {
    
42.             Ip = arg0.getParameter("Ip");
    
43.             Post = arg0.getIntParameter("Post");
    
44.             user = arg0.getParameter("user");
    
45.             password = arg0.getParameter("password");
    
46.             
    
47.       String json = "{\"test\":0,\"data\":{\"user\":\""+user+"\",\"password\":\""+password+"\"},\"key\":\"0\"}";
    
48.         
    
49.         SampleResult sr = new SampleResult();
    
50.         sr.setSampleLabel("登录");  //设置样品标签
    
51.         sr.setResponseMessage("请求的JSON: "+ json);
    
52.         try {
    
53.             sr.sampleStart();// jmeter 开始统计响应时间标记
    
54.             
    
55.           //1.创建客户端Socket，指定服务器地址和端口
    
56.           Socket socket=new Socket(Ip, Post);
    
57.                 //2.获取输出流，向服务器端发送信息
    
58.                 OutputStream os=socket.getOutputStream();//字节输出流               
    
59.                 os.write(getSendHex(json));
    
60.                 os.flush();
    
61.                
    
62.                 //3.获取输入流，并读取服务器端的响应信息
    
63.                 InputStream is=socket.getInputStream();               
    
64.                 resultData = getReceiveJson(is);
    
65. 
    
66.                 //4.关闭资源
    
67.                 if(os != null){  
    
68.               os.close();  
    
69.           }  
    
70.           if(is != null){  
    
71.               is.close();  
    
72.           }
    
73.           if(socket != null){  
    
74.                   socket.close();  
    
75.           }
    
76. 
    
77.           System.out.println("接收到的json ="+resultData);
    
78.           JSONObject jsonObj = JSONObject.fromObject(resultData);
    
79.           String codeNum = jsonObj.get("code").toString();
    
80.           if (Integer.parseInt(codeNum) == 200){
    
81.                   sr.setSuccessful(true);
    
82.                   System.out.println("登录成功，返回code ="+codeNum);        
    
83.               //sr.setResponseMessage("请求的JSON: "+ json + " 登录成功，返回code ="+codeNum);        //输出在查看结果树-的取样器结果中
    
84.           }else{
    
85.                   sr.setSuccessful(false);
    
86.                   System.out.println("登录失败，返回code ="+codeNum);
    
87.                   //sr.setResponseMessage("请求的JSON: "+ json + " 登录失败，返回code ="+codeNum);
    
88.           }
    
89.       
    
90.           // 通过下面的操作就可以将被测方法的响应输出到Jmeter的察看结果树中的响应数据里面了。
    
91.           if (resultData != null && resultData.length() > 0) {
    
92.               sr.setResponseData("返回结果是："+resultData, null);  //输出在查看结果树-的响应结果中
    
93.               sr.setDataType(SampleResult.TEXT);
    
94.           }
    
95.           // System.out.println(resultData);
    
96.             
    
97.         } catch (Throwable e) {
    
98.             sr.setSuccessful(false);
    
99.             e.printStackTrace();
    
100.         } finally {
     
101.                 sr.sampleEnd();// jmeter 结束统计响应时间标记
     
102.         }
     
103.         return sr;
     
104.     }
     
105. 
     
106.     //测试结束时调用；
     
107.     public void teardownTest(JavaSamplerContext arg0) {
     
108.          //System.out.println(end);
     
109.          //System.out.println("The cost is"+(end-start)/1000);
     
110.     }
     
111.    
     
112.     // main只是为了调试用，最后打jar包的时候注释掉。
     
113.     /*
     
114.       public static void main(String[] args)
     
115.       { // TODO Auto-generated method stub
     
116.               for (int i =0;i<5;i++){
     
117.           Arguments params = new Arguments();
     
118.           params.addArgument("Ip", "192.168.1.111");//设置参数，并赋予默认值
     
119.           params.addArgument("Post", "1111");//设置参数，并赋予默认值
     
120.           params.addArgument("user", "test");//设置参数，并赋予默认值
     
121.           params.addArgument("password", "1111");
     
122.           JavaSamplerContext arg0 = new JavaSamplerContext(params);
     
123.           LoginSocketTestJmeter test = new LoginSocketTestJmeter();
     
124.           test.setupTest(arg0);
     
125.           test.runTest(arg0);
     
126.           test.teardownTest(arg0);
     
127.               }
     
128.       }
     
129.       */
     
130.      
     
131. }
     

复制代码

5.将相关类打包成jar包放在 X:\apache-jmeter-3.0\lib\ext目录下，使用jmeter进行压测试

重爱

重爱

1. package com.test;
   
2. 
   
3. import java.io.IOException;
   
4. import java.io.InputStream;
   
5. import java.io.OutputStream;
   
6. import java.net.Socket;
   
7. import java.net.UnknownHostException;
   
8. import net.sf.json.JSONObject;
   
9. import org.apache.mina.core.buffer.IoBuffer;
   
10. //这两个加密加压的包根据项目修改
    
11. import com.tools.Des3;
    
12. import com.tools.ZLibUtils;
    
13. 
    
14. /**socket 发送消息，和接收消息 测试脚本
    
15. * @author Administrator
    
16. *
    
17. */
    
18. public class LoginSocketTest {
    
19.         public static void main(String[] args) throws Exception {
    
20.                 try {
    
21.                         //1.创建客户端Socket，指定服务器地址和端口
    
22.                         Socket socket=new Socket("192.168.1.1", 11111);
    
23.                         //2.获取输出流，向服务器端发送信息
    
24.                         OutputStream os=socket.getOutputStream();//字节输出流
    
25.                         //PrintWriter pw=new PrintWriter(os);//将输出流包装为打印流
    
26.                        
    
27.                         String json = "{\"test\":0,\"data\":{\"user\":\"test\",\"password\":\"test\"},\"key\":\"0\"}";
    
28.                         //将json转成16进制的字节流
    
29.                         os.write(getSendHex(json));
    
30.                         //发送
    
31.                         os.flush();
    
32.                         //socket.shutdownOutput();//关闭输出流
    
33.                        
    
34.                         //3.获取输入流，并读取服务器端的响应信息
    
35.                         InputStream is=socket.getInputStream();             
    
36.                         //将接收的字节流转成json
    
37.                         String recjson = getReceiveJson(is);
    
38.                         //判断结果是否正确  将json转为object对象，取出要判断的参数值code做断言。
    
39.       JSONObject jsonObj = JSONObject.fromObject(recjson);
    
40.       String codeNum = jsonObj.get("code").toString();
    
41.       System.out.println("code="+codeNum);
    
42. 
    
43.                         //4.关闭资源
    
44.                         if(os != null){  
    
45.           os.close();  
    
46.       }  
    
47.       if(is != null){  
    
48.           is.close();  
    
49.       }
    
50.       if(socket != null){  
    
51.               socket.close();  
    
52.       }
    
53.                 
    
54.                 } catch (UnknownHostException e) {
    
55.                         e.printStackTrace();
    
56.                 } catch (IOException e) {
    
57.                         e.printStackTrace();
    
58.                 }
    
59.         }
    
60. 
    
61.         /**
    
62.          * json转为客户端发送的16进制报文
    
63.          * @param json
    
64.          * @return
    
65.          * @throws Exception
    
66.          */
    
67.         public static byte[] getSendHex(String json) throws Exception {
    
68.                 System.out.println("json ="+json);
    
69.                 IoBuffer buff = IoBuffer.allocate(1024).setAutoExpand(true);
    
70.                 //加密规则，根据项目做修改
    
71.                 json = Des3.encode(json, "test");
    
72.                 //加压
    
73.                 byte[] bytes = ZLibUtils.compress(json.getBytes("UTF-8"));
    
74.                 //装bytes存入buff
    
75.                 buff.putInt(bytes.length);
    
76.                 buff.put(bytes);
    
77.                 buff.flip();
    
78.                 // 将buff转为 字节 再转为16进制
    
79.                 byte[] b = new byte[buff.limit()];
    
80.                 buff.get(b);
    
81.                 return b;
    
82.         }
    
83. 
    
84.         /**
    
85.          * byte数组转换成16进制字符串
    
86.          *
    
87.          * @param src
    
88.          * @return
    
89.          */
    
90.         public static String bytesToHexString(byte[] src) {
    
91.                 StringBuilder stringBuilder = new StringBuilder();
    
92.                 if (src == null || src.length <= 0) {
    
93.                         return null;
    
94.                 }
    
95.                 for (int i = 0; i < src.length; i++) {
    
96.                         int v = src[i] & 0xFF;
    
97.                         String hv = Integer.toHexString(v);
    
98.                         if (hv.length() < 2) {
    
99.                                 stringBuilder.append(0);
    
100.                         }
     
101.                         stringBuilder.append(hv);
     
102.                         stringBuilder.append("\\x");
     
103.                 }
     
104.                 //16进制前面要加\x
     
105.                 return ("\\x"+stringBuilder.substring(0,stringBuilder.length()-2)).toString();
     
106.         }
     
107.        
     
108.     /**
     
109.      * 字节流转int型   
     
110.      * @param b
     
111.      * @return
     
112.      */
     
113.     public static int b2i(byte[] b) {  
     
114.         int value = 0;  
     
115.         for (int i = 0; i < 4; i++) {  
     
116.         int shift = (4 - 1 - i) * 8;  
     
117.         value += (b[i] & 0x000000FF) << shift;  
     
118.         }  
     
119.         return value;  
     
120.     }
     
121. 
     
122. 
     
123.     /**客户端得接收服务端返回的iobuffer并转成json
     
124.      * 接收的iobuffer，前四个字节是表示字节流的长度，先接收前四个字节，并用16进制转10进制int型方法，得到长度的数字
     
125.      * 再根据长度接收所有的字节流。如果长度错误，拨收是会出错的。
     
126.      * @param is socket的输入流
     
127.      * @return json
     
128.      * @throws Exception
     
129.      */
     
130.     public static String getReceiveJson(InputStream is) throws Exception{
     
131.             byte[] intByte = new byte[4];  
     
132.         is.read(intByte);  
     
133.         int msgLength = b2i(intByte);  
     
134.         System.out.println("int:"+msgLength);  
     
135.         int readPosition = 0;  
     
136.         byte[] byteArray = new byte[msgLength];  
     
137.         while(readPosition < msgLength){  
     
138.             int value = is.read(byteArray, readPosition, msgLength-readPosition);  
     
139.             if(value == -1){  
     
140.                 break;  
     
141.             }  
     
142.             readPosition += value;  
     
143.         }  
     
144.                 byte[] data = ZLibUtils.decompress(byteArray); //解压
     
145.                 String code = new String(data, "UTF-8");
     
146.                 String text = Des3.decode(code, "test");        //解密
     
147.                 System.out.println("服务端接收消息内容为：="+text);
     
148.                 return text;
     
149.            
     
150.     }
     
151. }
     

复制代码

独慕

上一步是做什么的？

lsekfe

支持下~